Portal RPC

       (ptlrpc_request)
req -->|--------------|
       |              |
       | ...          |
       |              |            on-the-wire format
       |              |
       |--------------|            (lustre_msg_v2)
       | rq_reqbuf    |----------->|---------------|               ^
       |--------------|            | lm_bufcount   |               |
       | rq_reqbuf_len|            |---------------|               |
       |--------------|            |               |               |
       | rq_reqmsg    |-------*    |---------------|               |
       |--------------|       |    | ...           |               |
       | rq_reqlen    |       |    |---------------|               |
       |--------------|       |    | lm_buflens[0] |               | rq_reqbuf_len
       | ...          |       |    |---------------|               |
       |--------------|       |    | ...           |               |
       | rq_pill      |       |    |---------------|               |
       |              |       |    | lm_buflens[n] |               |
       |   |----------|       |    |---------------|               |
       |   | rc_fmt   |--*    |    | other buffers |               |
       |   |----------|  |    |    | (crypto, etc.)|               |
       |   | rc_area[]|  |    |    |---------------|               |
       |   |----------|  |    *--->| msg field[0]  | ^             |
       |--------------|  |         |---------------| |             |
                         |         | ...           | | rq_reqlen   |
   *---------------------*         |---------------| |             |
   |                               | msg field[n]  | v             v
   |                               |---------------|
   |
   |
   |   (req_format)
   *-->|-----------------------|
       | rf_name               |---> e.g. "LDLM_CANCEL"
       |-----------------------|
       | rf_idx                | = value set by req_layout_init()
       |-----------------------|
       | rf_fields[RCL_CLIENT] |------>|--------------| (array of req_msg_field)
       |-----------------------|       | rmf_flags    | = 0
       | rf_fields[RCL_SERVER] |--*    |--------------|
       |-----------------------|  |    | rmf_name     | = "ptlrpc_body"
                                  |    |--------------|
                                  |  0 | rmf_size     | = sizeof(struct ptlrpc_body)
   [reply req_msg_field array]<---*    |--------------|
                                       | rmf_swabber  | = lustre_swab_ptlrpc_body
                                       |--------------|
                                       | rmf_dumper   | = NULL
                                       |--------------|
                                       | rmf_offset   | = value set by req_layout_init()
                                    ---|--------------|
                                       | rmf_flags    | = RMF_F_NO_SIZE_CHECK
                                       |--------------|
                                       | rmf_name     | = "dlm_req"
                                       |--------------|
                                     1 | rmf_size     | = sizeof(struct ldlm_request)
                                       |--------------|
                                       | rmf_swabber  | = lustre_swab_ldlm_request
                                       |--------------|
                                       | rmf_dumper   | = NULL
                                       |--------------|
                                       | rmf_offset   | = value set by req_layout_init()
                                    ---|--------------|

/**
 * Structure to single define portal connection.
 */
struct ptlrpc_connection {
        /** linkage for connections hash table */
        struct hlist_node       c_hash;
        /** Our own lnet nid for this connection */
        lnet_nid_t              c_self;
        /** Remote side nid for this connection */
        lnet_process_id_t       c_peer;
        /** UUID of the other side */
        struct obd_uuid         c_remote_uuid;
        /** reference counter for this connection */
        atomic_t                c_refcount;
};

/** Client definition for PortalRPC */
struct ptlrpc_client {
        /** What lnet portal does this client send messages to by default */
        __u32                   cli_request_portal;
        /** What portal do we expect replies on */
        __u32                   cli_reply_portal;
        /** Name of the client */
        char                   *cli_name;
};

/**
 * Definition of request set structure.
 * Request set is a list of requests (not necessary to the same target) that
 * once populated with RPCs could be sent in parallel.
 * There are two kinds of request sets. General purpose and with dedicated
 * serving thread. Example of the latter is ptlrpcd set.
 * For general purpose sets once request set started sending it is impossible
 * to add new requests to such set.
 * Provides a way to call "completion callbacks" when all requests in the set
 * returned.
 */
struct ptlrpc_request_set {
        /** number of uncompleted requests */
        int               set_remaining;
        /** wait queue to wait on for request events */
        cfs_waitq_t       set_waitq;
        cfs_waitq_t      *set_wakeup_ptr;
        /** List of requests in the set */
        struct list_head  set_requests;
        /**
         * List of completion callbacks to be called when the set is completed
         * This is only used if \a set_interpret is NULL.
         * Links struct ptlrpc_set_cbdata.
         */
        struct list_head  set_cblist;
        /** Completion callback, if only one. */
        set_interpreter_func    set_interpret;
        /** opaq argument passed to completion \a set_interpret callback. */
        void              *set_arg;
        /**
         * Lock for \a set_new_requests manipulations
         * locked so that any old caller can communicate requests to
         * the set holder who can then fold them into the lock-free set
         */
        spinlock_t        set_new_req_lock;
        /** List of new yet unsent requests. Only used with ptlrpcd now. */
        struct list_head  set_new_requests;
};

/**
 * Description of a single ptrlrpc_set callback
 */
struct ptlrpc_set_cbdata {
        /** List linkage item */
        struct list_head        psc_item;
        /** Pointer to interpreting function */
        set_interpreter_func    psc_interpret;
        /** Opaque argument to pass to the callback */
        void                   *psc_data;
};

/**
 * Structure to define reply state on the server
 */
