Change lnet_event_t from typedef to proper structure.
Signed-off-by: James Simmons <uja.ornl@yahoo.com>
Reviewed-on: https://review.whamcloud.com/20831
Reviewed-by: Olaf Weber <olaf@sgi.com>
Reviewed-by: Doug Oucharek <doug.s.oucharek@intel.com>
Reviewed-by: Dmitry Eremin <dmitry.eremin@intel.com>
Reviewed-by: Oleg Drokin <oleg.drokin@intel.com>
Signed-off-by: James Simmons <jsimmons@infradead.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
  *
  * In addition to the lnet_handle_eq, the LNet API defines two types
  * associated with events: The ::lnet_event_kind_t defines the kinds of events
- * that can be stored in an EQ. The lnet_event_t defines a structure that
+ * that can be stored in an EQ. The lnet_event defines a structure that
  * holds the information about with an event.
  *
  * There are five functions for dealing with EQs: LNetEQAlloc() is used to
 int LNetEQPoll(struct lnet_handle_eq *eventqs_in,
               int               neq_in,
               int               timeout_ms,
-              lnet_event_t     *event_out,
+              struct lnet_event *event_out,
               int              *which_eq_out);
 /** @} lnet_eq */
 
 
 void lnet_msg_attach_md(struct lnet_msg *msg, struct lnet_libmd *md,
                        unsigned int offset, unsigned int mlen);
 void lnet_msg_detach_md(struct lnet_msg *msg, int status);
-void lnet_build_unlink_event(struct lnet_libmd *md, lnet_event_t *ev);
+void lnet_build_unlink_event(struct lnet_libmd *md, struct lnet_event *ev);
 void lnet_build_msg_event(struct lnet_msg *msg, lnet_event_kind_t ev_type);
 void lnet_msg_commit(struct lnet_msg *msg, int cpt);
 void lnet_msg_decommit(struct lnet_msg *msg, int cpt, int status);
 
-void lnet_eq_enqueue_event(struct lnet_eq *eq, lnet_event_t *ev);
+void lnet_eq_enqueue_event(struct lnet_eq *eq, struct lnet_event *ev);
 void lnet_prep_send(struct lnet_msg *msg, int type, lnet_process_id_t target,
                    unsigned int offset, unsigned int len);
 int lnet_send(lnet_nid_t nid, struct lnet_msg *msg, lnet_nid_t rtr_nid);
 
        struct kvec             *msg_iov;
        lnet_kiov_t             *msg_kiov;
 
-       lnet_event_t             msg_ev;
+       struct lnet_event        msg_ev;
        struct lnet_hdr          msg_hdr;
 };
 
        lnet_seq_t                eq_deq_seq;
        unsigned int              eq_size;
        lnet_eq_handler_t         eq_callback;
-       lnet_event_t             *eq_events;
+       struct lnet_event        *eq_events;
        int                     **eq_refs;      /* percpt refcount for EQ */
 };
 
 
 /**
  * Information about an event on a MD.
  */
-typedef struct {
+struct lnet_event {
        /** The identifier (nid, pid) of the target. */
        lnet_process_id_t       target;
        /** The identifier (nid, pid) of the initiator. */
         * to each event.
         */
        volatile lnet_seq_t     sequence;
-} lnet_event_t;
+};
 
 /**
  * Event queue handler function type.
  * The handler must not block, must be reentrant, and must not call any LNet
  * API functions. It should return as quickly as possible.
  */
-typedef void (*lnet_eq_handler_t)(lnet_event_t *event);
+typedef void (*lnet_eq_handler_t)(struct lnet_event *event);
 #define LNET_EQ_HANDLER_NONE NULL
 /** @} lnet_eq */
 
 
 }
 
 static void
