staging: lustre: lnet: change lnet_handle_eq_t to proper struct

Change lnet_handle_eq_t from a typedef of another typedef into
a proper stand alone structure. Create the inline functions
LNetInvalidateEQHandle and LNetEQHandleIsInvalid to handle this
new piece of data.

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>

diff --git a/drivers/staging/lustre/include/linux/lnet/api.h b/drivers/staging/lustre/include/linux/lnet/api.h
index cb0d6b481455befde934478899b3197560aacdb2..1db4e00034620b459d87c9fb21198d57a6485b1c 100644 (file)
--- a/drivers/staging/lustre/include/linux/lnet/api.h
+++ b/drivers/staging/lustre/include/linux/lnet/api.h
@@ -147,7 +147,7 @@ int LNetMDUnlink(lnet_handle_md_t md_in);
  * associated with it. If an event handler exists, it will be run for each
  * event that is deposited into the EQ.
  *
- * In addition to the lnet_handle_eq_t, the LNet API defines two types
+ * 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
  * holds the information about with an event.
@@ -162,11 +162,11 @@ int LNetMDUnlink(lnet_handle_md_t md_in);
  */
 int LNetEQAlloc(unsigned int       count_in,
                lnet_eq_handler_t  handler,
-               lnet_handle_eq_t  *handle_out);
+               struct lnet_handle_eq *handle_out);
 
-int LNetEQFree(lnet_handle_eq_t eventq_in);
+int LNetEQFree(struct lnet_handle_eq eventq_in);
 