struct ptlrpc_reply_state {
        /** Callback description */
        struct ptlrpc_cb_id    rs_cb_id;
        /** Linkage for list of all reply states in a system */
        struct list_head       rs_list;
        /** Linkage for list of all reply states on same export */
        struct list_head       rs_exp_list;
        /** Linkage for list of all reply states for same obd */
        struct list_head       rs_obd_list;
#if RS_DEBUG
        struct list_head       rs_debug_list;
#endif
        /** A spinlock to protect the reply state flags */
        spinlock_t             rs_lock;
        /** Reply state flags */
        unsigned long          rs_difficult:1;     /* ACK/commit stuff */
        unsigned long          rs_no_ack:1;    /* no ACK, even for
                                                  difficult requests */
        unsigned long          rs_scheduled:1;     /* being handled? */
        unsigned long          rs_scheduled_ever:1;/* any schedule attempts? */
        unsigned long          rs_handled:1;  /* been handled yet? */
        unsigned long          rs_on_net:1;   /* reply_out_callback pending? */
        unsigned long          rs_prealloc:1; /* rs from prealloc list */
        unsigned long          rs_committed:1;/* the transaction was committed
                                                 and the rs was dispatched
                                                 by ptlrpc_commit_replies */
        /** Size of the state */
        int                    rs_size;
        /** opcode */
        __u32                  rs_opc;
        /** Transaction number */
        __u64                  rs_transno;
        /** xid */
        __u64                  rs_xid;
        struct obd_export     *rs_export;
        struct ptlrpc_service *rs_service;
        /** Lnet metadata handle for the reply */
        lnet_handle_md_t       rs_md_h;
        atomic_t               rs_refcount;

        /** Context for the sevice thread */
        struct ptlrpc_svc_ctx *rs_svc_ctx;
        /** Reply buffer (actually sent to the client), encoded if needed */
        struct lustre_msg     *rs_repbuf;       /* wrapper */
        /** Size of the reply buffer */
        int                    rs_repbuf_len;   /* wrapper buf length */
        /** Size of the reply message */
        int                    rs_repdata_len;  /* wrapper msg length */
        /**
         * Actual reply message. Its content is encrupted (if needed) to
         * produce reply buffer for actual sending. In simple case
         * of no network encryption we jus set \a rs_repbuf to \a rs_msg
         */
        struct lustre_msg     *rs_msg;          /* reply message */

        /** Number of locks awaiting client ACK */
        int                    rs_nlocks;
        /** Handles of locks awaiting client reply ACK */
        struct lustre_handle   rs_locks[RS_MAX_LOCKS];
        /** Lock modes of locks in \a rs_locks */
        ldlm_mode_t            rs_modes[RS_MAX_LOCKS];
};

/**
 * Definition of request pool structure.
 * The pool is used to store empty preallocated requests for the case
 * when we would actually need to send something without performing
 * any allocations (to avoid e.g. OOM).
 */
struct ptlrpc_request_pool {
        /** Locks the list */
        spinlock_t prp_lock;
        /** list of ptlrpc_request structs */
        struct list_head prp_req_list;
        /** Maximum message size that would fit into a rquest from this pool */
        int prp_rq_size;
        /** Function to allocate more requests for this pool */
        void (*prp_populate)(struct ptlrpc_request_pool *, int);
};

enum req_location {
        RCL_CLIENT,
        RCL_SERVER,
        RCL_NR
};

/* Maximal number of fields (buffers) in a request message. */
#define REQ_MAX_FIELD_NR  9

struct req_capsule {
        struct ptlrpc_request   *rc_req;
        const struct req_format *rc_fmt;
        enum req_location        rc_loc;
        __u32                    rc_area[RCL_NR][REQ_MAX_FIELD_NR];
};

struct req_format {
        const char *rf_name;
        int         rf_idx;
        struct {
                int                          nr;
                const struct req_msg_field **d;
        } rf_fields[RCL_NR];
};

        __u32       rmf_flags;
        const char *rmf_name;
        /**
         * Field length. (-1) means "variable length".  If the
         * \a RMF_F_STRUCT_ARRAY flag is set the field is also variable-length,
         * but the actual size must be a whole multiple of \a rmf_size.
         */
        int         rmf_size;
        void      (*rmf_swabber)(void *);
        void      (*rmf_dumper)(void *);
        int         rmf_offset[ARRAY_SIZE(req_formats)][RCL_NR];

/* without gss, ptlrpc_body is put at the first buffer. */
#define PTLRPC_NUM_VERSIONS     4
struct ptlrpc_body {
        struct lustre_handle pb_handle;
        __u32 pb_type;
        __u32 pb_version;
        __u32 pb_opc;
        __u32 pb_status;
        __u64 pb_last_xid;
        __u64 pb_last_seen;
        __u64 pb_last_committed;
        __u64 pb_transno;
        __u32 pb_flags;
        __u32 pb_op_flags;
        __u32 pb_conn_cnt;
        __u32 pb_timeout;  /* for req, the deadline, for rep, the service est */
        __u32 pb_service_time; /* for rep, actual service time */
        __u32 pb_limit;
        __u64 pb_slv;
        /* VBR: pre-versions */
        __u64 pb_pre_versions[PTLRPC_NUM_VERSIONS];
        /* padding for future needs */
        __u64 pb_padding[4];
};