-lnet_ping_event_handler(lnet_event_t *event)
+lnet_ping_event_handler(struct lnet_event *event)
 {
        struct lnet_ping_info *pinfo = event->md.user_ptr;
 
 {
        struct lnet_handle_eq eqh;
        struct lnet_handle_md mdh;
-       lnet_event_t event;
+       struct lnet_event event;
        struct lnet_md md = { NULL };
        int which;
        int unlinked = 0;
 
                return -ENOMEM;
 
        if (count) {
-               LIBCFS_ALLOC(eq->eq_events, count * sizeof(lnet_event_t));
+               LIBCFS_ALLOC(eq->eq_events, count * sizeof(struct lnet_event));
                if (!eq->eq_events)
                        goto failed;
                /*
 
 failed:
        if (eq->eq_events)
-               LIBCFS_FREE(eq->eq_events, count * sizeof(lnet_event_t));
+               LIBCFS_FREE(eq->eq_events, count * sizeof(struct lnet_event));
 
        if (eq->eq_refs)
                cfs_percpt_free(eq->eq_refs);
 LNetEQFree(struct lnet_handle_eq eqh)
 {
        struct lnet_eq *eq;
-       lnet_event_t *events = NULL;
+       struct lnet_event *events = NULL;
        int **refs = NULL;
        int *ref;
        int rc = 0;
        lnet_res_unlock(LNET_LOCK_EX);
 
        if (events)
-               LIBCFS_FREE(events, size * sizeof(lnet_event_t));
+               LIBCFS_FREE(events, size * sizeof(struct lnet_event));
        if (refs)
                cfs_percpt_free(refs);
 
 EXPORT_SYMBOL(LNetEQFree);
 
 void
-lnet_eq_enqueue_event(struct lnet_eq *eq, lnet_event_t *ev)
+lnet_eq_enqueue_event(struct lnet_eq *eq, struct lnet_event *ev)
 {
        /* MUST called with resource lock hold but w/o lnet_eq_wait_lock */
        int index;
 }
 
 static int
-lnet_eq_dequeue_event(struct lnet_eq *eq, lnet_event_t *ev)
+lnet_eq_dequeue_event(struct lnet_eq *eq, struct lnet_event *ev)
 {
        int new_index = eq->eq_deq_seq & (eq->eq_size - 1);
-       lnet_event_t *new_event = &eq->eq_events[new_index];
+       struct lnet_event *new_event = &eq->eq_events[new_index];
        int rc;
 
        /* must called with lnet_eq_wait_lock hold */
  */
 int
 LNetEQPoll(struct lnet_handle_eq *eventqs, int neq, int timeout_ms,
-          lnet_event_t *event, int *which)
+          struct lnet_event *event, int *which)
 {
        int wait = 1;
        int rc;
 
 int
 LNetMDUnlink(struct lnet_handle_md mdh)
 {
-       lnet_event_t ev;
+       struct lnet_event ev;
        struct lnet_libmd *md;
        int cpt;
 
 
 {
        struct lnet_me *me;
        struct lnet_libmd *md;
-       lnet_event_t ev;
+       struct lnet_event ev;
        int cpt;
 
        LASSERT(the_lnet.ln_refcount > 0);
 
  * \retval -ENOMEM Memory allocation failure.
  * \retval -ENOENT Invalid MD object.
  *
- * \see lnet_event_t::hdr_data and lnet_event_kind_t.
+ * \see lnet_event::hdr_data and lnet_event_kind_t.
  */
 int
 LNetPut(lnet_nid_t self, struct lnet_handle_md mdh, lnet_ack_req_t ack,
 
 #include "../../include/linux/lnet/lib-lnet.h"
 
 void
-lnet_build_unlink_event(struct lnet_libmd *md, lnet_event_t *ev)
+lnet_build_unlink_event(struct lnet_libmd *md, struct lnet_event *ev)
 {
        memset(ev, 0, sizeof(*ev));
 
 lnet_build_msg_event(struct lnet_msg *msg, lnet_event_kind_t ev_type)
 {
        struct lnet_hdr *hdr = &msg->msg_hdr;
-       lnet_event_t *ev  = &msg->msg_ev;
+       struct lnet_event *ev  = &msg->msg_ev;
 
        LASSERT(!msg->msg_routing);
 
 lnet_msg_decommit_tx(struct lnet_msg *msg, int status)
 {
        struct lnet_counters    *counters;
-       lnet_event_t *ev = &msg->msg_ev;
+       struct lnet_event *ev = &msg->msg_ev;
 
        LASSERT(msg->msg_tx_committed);
        if (status)
 lnet_msg_decommit_rx(struct lnet_msg *msg, int status)
 {
        struct lnet_counters *counters;
-       lnet_event_t *ev = &msg->msg_ev;
+       struct lnet_event *ev = &msg->msg_ev;
 
        LASSERT(!msg->msg_tx_committed); /* decommitted or never committed */
        LASSERT(msg->msg_rx_committed);
 
 }
 
 static void
-lnet_router_checker_event(lnet_event_t *event)
+lnet_router_checker_event(struct lnet_event *event)
 {
        struct lnet_rc_data *rcd = event->md.user_ptr;
        struct lnet_peer *lp;
 
 
 /* when in kernel always called with LNET_LOCK() held, and in thread context */
 static void
-srpc_lnet_ev_handler(lnet_event_t *ev)
+srpc_lnet_ev_handler(struct lnet_event *ev)
 {
        struct srpc_service_cd *scd;
        struct srpc_event *rpcev = ev->md.user_ptr;
 
  * ptlrpc callback & work item stuff
  */
 struct ptlrpc_cb_id {
-       void   (*cbid_fn)(lnet_event_t *ev);     /* specific callback fn */
+       void   (*cbid_fn)(struct lnet_event *ev); /* specific callback fn */
        void    *cbid_arg;                    /* additional arg */
 };
 
  * underlying buffer
  * @{
  */
-void request_out_callback(lnet_event_t *ev);
-void reply_in_callback(lnet_event_t *ev);
-void client_bulk_callback(lnet_event_t *ev);
-void request_in_callback(lnet_event_t *ev);
-void reply_out_callback(lnet_event_t *ev);
+void request_out_callback(struct lnet_event *ev);
+void reply_in_callback(struct lnet_event *ev);
+void client_bulk_callback(struct lnet_event *ev);
+void request_in_callback(struct lnet_event *ev);
+void reply_out_callback(struct lnet_event *ev);
 /** @} */
 
 /* ptlrpc/connection.c */
 
 /*
  *  Client's outgoing request callback
  */
-void request_out_callback(lnet_event_t *ev)
+void request_out_callback(struct lnet_event *ev)
 {
        struct ptlrpc_cb_id *cbid = ev->md.user_ptr;
        struct ptlrpc_request *req = cbid->cbid_arg;
 /*
  * Client's incoming reply callback
  */
-void reply_in_callback(lnet_event_t *ev)
+void reply_in_callback(struct lnet_event *ev)
 {
        struct ptlrpc_cb_id *cbid = ev->md.user_ptr;
        struct ptlrpc_request *req = cbid->cbid_arg;
 /*
  * Client's bulk has been written/read
  */
-void client_bulk_callback(lnet_event_t *ev)
+void client_bulk_callback(struct lnet_event *ev)
 {
        struct ptlrpc_cb_id *cbid = ev->md.user_ptr;
        struct ptlrpc_bulk_desc *desc = cbid->cbid_arg;
 /*
  * Server's incoming request callback
  */
-void request_in_callback(lnet_event_t *ev)
+void request_in_callback(struct lnet_event *ev)
 {
        struct ptlrpc_cb_id *cbid = ev->md.user_ptr;
        struct ptlrpc_request_buffer_desc *rqbd = cbid->cbid_arg;
 /*
  *  Server's outgoing reply callback
  */
-void reply_out_callback(lnet_event_t *ev)
+void reply_out_callback(struct lnet_event *ev)
 {
        struct ptlrpc_cb_id *cbid = ev->md.user_ptr;
        struct ptlrpc_reply_state *rs = cbid->cbid_arg;
        }
 }
 
-static void ptlrpc_master_callback(lnet_event_t *ev)
+static void ptlrpc_master_callback(struct lnet_event *ev)
 {
        struct ptlrpc_cb_id *cbid = ev->md.user_ptr;
-       void (*callback)(lnet_event_t *ev) = cbid->cbid_fn;
+       void (*callback)(struct lnet_event *ev) = cbid->cbid_fn;
 
        /* Honestly, it's best to find out early. */
        LASSERT(cbid->cbid_arg != LP_POISON);