-int LNetEQPoll(lnet_handle_eq_t *eventqs_in,
+int LNetEQPoll(struct lnet_handle_eq *eventqs_in,
               int               neq_in,
               int               timeout_ms,
               lnet_event_t     *event_out,

diff --git a/drivers/staging/lustre/include/linux/lnet/lib-lnet.h b/drivers/staging/lustre/include/linux/lnet/lib-lnet.h
index 3d19402ba728bbe6fc7485be640e30d9ef401e99..808d886e98154078445fb4ba9abcd526a20be087 100644 (file)
--- a/drivers/staging/lustre/include/linux/lnet/lib-lnet.h
+++ b/drivers/staging/lustre/include/linux/lnet/lib-lnet.h
@@ -278,10 +278,10 @@ lnet_res_lh_invalidate(lnet_libhandle_t *lh)
 }
 
 static inline void
-lnet_eq2handle(lnet_handle_eq_t *handle, lnet_eq_t *eq)
+lnet_eq2handle(struct lnet_handle_eq *handle, lnet_eq_t *eq)
 {
        if (!eq) {
-               LNetInvalidateHandle(handle);
+               LNetInvalidateEQHandle(handle);
                return;
        }
 
@@ -289,7 +289,7 @@ lnet_eq2handle(lnet_handle_eq_t *handle, lnet_eq_t *eq)
 }
 
 static inline lnet_eq_t *
-lnet_handle2eq(lnet_handle_eq_t *handle)
+lnet_handle2eq(struct lnet_handle_eq *handle)
 {
        lnet_libhandle_t *lh;
 

diff --git a/drivers/staging/lustre/include/linux/lnet/lib-types.h b/drivers/staging/lustre/include/linux/lnet/lib-types.h
index 9850398bf29a44a3e9b45bd218132c44609ddf46..199e194669f8558c06980d7113e0b86570f5e20f 100644 (file)
--- a/drivers/staging/lustre/include/linux/lnet/lib-types.h
+++ b/drivers/staging/lustre/include/linux/lnet/lib-types.h
@@ -598,13 +598,13 @@ typedef struct {
        lnet_rtrbufpool_t               **ln_rtrpools;
 
        lnet_handle_md_t                  ln_ping_target_md;
-       lnet_handle_eq_t                  ln_ping_target_eq;
+       struct lnet_handle_eq             ln_ping_target_eq;
        struct lnet_ping_info            *ln_ping_info;
 
        /* router checker startup/shutdown state */
        int                               ln_rc_state;
        /* router checker's event queue */
-       lnet_handle_eq_t                  ln_rc_eqh;
+       struct lnet_handle_eq             ln_rc_eqh;
        /* rcd still pending on net */
        struct list_head                  ln_rcd_deathrow;
        /* rcd ready for free */

diff --git a/drivers/staging/lustre/include/linux/lnet/types.h b/drivers/staging/lustre/include/linux/lnet/types.h
index 1c8de72e6d6bb2f597b23cd90f9a3dd6cd2954ce..ebf87cd65ef4ec18ebdb0d71690c1f0d5dd9beab 100644 (file)
--- a/drivers/staging/lustre/include/linux/lnet/types.h
+++ b/drivers/staging/lustre/include/linux/lnet/types.h
@@ -284,7 +284,6 @@ typedef struct {
        __u64    cookie;
 } lnet_handle_any_t;
 
-typedef lnet_handle_any_t lnet_handle_eq_t;
 typedef lnet_handle_any_t lnet_handle_md_t;
 typedef lnet_handle_any_t lnet_handle_me_t;
 
@@ -318,6 +317,28 @@ static inline int LNetHandleIsInvalid(lnet_handle_any_t h)
        return h.cookie == LNET_WIRE_HANDLE_COOKIE_NONE;
 }
 
+struct lnet_handle_eq {
+       u64     cookie;
+};
+
+/**
+ * Invalidate eq handle @h.
+ */
+static inline void LNetInvalidateEQHandle(struct lnet_handle_eq *h)
+{
+       h->cookie = LNET_WIRE_HANDLE_COOKIE_NONE;
+}
+
+/**
+ * Check whether eq handle @h is invalid.
+ *
+ * @return 1 if handle is invalid, 0 if valid.
+ */
+static inline int LNetEQHandleIsInvalid(struct lnet_handle_eq h)
+{
+       return (LNET_WIRE_HANDLE_COOKIE_NONE == h.cookie);
+}
+
 /**
  * Global process ID.
  */
@@ -461,7 +482,7 @@ typedef struct {
         * by LNetInvalidateHandle()), operations performed on this memory
         * descriptor are not logged.
         */
-       lnet_handle_eq_t eq_handle;
+       struct lnet_handle_eq eq_handle;
 } lnet_md_t;
 
 /*

diff --git a/drivers/staging/lustre/lnet/lnet/api-ni.c b/drivers/staging/lustre/lnet/lnet/api-ni.c
index 08b38ef67784bef82e647fe4d5e58c3bb1675451..0564e93fb6d922df3b14807d4f6d693adc68a96c 100644 (file)
--- a/drivers/staging/lustre/lnet/lnet/api-ni.c
+++ b/drivers/staging/lustre/lnet/lnet/api-ni.c
@@ -1433,7 +1433,7 @@ int lnet_lib_init(void)
        }
 
        the_lnet.ln_refcount = 0;
-       LNetInvalidateHandle(&the_lnet.ln_rc_eqh);
+       LNetInvalidateEQHandle(&the_lnet.ln_rc_eqh);
        INIT_LIST_HEAD(&the_lnet.ln_lnds);
        INIT_LIST_HEAD(&the_lnet.ln_rcd_zombie);
        INIT_LIST_HEAD(&the_lnet.ln_rcd_deathrow);
@@ -2138,7 +2138,7 @@ EXPORT_SYMBOL(LNetSnprintHandle);
 static int lnet_ping(lnet_process_id_t id, int timeout_ms,
                     lnet_process_id_t __user *ids, int n_ids)
 {
-       lnet_handle_eq_t eqh;
+       struct lnet_handle_eq eqh;
        lnet_handle_md_t mdh;
        lnet_event_t event;
        lnet_md_t md = { NULL };

diff --git a/drivers/staging/lustre/lnet/lnet/lib-eq.c b/drivers/staging/lustre/lnet/lnet/lib-eq.c
index d05c6cc797f676ba42ae397e4bfa99d7d4ab57f2..6645fdcfac4421f9f3eb42dceff9a85067738c8e 100644 (file)
--- a/drivers/staging/lustre/lnet/lnet/lib-eq.c
+++ b/drivers/staging/lustre/lnet/lnet/lib-eq.c
@@ -64,7 +64,7 @@
  */
 int
 LNetEQAlloc(unsigned int count, lnet_eq_handler_t callback,
-           lnet_handle_eq_t *handle)
+           struct lnet_handle_eq *handle)
 {
        lnet_eq_t *eq;
 
@@ -152,7 +152,7 @@ EXPORT_SYMBOL(LNetEQAlloc);
  * \retval -EBUSY  If the EQ is still in use by some MDs.
  */
 int
-LNetEQFree(lnet_handle_eq_t eqh)
+LNetEQFree(struct lnet_handle_eq eqh)
 {
        struct lnet_eq *eq;
        lnet_event_t *events = NULL;
@@ -370,7 +370,7 @@ __must_hold(&the_lnet.ln_eq_wait_lock)
  * \retval -ENOENT    If there's an invalid handle in \a eventqs.
  */
 int
-LNetEQPoll(lnet_handle_eq_t *eventqs, int neq, int timeout_ms,
+LNetEQPoll(struct lnet_handle_eq *eventqs, int neq, int timeout_ms,
           lnet_event_t *event, int *which)
 {
        int wait = 1;

diff --git a/drivers/staging/lustre/lnet/lnet/lib-md.c b/drivers/staging/lustre/lnet/lnet/lib-md.c
index eab53cd5729645995f25b595d8789de676bf1662..d97e046103454563c2804722968d5959cdd781fd 100644 (file)
--- a/drivers/staging/lustre/lnet/lnet/lib-md.c
+++ b/drivers/staging/lustre/lnet/lnet/lib-md.c
@@ -165,7 +165,7 @@ lnet_md_build(lnet_libmd_t *lmd, lnet_md_t *umd, int unlink)
 
 /* must be called with resource lock held */
 static int
-lnet_md_link(lnet_libmd_t *md, lnet_handle_eq_t eq_handle, int cpt)
+lnet_md_link(lnet_libmd_t *md, struct lnet_handle_eq eq_handle, int cpt)
 {
        struct lnet_res_container *container = the_lnet.ln_md_containers[cpt];
 
@@ -185,7 +185,7 @@ lnet_md_link(lnet_libmd_t *md, lnet_handle_eq_t eq_handle, int cpt)
         * maybe there we shouldn't even allow LNET_EQ_NONE!)
         * LASSERT(!eq);
         */
-       if (!LNetHandleIsInvalid(eq_handle)) {
+       if (!LNetEQHandleIsInvalid(eq_handle)) {
                md->md_eq = lnet_handle2eq(&eq_handle);
 
                if (!md->md_eq)

diff --git a/drivers/staging/lustre/lnet/lnet/router.c b/drivers/staging/lustre/lnet/lnet/router.c
index cf22525d7129bcf9e9b20d9110abd64fcbbeb552..ba80221a6cca09cba1014758ef623af9116e1b26 100644 (file)
--- a/drivers/staging/lustre/lnet/lnet/router.c
+++ b/drivers/staging/lustre/lnet/lnet/router.c
@@ -933,7 +933,7 @@ lnet_create_rc_data_locked(lnet_peer_t *gateway)
        md.options = LNET_MD_TRUNCATE;
        md.eq_handle = the_lnet.ln_rc_eqh;
 
-       LASSERT(!LNetHandleIsInvalid(the_lnet.ln_rc_eqh));
+       LASSERT(!LNetEQHandleIsInvalid(the_lnet.ln_rc_eqh));
        rc = LNetMDBind(md, LNET_UNLINK, &rcd->rcd_mdh);
        if (rc < 0) {
                CERROR("Can't bind MD: %d\n", rc);

diff --git a/drivers/staging/lustre/lnet/selftest/rpc.c b/drivers/staging/lustre/lnet/selftest/rpc.c
index 87fe366f8f70312df1c571aa2c6ee240b7c2cdc5..41dd24f33dc593086d7404c791afbdf8def05ad9 100644 (file)
--- a/drivers/staging/lustre/lnet/selftest/rpc.c
+++ b/drivers/staging/lustre/lnet/selftest/rpc.c
@@ -53,7 +53,7 @@ enum srpc_state {
 static struct smoketest_rpc {
        spinlock_t       rpc_glock;     /* global lock */
        struct srpc_service     *rpc_services[SRPC_SERVICE_MAX_ID + 1];
-       lnet_handle_eq_t rpc_lnet_eq;   /* _the_ LNet event queue */
+       struct lnet_handle_eq    rpc_lnet_eq;   /* _the_ LNet event queue */
        enum srpc_state  rpc_state;
        struct srpc_counters     rpc_counters;
        __u64            rpc_matchbits; /* matchbits counter */
@@ -1622,7 +1622,7 @@ srpc_startup(void)
 
        srpc_data.rpc_state = SRPC_STATE_NI_INIT;
 
-       LNetInvalidateHandle(&srpc_data.rpc_lnet_eq);
+       LNetInvalidateEQHandle(&srpc_data.rpc_lnet_eq);
        rc = LNetEQAlloc(0, srpc_lnet_ev_handler, &srpc_data.rpc_lnet_eq);
        if (rc) {
                CERROR("LNetEQAlloc() has failed: %d\n", rc);

diff --git a/drivers/staging/lustre/lustre/include/lustre_net.h b/drivers/staging/lustre/lustre/include/lustre_net.h
index 1b48df0d486298858960aef0152d781d5d43dddc..7955cbf9e7596703c56addc7f3d09c3bb5f4e7ca 100644 (file)
--- a/drivers/staging/lustre/lustre/include/lustre_net.h
+++ b/drivers/staging/lustre/lustre/include/lustre_net.h
@@ -1749,7 +1749,7 @@ static inline bool nrs_policy_compat_one(const struct ptlrpc_service *svc,
 /** @} nrs */
 
 /* ptlrpc/events.c */
-extern lnet_handle_eq_t ptlrpc_eq_h;
+extern struct lnet_handle_eq ptlrpc_eq_h;
 int ptlrpc_uuid_to_peer(struct obd_uuid *uuid,
                        lnet_process_id_t *peer, lnet_nid_t *self);
 /**

diff --git a/drivers/staging/lustre/lustre/ptlrpc/events.c b/drivers/staging/lustre/lustre/ptlrpc/events.c
index dc0fe9d660dabef82c3c1049a73a869402d55bc7..ca11b0314b3cd709f41592b12cf3b99065a2a68f 100644 (file)
--- a/drivers/staging/lustre/lustre/ptlrpc/events.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/events.c
@@ -42,7 +42,7 @@
 #include "../include/lustre_sec.h"
 #include "ptlrpc_internal.h"
 
-lnet_handle_eq_t   ptlrpc_eq_h;
+struct lnet_handle_eq ptlrpc_eq_h;
 
 /*
  *  Client's outgoing request callback