/**
 * Represents remote procedure call.
 *
 * This is a staple structure used by everybody wanting to send a request
 * in Lustre.
 */
struct ptlrpc_request {
        /* Request type: one of PTL_RPC_MSG_* */
        int rq_type;
        /**
         * Linkage item through which this request is included into
         * sending/delayed lists on client and into rqbd list on server
         */
        struct list_head rq_list;
        /**
         * Server side list of incoming unserved requests sorted by arrival
         * time.  Traversed from time to time to notice about to expire
         * requests and sent back "early replies" to clients to let them
         * know server is alive and well, just very busy to service their
         * requests in time
         */
        struct list_head rq_timed_list;
        /** server-side history, used for debuging purposes. */
        struct list_head rq_history_list;
        /** server-side per-export list */
        struct list_head rq_exp_list;
        /** server-side hp handlers */
        struct ptlrpc_hpreq_ops *rq_ops;
        /** history sequence # */
        __u64            rq_history_seq;
        /** the index of service's srv_at_array into which request is linked */
        time_t rq_at_index;
        /** Result of request processing */
        int rq_status;
        /** Lock to protect request flags and some other important bits, like
         * rq_list
         */
        spinlock_t rq_lock;
        /** client-side flags are serialized by rq_lock */
        unsigned long rq_intr:1, rq_replied:1, rq_err:1,
                rq_timedout:1, rq_resend:1, rq_restart:1,
                /**
                 * when ->rq_replay is set, request is kept by the client even
                 * after server commits corresponding transaction. This is
                 * used for operations that require sequence of multiple
                 * requests to be replayed. The only example currently is file
                 * open/close. When last request in such a sequence is
                 * committed, ->rq_replay is cleared on all requests in the
                 * sequence.
                 */
                rq_replay:1,
                rq_no_resend:1, rq_waiting:1, rq_receiving_reply:1,
                rq_no_delay:1, rq_net_err:1, rq_wait_ctx:1,
                rq_early:1, rq_must_unlink:1,
                rq_fake:1,          /* this fake req */
                /* server-side flags */
                rq_packed_final:1,  /* packed final reply */
                rq_hp:1,            /* high priority RPC */
                rq_at_linked:1,     /* link into service's srv_at_array */
                rq_reply_truncate:1;

        enum rq_phase rq_phase; /* one of RQ_PHASE_* */
        enum rq_phase rq_next_phase; /* one of RQ_PHASE_* to be used next */
        atomic_t rq_refcount;   /* client-side refcount for SENT race,
                                   server-side refcounf for multiple replies */

        /** initial thread servicing this request */
        struct ptlrpc_thread *rq_svc_thread;

        /** Portal to which this request would be sent */
        int rq_request_portal;  /* XXX FIXME bug 249 */
        /** Portal where to wait for reply and where reply would be sent */
        int rq_reply_portal;    /* XXX FIXME bug 249 */

        /** client-side # reply bytes actually received  */
        int rq_nob_received;

        /** Request length */
        int rq_reqlen;
        /** Request message - what client sent */
        struct lustre_msg *rq_reqmsg;

        /** Reply length */
        int rq_replen;
        /** Reply message - server response */
        struct lustre_msg *rq_repmsg;
        /** Transaction number */
        __u64 rq_transno;
        /** xid */
        __u64 rq_xid;
        /**
         * List item to for replay list. Not yet commited requests get linked
         * there.
         * Also see \a rq_replay comment above.
         */
        struct list_head rq_replay_list;

        /**
         * security and encryption data
         * @{
        struct ptlrpc_cli_ctx   *rq_cli_ctx;     /* client's half ctx */
        struct ptlrpc_svc_ctx   *rq_svc_ctx;     /* server's half ctx */
        struct list_head         rq_ctx_chain;   /* link to waited ctx */

        struct sptlrpc_flavor    rq_flvr;        /* client & server */
        enum lustre_sec_part     rq_sp_from;

        unsigned long            /* client/server security flags */
                                 rq_ctx_init:1,      /* context initiation */
                                 rq_ctx_fini:1,      /* context destroy */
                                 rq_bulk_read:1,     /* request bulk read */
                                 rq_bulk_write:1,    /* request bulk write */
                                 /* server authentication flags */
                                 rq_auth_gss:1,      /* authenticated by gss */
                                 rq_auth_remote:1,   /* authed as remote user */
                                 rq_auth_usr_root:1, /* authed as root */
                                 rq_auth_usr_mdt:1,  /* authed as mdt */
                                 /* security tfm flags */
                                 rq_pack_udesc:1,
                                 rq_pack_bulk:1,
                                 /* doesn't expect reply FIXME */
                                 rq_no_reply:1,
                                 rq_pill_init:1;     /* pill initialized */

        uid_t                    rq_auth_uid;        /* authed uid */
        uid_t                    rq_auth_mapped_uid; /* authed uid mapped to */

        /* (server side), pointed directly into req buffer */
        struct ptlrpc_user_desc *rq_user_desc;

        /* @} */

        /** early replies go to offset 0, regular replies go after that */
        unsigned int             rq_reply_off;

        /* various buffer pointers */
        struct lustre_msg       *rq_reqbuf;      /* req wrapper */
        int                      rq_reqbuf_len;  /* req wrapper buf len */
        int                      rq_reqdata_len; /* req wrapper msg len */
        char                    *rq_repbuf;      /* rep buffer */
        int                      rq_repbuf_len;  /* rep buffer len */
        struct lustre_msg       *rq_repdata;     /* rep wrapper msg */
        int                      rq_repdata_len; /* rep wrapper msg len */
        struct lustre_msg       *rq_clrbuf;      /* only in priv mode */
        int                      rq_clrbuf_len;  /* only in priv mode */
        int                      rq_clrdata_len; /* only in priv mode */

        /** Fields that help to see if request and reply were swabbed or not */
        __u32 rq_req_swab_mask;
        __u32 rq_rep_swab_mask;

        /** What was import generation when this request was sent */
        int rq_import_generation;
        enum lustre_imp_state rq_send_state;

        /** how many early replies (for stats) */
        int rq_early_count;

        /** client+server request */
        lnet_handle_md_t     rq_req_md_h;
        struct ptlrpc_cb_id  rq_req_cbid;

        /** server-side fields: */
        /** request arrival time */
        struct timeval       rq_arrival_time;
        /** separated reply state */
        struct ptlrpc_reply_state *rq_reply_state;
        /** incoming request buffer */
        struct ptlrpc_request_buffer_desc *rq_rqbd;
#ifdef CRAY_XT3
        __u32                rq_uid;            /* peer uid, used in MDS only */
#endif

        /** client-only incoming reply: */
        lnet_handle_md_t     rq_reply_md_h;
        cfs_waitq_t          rq_reply_waitq;
        struct ptlrpc_cb_id  rq_reply_cbid;

        /** our LNet NID */
        lnet_nid_t           rq_self;
        /** Peer description */
        lnet_process_id_t    rq_peer;
        /** Server-side, export on which request was received */
        struct obd_export   *rq_export;
        /** Client side, import where request is being sent */
        struct obd_import   *rq_import;

        /** Replay callback, called after request is replayed at recovery */
        void (*rq_replay_cb)(struct ptlrpc_request *);
        /**
         * Commit callback, called when request is committed and about to be
         * freed.
         */
        void (*rq_commit_cb)(struct ptlrpc_request *);
        /** Opaq data for replay and commit callbacks. */
        void  *rq_cb_data;

        /** For bulk requests on clien only: bulk descriptor */
        struct ptlrpc_bulk_desc *rq_bulk;

        /** client outgoing req: */
        /**
         * when request/reply sent (secs), or time when request should be sent
         */
        time_t rq_sent;

        /** when request must finish. volatile
         * so that servers' early reply updates to the deadline aren't
         * kept in per-cpu cache */
        volatile time_t rq_deadline;
        /** when req reply unlink must finish. */
        time_t rq_reply_deadline;
        /** when req bulk unlink must finish. */
        time_t rq_bulk_deadline;
        /**
         * service time estimate (secs)
         * If requests is not served by this time, it is marked as timed out.
         */
        int    rq_timeout;

        /** Multi-rpc bits: */
        /** Link item for request set lists */
        struct list_head rq_set_chain;
        /** Link back to the request set */
        struct ptlrpc_request_set *rq_set;
        /** Async completion handler, called when reply is received */
        ptlrpc_interpterer_t rq_interpret_reply;
        /** Async completion context */
        union ptlrpc_async_args rq_async_args;

        /** Pool if request from preallocated list */
        struct ptlrpc_request_pool *rq_pool;

        struct lu_context           rq_session;
        struct lu_context           rq_recov_session;

        /** request format */
        struct req_capsule          rq_pill;
};

/**
 * Structure that defines a single page of a bulk transfer
 */
struct ptlrpc_bulk_page {
        /** Linkage to list of pages in a bulk */
        struct list_head bp_link;
        /**
         * Number of bytes in a page to transfer starting from \a bp_pageoffset
         */
        int              bp_buflen;
        /** offset within a page */
        int              bp_pageoffset;
        /** The page itself */
        struct page     *bp_page;
};

/**
 * Definition of buk descriptor.
 * Bulks are special "Two phase" RPCs where initial request message
 * is sent first and it is followed bt a transfer (o receiving) of a large
 * amount of data to be settled into pages referenced from the bulk descriptors.
 * Bulks transfers (the actual data following the small requests) are done
 * on separate LNet portals.
 * In lustre we use bulk transfers for READ and WRITE transfers from/to OSTs.
 *  Another user is readpage for MDT.
 */
struct ptlrpc_bulk_desc {
        /** completed successfully */
        unsigned long bd_success:1;
        /** accessible to the network (network io potentially in progress) */
        unsigned long bd_network_rw:1;
        /** {put,get}{source,sink} */
        unsigned long bd_type:2;
        /** client side */
        unsigned long bd_registered:1;
        /** For serialization with callback */
        spinlock_t   bd_lock;
        /** Import generation when request for this bulk was sent */
        int bd_import_generation;
        /** Server side - export this bulk created for */
        struct obd_export *bd_export;
        /** Client side - import this bulk was sent on */
        struct obd_import *bd_import;
        /** LNet portal for this bulk */
        __u32 bd_portal;
        /** Back pointer to the request */
        struct ptlrpc_request *bd_req;
        cfs_waitq_t            bd_waitq;        /* server side only WQ */
        int                    bd_iov_count;    /* # entries in bd_iov */
        int                    bd_max_iov;      /* allocated size of bd_iov */
        int                    bd_nob;          /* # bytes covered */
        int                    bd_nob_transferred; /* # bytes GOT/PUT */

        __u64                  bd_last_xid;

        struct ptlrpc_cb_id    bd_cbid;         /* network callback info */
        lnet_handle_md_t       bd_md_h;         /* associated MD */
        lnet_nid_t             bd_sender;       /* stash event::sender */

#if defined(__KERNEL__)
        /*
         * encrypt iov, size is either 0 or bd_iov_count.
         */
        lnet_kiov_t           *bd_enc_iov;

        lnet_kiov_t            bd_iov[0];
#else
        lnet_md_iovec_t        bd_iov[0];
#endif
};

/**
 * Definition of server service thread structure
 */
struct ptlrpc_thread {
        /**
         * List of active threads in svc->srv_threads
         */
        struct list_head t_link;
        /**
         * thread-private data (preallocated memory)
         */
        void *t_data;
        __u32 t_flags;
        /**
         * service thread index, from ptlrpc_start_threads
         */
        unsigned int t_id;
        /**
         * service thread pid
         */
        pid_t t_pid;
        /**
         * put watchdog in the structure per thread b=14840
         */
        struct lc_watchdog *t_watchdog;
        /**
         * the svc this thread belonged to b=18582
         */
        struct ptlrpc_service *t_svc;
        cfs_waitq_t t_ctl_waitq;
        struct lu_env *t_env;
};

/**
 * Request buffer descriptor structure.
 * This is a structure that contains one posted request buffer for service.
 * Once data land into a buffer, event callback creates actual request and
 * notifies wakes one of the service threads to process new incoming request.
 * More than one request can fit into the buffer.
 */
struct ptlrpc_request_buffer_desc {
        /** Link item for rqbds on a service */
        struct list_head       rqbd_list;
        /** History of requests for this buffer */
        struct list_head       rqbd_reqs;
        /** Back pointer to service for which this buffer is registered */
        struct ptlrpc_service *rqbd_service;
        /** LNet descriptor */
        lnet_handle_md_t       rqbd_md_h;
        int                    rqbd_refcount;
        /** The buffer itself */
        char                  *rqbd_buffer;
        struct ptlrpc_cb_id    rqbd_cbid;
        /**
         * This "embedded" request structure is only used for the
         * last request to fit into the buffer
         */
        struct ptlrpc_request  rqbd_req;
};

/**
 * Definition of PortalRPC service.
 * The service is listening on a particular portal (like tcp port)
 * and perform actions for a specific server like IO service for OST
 * or general metadata service for MDS.
 */
struct ptlrpc_service {
        struct list_head srv_list;              /* chain thru all services */
        int              srv_max_req_size;      /* biggest request to receive */
        int              srv_max_reply_size;    /* biggest reply to send */
        int              srv_buf_size;          /* size of individual buffers */
        int              srv_nbuf_per_group;    /* # buffers to allocate in 1 group */
        int              srv_nbufs;             /* total # req buffer descs allocated */
        int              srv_threads_min;       /* threads to start at SOW */
        int              srv_threads_max;       /* thread upper limit */
        int              srv_threads_started;   /* index of last started thread */
        int              srv_threads_running;   /* # running threads */
        atomic_t         srv_n_difficult_replies; /* # 'difficult' replies */
        int              srv_n_active_reqs;     /* # reqs being served */
        int              srv_n_hpreq;           /* # HPreqs being served */
        cfs_duration_t   srv_rqbd_timeout;      /* timeout before re-posting reqs, in tick */
        int              srv_watchdog_factor;   /* soft watchdog timeout multiplier */
        unsigned         srv_cpu_affinity:1;    /* bind threads to CPUs */
        unsigned         srv_at_check:1;        /* check early replies */
        unsigned         srv_is_stopping:1;     /* under unregister_service */
        cfs_time_t       srv_at_checktime;      /* debug */

        /** Local portal on which to receive requests */
        __u32            srv_req_portal;
        /** Portal on the client to send replies to */
        __u32            srv_rep_portal;

        /** AT stuff */
        /** @{ */
        struct adaptive_timeout srv_at_estimate;/* estimated rpc service time */
        spinlock_t        srv_at_lock;
        struct ptlrpc_at_array  srv_at_array;   /* reqs waiting for replies */
        cfs_timer_t       srv_at_timer;         /* early reply timer */
        /** @} */

        int               srv_n_queued_reqs;    /* # reqs in either of the queues below */
        int               srv_hpreq_count;      /* # hp requests handled */
        int               srv_hpreq_ratio;      /* # hp per lp reqs to handle */
        struct list_head  srv_req_in_queue;     /* incoming reqs */
        struct list_head  srv_request_queue;    /* reqs waiting for service */
        struct list_head  srv_request_hpq;      /* high priority queue */

        struct list_head  srv_request_history;  /* request history */
        __u64             srv_request_seq;      /* next request sequence # */
        __u64             srv_request_max_cull_seq; /* highest seq culled from history */
        svcreq_printfn_t  srv_request_history_print_fn; /* service-specific print fn */

        struct list_head  srv_idle_rqbds;       /* request buffers to be reposted */
        struct list_head  srv_active_rqbds;     /* req buffers receiving */
        struct list_head  srv_history_rqbds;    /* request buffer history */
        int               srv_nrqbd_receiving;  /* # posted request buffers */
        int               srv_n_history_rqbds;  /* # request buffers in history */
        int               srv_max_history_rqbds;/* max # request buffers in history */

        atomic_t          srv_outstanding_replies;
        struct list_head  srv_active_replies;   /* all the active replies */
#ifndef __KERNEL__
        struct list_head  srv_reply_queue;      /* replies waiting for service */
#endif
        cfs_waitq_t       srv_waitq; /* all threads sleep on this. This
                                      * wait-queue is signalled when new
                                      * incoming request arrives and when
                                      * difficult reply has to be handled. */

        struct list_head   srv_threads;         /* service thread list */
        /** Handler function for incoming requests for this service */
        svc_handler_t      srv_handler;
        svc_hpreq_handler_t srv_hpreq_handler;  /* hp request handler */

        char *srv_name; /* only statically allocated strings here; we don't clean them */
        char *srv_thread_name; /* only statically allocated strings here; we don't clean them */

        spinlock_t               srv_lock;

        /** Root of /proc dir tree for this service */
        cfs_proc_dir_entry_t    *srv_procroot;
        /** Pointer to statistic data for this service */
        struct lprocfs_stats    *srv_stats;

        /** List of free reply_states */
        struct list_head         srv_free_rs_list;
        /** waitq to run, when adding stuff to srv_free_rs_list */
        cfs_waitq_t              srv_free_rs_waitq;

        /**
         * Tags for lu_context associated with this thread, see struct
         * lu_context.
         */
        __u32                    srv_ctx_tags;
        /**
         * if non-NULL called during thread creation (ptlrpc_start_thread())
         * to initialize service specific per-thread state.
         */
        int (*srv_init)(struct ptlrpc_thread *thread);
        /**
         * if non-NULL called during thread shutdown (ptlrpc_main()) to
         * destruct state created by ->srv_init().
         */
        void (*srv_done)(struct ptlrpc_thread *thread);

        //struct ptlrpc_srv_ni srv_interfaces[0];
};

/**
 * Declaration of ptlrpcd control structure
 */
struct ptlrpcd_ctl {
        /**
         * Ptlrpc thread control flags (LIOD_START, LIOD_STOP, LIOD_FORCE)
         */
        unsigned long               pc_flags;
        /**
         * Thread lock protecting structure fields.
         */
        spinlock_t                  pc_lock;
        /**
         * Start completion.
         */
        struct completion           pc_starting;
        /**
         * Stop completion.
         */
        struct completion           pc_finishing;
        /**
         * Thread requests set.
         */
        struct ptlrpc_request_set  *pc_set;
        /**
         * Thread name used in cfs_daemonize()
         */
        char                        pc_name[16];
        /**
         * Environment for request interpreters to run in.
         */
        struct lu_env               pc_env;
#ifndef __KERNEL__
        /**
         * Async rpcs flag to make sure that ptlrpcd_check() is called only
         * once.
         */
        int                         pc_recurred;
        /**
         * Currently not used.
         */
        void                       *pc_callback;
        /**
         * User-space async rpcs callback.
         */
        void                       *pc_wait_callback;
        /**
         * User-space check idle rpcs callback.
         */
        void                       *pc_idle_callback;
#endif
};

/**
 * Export structure. Represents target-side of connection in portals.
 * Also used in Lustre to connect between layers on the same node when
 * there is no network-connection in-between.
 * For every connected client there is an export structure on the server
 * attached to the same obd device.
 */
struct obd_export {
        /**
         * Export handle, it's id is provided to client on connect
         * Subsequent client RPCs contain this handle id to identify
         * what export they are talking to.
         */
        struct portals_handle     exp_handle;
        atomic_t                  exp_refcount;
        /**
         * Set of counters below is to track where export references are
         * kept. The exp_rpc_count is used for reconnect handling also,
         * the cb_count and locks_count are for debug purposes only for now.
         * The sum of them should be less than exp_refcount by 3
         */
        atomic_t                  exp_rpc_count; /** RPC references */
        atomic_t                  exp_cb_count; /** Commit callback references */
        atomic_t                  exp_locks_count; /** Lock references */
#if LUSTRE_TRACKS_LOCK_EXP_REFS
        struct list_head          exp_locks_list;
        spinlock_t                exp_locks_list_guard;
#endif
        /** Number of queued replay requests to be processes */
        atomic_t                  exp_replay_count;
        /** UUID of client connected to this export */
        struct obd_uuid           exp_client_uuid;
        /** To link all exports on an obd device */
        struct list_head          exp_obd_chain;
        struct hlist_node         exp_uuid_hash; /** uuid-export hash*/
        struct hlist_node         exp_nid_hash; /** nid-export hash */
        /**
         * All exports eligible for ping evictor are linked into a list
         * through this field in "most time since last request on this export"
         * order
         * protected by obd_dev_lock
         */
        struct list_head          exp_obd_chain_timed;
        /** Obd device of this export */
        struct obd_device        *exp_obd;
        /** "reverse" import to send requests (e.g. from ldlm) back to client */
        struct obd_import        *exp_imp_reverse;
        struct nid_stat          *exp_nid_stats;
        struct lprocfs_stats     *exp_md_stats;
        /** Active connetion */
        struct ptlrpc_connection *exp_connection;
        /** Connection count value from last succesful reconnect rpc */
        __u32                     exp_conn_cnt;
        /** Hash list of all ldlm locks granted on this export */
        lustre_hash_t            *exp_lock_hash;
        /** lock to protect exp_lock_hash accesses */
        spinlock_t                exp_lock_hash_lock;
        struct list_head          exp_outstanding_replies;
        struct list_head          exp_uncommitted_replies;
        spinlock_t                exp_uncommitted_replies_lock;
        /** Last committed transno for this export */
        __u64                     exp_last_committed;
        /** When was last request received */
        cfs_time_t                exp_last_request_time;
        /** On replay all requests waiting for replay are linked here */
        struct list_head          exp_req_replay_queue;
        /** protects exp_flags and exp_outstanding_replies */
        spinlock_t                exp_lock;
        /** Compatibility flags for this export */
        __u64                     exp_connect_flags;
        enum obd_option           exp_flags;
        unsigned long             exp_failed:1,
                                  exp_in_recovery:1,
                                  exp_disconnected:1,
                                  exp_connecting:1,
                                  /** VBR: export missed recovery */
                                  exp_delayed:1,
                                  /** VBR: failed version checking */
                                  exp_vbr_failed:1,
                                  exp_req_replay_needed:1,
                                  exp_lock_replay_needed:1,
                                  exp_need_sync:1,
                                  exp_flvr_changed:1,
                                  exp_flvr_adapt:1,
                                  exp_libclient:1, /* liblustre client? */
                                  /* client timed out and tried to reconnect,
                                   * but couldn't because of active rpcs */
                                  exp_abort_active_req:1;
        struct list_head          exp_queued_rpc;  /* RPC to be handled */
        /* also protected by exp_lock */
        enum lustre_sec_part      exp_sp_peer;
        struct sptlrpc_flavor     exp_flvr;             /* current */
        struct sptlrpc_flavor     exp_flvr_old[2];      /* about-to-expire */
        cfs_time_t                exp_flvr_expire[2];   /* seconds */

        /** Target specific data */
        union {
                struct lu_export_data     eu_target_data;
                struct mdt_export_data    eu_mdt_data;
                struct filter_export_data eu_filter_data;
                struct ec_export_data     eu_ec_data;
        } u;
};

#define exp_target_data u.eu_target_data
#define exp_mdt_data    u.eu_mdt_data
#define exp_filter_data u.eu_filter_data
#define exp_ec_data     u.eu_ec_data

/**
 * Defintion of PortalRPC import structure.
 * Imports are representing client-side view to remote target.
 */
struct obd_import {
        /** Local handle (== id) for this import. */
        struct portals_handle     imp_handle;
        /** Reference handle */
        atomic_t                  imp_refcount;
        struct lustre_handle      imp_dlm_handle; /* client's ldlm export */
        /** Currently active connection */
        struct ptlrpc_connection *imp_connection;
        /** PortalRPC client structure for this import */
        struct ptlrpc_client     *imp_client;
        /** List element for linking into pinger chain */
        struct list_head          imp_pinger_chain;
        /** List element for linking into chain for destruction */
        struct list_head          imp_zombie_chain;

        /**
         * Lists of requests that are retained for replay, waiting for a reply,
         * or waiting for recovery to complete, respectively.
         * @{
         */
        struct list_head          imp_replay_list;
        struct list_head          imp_sending_list;
        struct list_head          imp_delayed_list;
        /** @} */

        /** obd device for this import */
        struct obd_device        *imp_obd;

        /**
         * some seciruty-related fields
         * @{
         */
        struct ptlrpc_sec        *imp_sec;
        struct semaphore          imp_sec_mutex;
        cfs_time_t                imp_sec_expire;
        /** @} */

        /** Wait queue for those who need to wait for recovery completion */
        cfs_waitq_t               imp_recovery_waitq;

        /** Number of requests currently in-flight */
        atomic_t                  imp_inflight;
        /** Number of requests currently unregistering */
        atomic_t                  imp_unregistering;
        /** Number of replay requests inflight */
        atomic_t                  imp_replay_inflight;
        /** Number of currently happening import invalidations */
        atomic_t                  imp_inval_count;
        /** Numbner of request timeouts */
        atomic_t                  imp_timeouts;
        /** Current import state */
        enum lustre_imp_state     imp_state;
        /** History of import states */
        struct import_state_hist  imp_state_hist[IMP_STATE_HIST_LEN];
        int                       imp_state_hist_idx;
        /** Current import generation. Incremented on every reconnect */
        int                       imp_generation;
        /** Incremented every time we send reconnection request */
        __u32                     imp_conn_cnt;
        /**
         * \see ptlrpc_free_committed remembers imp_generation value here
         * after a check to save on unnecessary replay list iterations
         */
        int                       imp_last_generation_checked;
        /** Last tranno we replayed */
        __u64                     imp_last_replay_transno;
        /** Last transno committed on remote side */
        __u64                     imp_peer_committed_transno;
        /**
         * \see ptlrpc_free_committed remembers last_transno since its last
         * check here and if last_transno did not change since last run of
         * ptlrpc_free_committed and import generation is the same, we can
         * skip looking for requests to remove from replay list as optimisation
         */
        __u64                     imp_last_transno_checked;
        /**
         * Remote export handle. This is how remote side knows what export
         * we are talking to. Filled from response to connect request
         */
        struct lustre_handle      imp_remote_handle;
        /** When to perform next ping. time in jiffies. */
        cfs_time_t                imp_next_ping;
        /** When we last succesfully connected. time in 64bit jiffies */
        __u64                     imp_last_success_conn;

        /** List of all possible connection for import. */
        struct list_head          imp_conn_list;
        /**
         * Current connection. \a imp_connection is imp_conn_current->oic_conn
         */
        struct obd_import_conn   *imp_conn_current;

        /** Protects flags, level, generation, conn_cnt, *_list */
        spinlock_t                imp_lock;

        /* flags */
        unsigned long             imp_no_timeout:1,       /* timeouts are disabled */
                                  imp_invalid:1,          /* evicted */
                                  imp_deactive:1,         /* administratively disabled */
                                  imp_replayable:1,       /* try to recover the import */
                                  imp_dlm_fake:1,         /* don't run recovery (timeout instead) */
                                  imp_server_timeout:1,   /* use 1/2 timeout on MDS' OSCs */
                                  imp_initial_recov:1,    /* retry the initial connection */
                                  imp_initial_recov_bk:1, /* turn off init_recov after trying all failover nids */
                                  imp_delayed_recovery:1, /* VBR: imp in delayed recovery */
                                  imp_no_lock_replay:1,   /* VBR: if gap was found then no lock replays */
                                  imp_vbr_failed:1,       /* recovery by versions was failed */
                                  imp_force_verify:1,     /* force an immidiate ping */
                                  imp_pingable:1,         /* pingable */
                                  imp_resend_replay:1,    /* resend for replay */
                                  imp_recon_bk:1,         /* turn off reconnect if all failovers fail */
                                  imp_last_recon:1,       /* internally used by above */
                                  imp_force_reconnect:1;  /* import must be reconnected instead of chouse new connection */
        __u32                     imp_connect_op;
        struct obd_connect_data   imp_connect_data;
        __u64                     imp_connect_flags_orig;
        int                       imp_connect_error;

        __u32                     imp_msg_magic;
        __u32                     imp_msghdr_flags;       /* adjusted based on server capability */

        struct ptlrpc_request_pool *imp_rq_pool;          /* emergency request pool */

        struct imp_at             imp_at;                 /* adaptive timeout data */
        time_t                    imp_last_reply_time;    /* for health check */
};

__init int ptlrpc_init(void);

static void __exit ptlrpc_exit(void);

struct ptlrpc_request *ptlrpc_request_alloc(struct obd_import *imp,
                                            const struct req_format *format);

struct ptlrpc_request *ptlrpc_request_alloc_pool(struct obd_import *imp,
                                                 struct ptlrpc_request_pool * pool,
                                                 const struct req_format *format)

static struct ptlrpc_request *
ptlrpc_request_alloc_internal(struct obd_import *imp,
                              struct ptlrpc_request_pool * pool,
                              const struct req_format *format)

void ptlrpc_request_free(struct ptlrpc_request *request);

struct ptlrpc_request *ptlrpc_request_alloc_pack(struct obd_import *imp,
                                                const struct req_format *format,
                                                __u32 version, int opcode)

int ptlrpc_request_pack(struct ptlrpc_request *request,
                        __u32 version, int opcode);

int ptlrpc_request_bufs_pack(struct ptlrpc_request *request,
                             __u32 version, int opcode, char **bufs,
                             struct ptlrpc_cli_ctx *ctx)

static int __ptlrpc_request_bufs_pack(struct ptlrpc_request *request,
                                      __u32 version, int opcode,
                                      int count, __u32 *lengths, char **bufs,
                                      struct ptlrpc_cli_ctx *ctx)

int lustre_pack_request(struct ptlrpc_request *req, __u32 magic, int count,
                        __u32 *lens, char **bufs)

int lustre_pack_request_v2(struct ptlrpc_request *req, int count,
                           __u32 *lens, char **bufs)

struct ptlrpc_request *
ptlrpc_prep_req(struct obd_import *imp, __u32 version, int opcode, int count,
                __u32 *lengths, char **bufs)

struct ptlrpc_request *
ptlrpc_prep_req_pool(struct obd_import *imp,
                     __u32 version, int opcode,
                     int count, __u32 *lengths, char **bufs,
                     struct ptlrpc_request_pool *pool)

int ptlrpc_queue_wait(struct ptlrpc_request *req);

struct ptlrpc_request_set *ptlrpc_prep_set(void);

void ptlrpc_set_destroy(struct ptlrpc_request_set *set);

void ptlrpc_set_wait(struct ptlrpc_request_set *set);

int ptlrpc_check_set(const struct lu_env *env, struct ptlrpc_request_set *set)

static int after_reply(struct ptlrpc_request *req);

int ptlrpc_expired_set(void *data);

int ptlrpc_expire_one_request(struct ptlrpc_request *req, int async_unlink);

int ptlrpc_interrupted_set(void *data);

static int ptlrpc_send_new_req(struct ptlrpc_request *req)

int ptl_send_rpc(struct ptlrpc_request *request, int noreply);

static int ptl_send_buf (lnet_handle_md_t *mdh, void *base, int len,
                         lnet_ack_req_t ack, struct ptlrpc_cb_id *cbid,
                         struct ptlrpc_connection *conn, int portal, __u64 xid,
                         unsigned int offset);

int ptlrpc_register_bulk(struct ptlrpc_request *req);

int ptlrpc_unregister_bulk(struct ptlrpc_request *req, int async);