Whamcloud - gitweb
LU-6142 lnet: remove most of typedefs from LNet headers 31/20831/10
authorJames Simmons <uja.ornl@yahoo.com>
Tue, 7 Feb 2017 15:55:49 +0000 (10:55 -0500)
committerOleg Drokin <oleg.drokin@intel.com>
Wed, 15 Feb 2017 01:02:49 +0000 (01:02 +0000)
Remove the majority of typedefs from the LNet headers.
Change them into structures instead. Currently only
lnet_nid_t, lnet_pid_t, and lnet_kiov_t are left.

Test-Parameters: trivial

Change-Id: Ib083d305ab945bab8d78ac96d17015550c0f9486
Signed-off-by: James Simmons <uja.ornl@yahoo.com>
Reviewed-on: https://review.whamcloud.com/20831
Reviewed-by: Olaf Weber <olaf@sgi.com>
Tested-by: Jenkins
Reviewed-by: Doug Oucharek <doug.s.oucharek@intel.com>
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: Dmitry Eremin <dmitry.eremin@intel.com>
Reviewed-by: Oleg Drokin <oleg.drokin@intel.com>
57 files changed:
libcfs/libcfs/util/nidstrings.c
lnet/include/lnet/api.h
lnet/include/lnet/lib-lnet.h
lnet/include/lnet/lib-types.h
lnet/include/lnet/lnetst.h
lnet/include/lnet/nidstr.h
lnet/include/lnet/socklnd.h
lnet/include/lnet/types.h
lnet/klnds/gnilnd/gnilnd.h
lnet/klnds/gnilnd/gnilnd_cb.c
lnet/klnds/o2iblnd/o2iblnd.c
lnet/klnds/o2iblnd/o2iblnd.h
lnet/klnds/o2iblnd/o2iblnd_cb.c
lnet/klnds/o2iblnd/o2iblnd_modparams.c
lnet/klnds/socklnd/socklnd.c
lnet/klnds/socklnd/socklnd.h
lnet/klnds/socklnd/socklnd_cb.c
lnet/klnds/socklnd/socklnd_proto.c
lnet/lnet/acceptor.c
lnet/lnet/api-ni.c
lnet/lnet/lib-eq.c
lnet/lnet/lib-md.c
lnet/lnet/lib-me.c
lnet/lnet/lib-move.c
lnet/lnet/lib-msg.c
lnet/lnet/lib-ptl.c
lnet/lnet/lo.c
lnet/lnet/net_fault.c
lnet/lnet/nidstrings.c
lnet/lnet/router.c
lnet/lnet/router_proc.c
lnet/selftest/brw_test.c
lnet/selftest/conrpc.c
lnet/selftest/console.c
lnet/selftest/console.h
lnet/selftest/framework.c
lnet/selftest/ping_test.c
lnet/selftest/rpc.c
lnet/selftest/rpc.h
lnet/selftest/selftest.h
lnet/utils/lst.c
lnet/utils/portals.c
lnet/utils/wirecheck.c
lustre/include/lustre_net.h
lustre/ldlm/ldlm_lockd.c
lustre/llite/llite_lib.c
lustre/llite/super25.c
lustre/obdclass/obd_mount.c
lustre/obdclass/obd_mount_server.c
lustre/osc/osc_request.c
lustre/ptlrpc/client.c
lustre/ptlrpc/connection.c
lustre/ptlrpc/events.c
lustre/ptlrpc/niobuf.c
lustre/ptlrpc/nodemap_handler.c
lustre/ptlrpc/pers.c
lustre/ptlrpc/ptlrpc_internal.h

index 18fcae2..baed3a2 100644 (file)
@@ -588,7 +588,7 @@ libcfs_str2nid(const char *str)
 }
 
 char *
-libcfs_id2str(lnet_process_id_t id)
+libcfs_id2str(struct lnet_process_id id)
 {
        char *str = libcfs_next_nidstring();
 
index 337b986..4fa2f66 100644 (file)
@@ -75,9 +75,8 @@ int LNetNIFini(void);
  *
  * \see LNetMEAttach
  * @{ */
-int LNetGetId(unsigned int index, lnet_process_id_t *id);
+int LNetGetId(unsigned int index, struct lnet_process_id *id);
 int LNetDist(lnet_nid_t nid, lnet_nid_t *srcnid, __u32 *order);
-void LNetSnprintHandle(char *str, int str_len, lnet_handle_any_t handle);
 lnet_nid_t LNetPrimaryNID(lnet_nid_t nid);
 
 /** @} lnet_addr */
@@ -96,22 +95,22 @@ lnet_nid_t LNetPrimaryNID(lnet_nid_t nid);
  * and LNetMEInsert(), and removed from its list by LNetMEUnlink().
  * @{ */
 int LNetMEAttach(unsigned int     portal,
-                lnet_process_id_t match_id_in,
+                struct lnet_process_id match_id_in,
                 __u64             match_bits_in,
                 __u64             ignore_bits_in,
-                lnet_unlink_t     unlink_in,
-                lnet_ins_pos_t    pos_in,
-                lnet_handle_me_t *handle_out);
+                enum lnet_unlink       unlink_in,
+                enum lnet_ins_pos      pos_in,
+                struct lnet_handle_me  *handle_out);
 
-int LNetMEInsert(lnet_handle_me_t  current_in,
-                lnet_process_id_t match_id_in,
+int LNetMEInsert(struct lnet_handle_me current_in,
+                struct lnet_process_id match_id_in,
                 __u64             match_bits_in,
                 __u64             ignore_bits_in,
-                lnet_unlink_t     unlink_in,
-                lnet_ins_pos_t    position_in,
-                lnet_handle_me_t *handle_out);
+                enum lnet_unlink  unlink_in,
+                enum lnet_ins_pos position_in,
+                struct lnet_handle_me *handle_out);
 
-int LNetMEUnlink(lnet_handle_me_t current_in);
+int LNetMEUnlink(struct lnet_handle_me current_in);
 /** @} lnet_me */
 
 /** \defgroup lnet_md Memory descriptors
@@ -126,16 +125,16 @@ int LNetMEUnlink(lnet_handle_me_t current_in);
  * and LNetMDBind(); one operation to unlink and release the resources
  * associated with a MD: LNetMDUnlink().
  * @{ */
-int LNetMDAttach(lnet_handle_me_t  current_in,
-                lnet_md_t         md_in,
-                lnet_unlink_t     unlink_in,
-                lnet_handle_md_t *handle_out);
+int LNetMDAttach(struct lnet_handle_me current_in,
+                struct lnet_md    md_in,
+                enum lnet_unlink  unlink_in,
+                struct lnet_handle_md *md_handle_out);
 
-int LNetMDBind(lnet_md_t        md_in,
-              lnet_unlink_t     unlink_in,
-              lnet_handle_md_t *handle_out);
+int LNetMDBind(struct lnet_md   md_in,
+              enum lnet_unlink unlink_in,
+              struct lnet_handle_md *md_handle_out);
 
-int LNetMDUnlink(lnet_handle_md_t md_in);
+int LNetMDUnlink(struct lnet_handle_md md_in);
 /** @} lnet_md */
 
 /** \defgroup lnet_eq Events and event queues
@@ -148,9 +147,9 @@ 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
- * 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
+ * In addition to the struct lnet_handle_eq, the LNet API defines two types
+ * associated with events: The ::lnet_event_kind defines the kinds of events
+ * that can be stored in an EQ. The struct 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
@@ -162,21 +161,20 @@ 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 LNetEQGet(lnet_handle_eq_t eventq_in,
-             lnet_event_t     *event_out);
+int LNetEQGet(struct lnet_handle_eq eventq_in,
+             struct lnet_event *event_out);
 
+int LNetEQWait(struct lnet_handle_eq eventq_in,
+              struct lnet_event *event_out);
 
-int LNetEQWait(lnet_handle_eq_t  eventq_in,
-              lnet_event_t     *event_out);
-
-int LNetEQPoll(lnet_handle_eq_t *eventqs_in,
+int LNetEQPoll(struct lnet_handle_eq *eventqs_in,
               int               neq_in,
               signed long       timeout,
-              lnet_event_t     *event_out,
+              struct lnet_event *event_out,
               int              *which_eq_out);
 /** @} lnet_eq */
 
@@ -186,17 +184,17 @@ int LNetEQPoll(lnet_handle_eq_t *eventqs_in,
  * and LNetGet().
  * @{ */
 int LNetPut(lnet_nid_t       self,
-           lnet_handle_md_t  md_in,
-           lnet_ack_req_t    ack_req_in,
-           lnet_process_id_t target_in,
+           struct lnet_handle_md md_in,
+           enum lnet_ack_req   ack_req_in,
+           struct lnet_process_id target_in,
            unsigned int      portal_in,
            __u64             match_bits_in,
            unsigned int      offset_in,
            __u64             hdr_data_in);
 
 int LNetGet(lnet_nid_t       self,
-           lnet_handle_md_t  md_in,
-           lnet_process_id_t target_in,
+           struct lnet_handle_md md_in,
+           struct lnet_process_id target_in,
            unsigned int      portal_in,
            __u64             match_bits_in,
            unsigned int      offset_in);
@@ -210,7 +208,7 @@ int LNetGet(lnet_nid_t            self,
 int LNetSetLazyPortal(int portal);
 int LNetClearLazyPortal(int portal);
 int LNetCtl(unsigned int cmd, void *arg);
-void LNetDebugPeer(lnet_process_id_t id);
+void LNetDebugPeer(struct lnet_process_id id);
 
 /** @} lnet_misc */
 
index ed1918c..86efcaf 100644 (file)
@@ -46,7 +46,7 @@
 #include <lnet/lnet.h>
 #include <lnet/lib-types.h>
 
-extern lnet_t  the_lnet;                       /* THE network */
+extern struct lnet the_lnet;                   /* THE network */
 
 #if (BITS_PER_LONG == 32)
 /* 2 CPTs, allowing more CPTs might make us under memory pressure */
@@ -70,7 +70,7 @@ extern lnet_t  the_lnet;                      /* THE network */
 /** exclusive lock */
 #define LNET_LOCK_EX           CFS_PERCPT_LOCK_EX
 
-static inline int lnet_is_route_alive(lnet_route_t *route)
+static inline int lnet_is_route_alive(struct lnet_route *route)
 {
        if (!route->lr_gateway->lpni_alive)
                return 0; /* gateway is down */
@@ -87,14 +87,14 @@ static inline int lnet_is_wire_handle_none(struct lnet_handle_wire *wh)
                wh->wh_object_cookie == LNET_WIRE_HANDLE_COOKIE_NONE);
 }
 
-static inline int lnet_md_exhausted (lnet_libmd_t *md)
+static inline int lnet_md_exhausted(struct lnet_libmd *md)
 {
        return (md->md_threshold == 0 ||
                ((md->md_options & LNET_MD_MAX_SIZE) != 0 &&
                 md->md_offset + md->md_max_size > md->md_length));
 }
 
-static inline int lnet_md_unlinkable (lnet_libmd_t *md)
+static inline int lnet_md_unlinkable(struct lnet_libmd *md)
 {
        /* Should unlink md when its refcount is 0 and either:
         *  - md has been flagged for deletion (by auto unlink or LNetM[DE]Unlink,
@@ -178,40 +178,40 @@ lnet_net_lock_current(void)
 
 #define MAX_PORTALS    64
 
-#define LNET_SMALL_MD_SIZE   offsetof(lnet_libmd_t, md_iov.iov[1])
+#define LNET_SMALL_MD_SIZE   offsetof(struct lnet_libmd, md_iov.iov[1])
 extern struct kmem_cache *lnet_mes_cachep;      /* MEs kmem_cache */
 extern struct kmem_cache *lnet_small_mds_cachep; /* <= LNET_SMALL_MD_SIZE bytes
                                                  * MDs kmem_cache */
 
-static inline lnet_eq_t *
+static inline struct lnet_eq *
 lnet_eq_alloc (void)
 {
-       lnet_eq_t *eq;
+       struct lnet_eq *eq;
 
        LIBCFS_ALLOC(eq, sizeof(*eq));
        return (eq);
 }
 
 static inline void
-lnet_eq_free(lnet_eq_t *eq)
+lnet_eq_free(struct lnet_eq *eq)
 {
        LIBCFS_FREE(eq, sizeof(*eq));
 }
 
-static inline lnet_libmd_t *
-lnet_md_alloc (lnet_md_t *umd)
+static inline struct lnet_libmd *
+lnet_md_alloc(struct lnet_md *umd)
 {
-       lnet_libmd_t *md;
+       struct lnet_libmd *md;
        unsigned int  size;
        unsigned int  niov;
 
        if ((umd->options & LNET_MD_KIOV) != 0) {
                niov = umd->length;
-               size = offsetof(lnet_libmd_t, md_iov.kiov[niov]);
+               size = offsetof(struct lnet_libmd, md_iov.kiov[niov]);
        } else {
                niov = ((umd->options & LNET_MD_IOVEC) != 0) ?
                       umd->length : 1;
-               size = offsetof(lnet_libmd_t, md_iov.iov[niov]);
+               size = offsetof(struct lnet_libmd, md_iov.iov[niov]);
        }
 
        if (size <= LNET_SMALL_MD_SIZE) {
@@ -240,14 +240,14 @@ lnet_md_alloc (lnet_md_t *umd)
 }
 
 static inline void
-lnet_md_free(lnet_libmd_t *md)
+lnet_md_free(struct lnet_libmd *md)
 {
        unsigned int  size;
 
        if ((md->md_options & LNET_MD_KIOV) != 0)
-               size = offsetof(lnet_libmd_t, md_iov.kiov[md->md_niov]);
+               size = offsetof(struct lnet_libmd, md_iov.kiov[md->md_niov]);
        else
-               size = offsetof(lnet_libmd_t, md_iov.iov[md->md_niov]);
+               size = offsetof(struct lnet_libmd, md_iov.iov[md->md_niov]);
 
        if (size <= LNET_SMALL_MD_SIZE) {
                CDEBUG(D_MALLOC, "slab-freed 'md' at %p.\n", md);
@@ -257,10 +257,10 @@ lnet_md_free(lnet_libmd_t *md)
        }
 }
 
-static inline lnet_me_t *
+static inline struct lnet_me *
 lnet_me_alloc (void)
 {
-       lnet_me_t *me;
+       struct lnet_me *me;
 
        me = kmem_cache_alloc(lnet_mes_cachep, GFP_NOFS | __GFP_ZERO);
 
@@ -273,18 +273,18 @@ lnet_me_alloc (void)
 }
 
 static inline void
-lnet_me_free(lnet_me_t *me)
+lnet_me_free(struct lnet_me *me)
 {
        CDEBUG(D_MALLOC, "slab-freed 'me' at %p.\n", me);
        kmem_cache_free(lnet_mes_cachep, me);
 }
 
-lnet_libhandle_t *lnet_res_lh_lookup(struct lnet_res_container *rec,
+struct lnet_libhandle *lnet_res_lh_lookup(struct lnet_res_container *rec,
                                     __u64 cookie);
 void lnet_res_lh_initialize(struct lnet_res_container *rec,
-                           lnet_libhandle_t *lh);
+                           struct lnet_libhandle *lh);
 static inline void
-lnet_res_lh_invalidate(lnet_libhandle_t *lh)
+lnet_res_lh_invalidate(struct lnet_libhandle *lh)
 {
        /* ALWAYS called with resource lock held */
        /* NB: cookie is still useful, don't reset it */
@@ -292,40 +292,40 @@ 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, struct lnet_eq *eq)
 {
        if (eq == NULL) {
-               LNetInvalidateHandle(handle);
+               LNetInvalidateEQHandle(handle);
                return;
        }
 
        handle->cookie = eq->eq_lh.lh_cookie;
 }
 
-static inline lnet_eq_t *
-lnet_handle2eq(lnet_handle_eq_t *handle)
+static inline struct lnet_eq *
+lnet_handle2eq(struct lnet_handle_eq *handle)
 {
        /* ALWAYS called with resource lock held */
-       lnet_libhandle_t *lh;
+       struct lnet_libhandle *lh;
 
        lh = lnet_res_lh_lookup(&the_lnet.ln_eq_container, handle->cookie);
        if (lh == NULL)
                return NULL;
 
-       return lh_entry(lh, lnet_eq_t, eq_lh);
+       return lh_entry(lh, struct lnet_eq, eq_lh);
 }
 
 static inline void
-lnet_md2handle (lnet_handle_md_t *handle, lnet_libmd_t *md)
+lnet_md2handle(struct lnet_handle_md *handle, struct lnet_libmd *md)
 {
        handle->cookie = md->md_lh.lh_cookie;
 }
 
-static inline lnet_libmd_t *
-lnet_handle2md(lnet_handle_md_t *handle)
+static inline struct lnet_libmd *
+lnet_handle2md(struct lnet_handle_md *handle)
 {
        /* ALWAYS called with resource lock held */
-       lnet_libhandle_t *lh;
+       struct lnet_libhandle *lh;
        int              cpt;
 
        cpt = lnet_cpt_of_cookie(handle->cookie);
@@ -334,14 +334,14 @@ lnet_handle2md(lnet_handle_md_t *handle)
        if (lh == NULL)
                return NULL;
 
-       return lh_entry(lh, lnet_libmd_t, md_lh);
+       return lh_entry(lh, struct lnet_libmd, md_lh);
 }
 
-static inline lnet_libmd_t *
+static inline struct lnet_libmd *
 lnet_wire_handle2md(struct lnet_handle_wire *wh)
 {
        /* ALWAYS called with resource lock held */
-       lnet_libhandle_t *lh;
+       struct lnet_libhandle *lh;
        int              cpt;
 
        if (wh->wh_interface_cookie != the_lnet.ln_interface_cookie)
@@ -353,20 +353,20 @@ lnet_wire_handle2md(struct lnet_handle_wire *wh)
        if (lh == NULL)
                return NULL;
 
-       return lh_entry(lh, lnet_libmd_t, md_lh);
+       return lh_entry(lh, struct lnet_libmd, md_lh);
 }
 
 static inline void
-lnet_me2handle (lnet_handle_me_t *handle, lnet_me_t *me)
+lnet_me2handle(struct lnet_handle_me *handle, struct lnet_me *me)
 {
        handle->cookie = me->me_lh.lh_cookie;
 }
 
-static inline lnet_me_t *
-lnet_handle2me(lnet_handle_me_t *handle)
+static inline struct lnet_me *
+lnet_handle2me(struct lnet_handle_me *handle)
 {
        /* ALWAYS called with resource lock held */
-       lnet_libhandle_t *lh;
+       struct lnet_libhandle *lh;
        int              cpt;
 
        cpt = lnet_cpt_of_cookie(handle->cookie);
@@ -375,7 +375,7 @@ lnet_handle2me(lnet_handle_me_t *handle)
        if (lh == NULL)
                return NULL;
 
-       return lh_entry(lh, lnet_me_t, me_lh);
+       return lh_entry(lh, struct lnet_me, me_lh);
 }
 
 static inline void
@@ -403,7 +403,7 @@ lnet_isrouter(struct lnet_peer_ni *lp)
 }
 
 static inline void
-lnet_ni_addref_locked(lnet_ni_t *ni, int cpt)
+lnet_ni_addref_locked(struct lnet_ni *ni, int cpt)
 {
        LASSERT(cpt >= 0 && cpt < LNET_CPT_NUMBER);
        LASSERT(*ni->ni_refs[cpt] >= 0);
@@ -412,7 +412,7 @@ lnet_ni_addref_locked(lnet_ni_t *ni, int cpt)
 }
 
 static inline void
-lnet_ni_addref(lnet_ni_t *ni)
+lnet_ni_addref(struct lnet_ni *ni)
 {
        lnet_net_lock(0);
        lnet_ni_addref_locked(ni, 0);
@@ -420,7 +420,7 @@ lnet_ni_addref(lnet_ni_t *ni)
 }
 
 static inline void
-lnet_ni_decref_locked(lnet_ni_t *ni, int cpt)
+lnet_ni_decref_locked(struct lnet_ni *ni, int cpt)
 {
        LASSERT(cpt >= 0 && cpt < LNET_CPT_NUMBER);
        LASSERT(*ni->ni_refs[cpt] > 0);
@@ -429,17 +429,17 @@ lnet_ni_decref_locked(lnet_ni_t *ni, int cpt)
 }
 
 static inline void
-lnet_ni_decref(lnet_ni_t *ni)
+lnet_ni_decref(struct lnet_ni *ni)
 {
        lnet_net_lock(0);
        lnet_ni_decref_locked(ni, 0);
        lnet_net_unlock(0);
 }
 
-static inline lnet_msg_t *
+static inline struct lnet_msg *
 lnet_msg_alloc(void)
 {
-       lnet_msg_t *msg;
+       struct lnet_msg *msg;
 
        LIBCFS_ALLOC(msg, sizeof(*msg));
 
@@ -448,7 +448,7 @@ lnet_msg_alloc(void)
 }
 
 static inline void
-lnet_msg_free(lnet_msg_t *msg)
+lnet_msg_free(struct lnet_msg *msg)
 {
        LASSERT(!msg->msg_onactivelist);
        LIBCFS_FREE(msg, sizeof(*msg));
@@ -481,16 +481,16 @@ lnet_net2rnethash(__u32 net)
                ((1U << the_lnet.ln_remote_nets_hbits) - 1)];
 }
 
-extern lnd_t the_lolnd;
+extern struct lnet_lnd the_lolnd;
 extern int avoid_asym_router_failure;
 
 extern unsigned int lnet_nid_cpt_hash(lnet_nid_t nid, unsigned int number);
 extern int lnet_cpt_of_nid_locked(lnet_nid_t nid, struct lnet_ni *ni);
 extern int lnet_cpt_of_nid(lnet_nid_t nid, struct lnet_ni *ni);
-extern lnet_ni_t *lnet_nid2ni_locked(lnet_nid_t nid, int cpt);
-extern lnet_ni_t *lnet_nid2ni_addref(lnet_nid_t nid);
-extern lnet_ni_t *lnet_net2ni_locked(__u32 net, int cpt);
-extern lnet_ni_t *lnet_net2ni_addref(__u32 net);
+extern struct lnet_ni *lnet_nid2ni_locked(lnet_nid_t nid, int cpt);
+extern struct lnet_ni *lnet_nid2ni_addref(lnet_nid_t nid);
+extern struct lnet_ni *lnet_net2ni_locked(__u32 net, int cpt);
+extern struct lnet_ni *lnet_net2ni_addref(__u32 net);
 bool lnet_is_ni_healthy_locked(struct lnet_ni *ni);
 struct lnet_net *lnet_get_net_locked(__u32 net_id);
 
@@ -500,7 +500,8 @@ void lnet_lib_exit(void);
 extern unsigned int lnet_numa_range;
 extern int portal_rotor;
 
-int lnet_notify(lnet_ni_t *ni, lnet_nid_t peer, int alive, cfs_time_t when);
+int lnet_notify(struct lnet_ni *ni, lnet_nid_t peer, int alive,
+               cfs_time_t when);
 void lnet_notify_locked(struct lnet_peer_ni *lp, int notifylnd, int alive,
                        cfs_time_t when);
 int lnet_add_route(__u32 net, __u32 hops, lnet_nid_t gateway_nid,
@@ -534,12 +535,12 @@ extern int libcfs_ioctl_getdata(struct libcfs_ioctl_hdr **hdr_pp,
 void lnet_proc_init(void);
 void lnet_proc_fini(void);
 int  lnet_rtrpools_alloc(int im_a_router);
-void lnet_destroy_rtrbuf(lnet_rtrbuf_t *rb, int npages);
+void lnet_destroy_rtrbuf(struct lnet_rtrbuf *rb, int npages);
 int  lnet_rtrpools_adjust(int tiny, int small, int large);
 int lnet_rtrpools_enable(void);
 void lnet_rtrpools_disable(void);
 void lnet_rtrpools_free(int keep_pools);
-lnet_remotenet_t *lnet_find_rnet_locked(__u32 net);
+struct lnet_remotenet *lnet_find_rnet_locked(__u32 net);
 int lnet_dyn_add_net(struct lnet_ioctl_config_data *conf);
 int lnet_dyn_del_net(__u32 net);
 int lnet_dyn_add_ni(struct lnet_ioctl_config_ni *conf);
@@ -550,69 +551,70 @@ struct lnet_net *lnet_get_net_locked(__u32 net_id);
 int lnet_islocalnid(lnet_nid_t nid);
 int lnet_islocalnet(__u32 net);
 
-void lnet_msg_attach_md(lnet_msg_t *msg, lnet_libmd_t *md,
+void lnet_msg_attach_md(struct lnet_msg *msg, struct lnet_libmd *md,
                        unsigned int offset, unsigned int mlen);
-void lnet_msg_detach_md(lnet_msg_t *msg, int status);
-void lnet_build_unlink_event(lnet_libmd_t *md, lnet_event_t *ev);
-void lnet_build_msg_event(lnet_msg_t *msg, lnet_event_kind_t ev_type);
-void lnet_msg_commit(lnet_msg_t *msg, int cpt);
-void lnet_msg_decommit(lnet_msg_t *msg, int cpt, int status);
-
-void lnet_eq_enqueue_event(lnet_eq_t *eq, lnet_event_t *ev);
-void lnet_prep_send(lnet_msg_t *msg, int type, lnet_process_id_t target,
-                   unsigned int offset, unsigned int len);
-int lnet_send(lnet_nid_t nid, lnet_msg_t *msg, lnet_nid_t rtr_nid);
-void lnet_return_tx_credits_locked(lnet_msg_t *msg);
-void lnet_return_rx_credits_locked(lnet_msg_t *msg);
-void lnet_schedule_blocked_locked(lnet_rtrbufpool_t *rbp);
+void lnet_msg_detach_md(struct lnet_msg *msg, int status);
+void lnet_build_unlink_event(struct lnet_libmd *md, struct lnet_event *ev);
+void lnet_build_msg_event(struct lnet_msg *msg, enum lnet_event_kind 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, struct lnet_event *ev);
+void lnet_prep_send(struct lnet_msg *msg, int type,
+                   struct lnet_process_id target, unsigned int offset,
+                   unsigned int len);
+int lnet_send(lnet_nid_t nid, struct lnet_msg *msg, lnet_nid_t rtr_nid);
+void lnet_return_tx_credits_locked(struct lnet_msg *msg);
+void lnet_return_rx_credits_locked(struct lnet_msg *msg);
+void lnet_schedule_blocked_locked(struct lnet_rtrbufpool *rbp);
 void lnet_drop_routed_msgs_locked(struct list_head *list, int cpt);
 
 /* portals functions */
 /* portals attributes */
 static inline int
-lnet_ptl_is_lazy(lnet_portal_t *ptl)
+lnet_ptl_is_lazy(struct lnet_portal *ptl)
 {
        return !!(ptl->ptl_options & LNET_PTL_LAZY);
 }
 
 static inline int
-lnet_ptl_is_unique(lnet_portal_t *ptl)
+lnet_ptl_is_unique(struct lnet_portal *ptl)
 {
        return !!(ptl->ptl_options & LNET_PTL_MATCH_UNIQUE);
 }
 
 static inline int
-lnet_ptl_is_wildcard(lnet_portal_t *ptl)
+lnet_ptl_is_wildcard(struct lnet_portal *ptl)
 {
        return !!(ptl->ptl_options & LNET_PTL_MATCH_WILDCARD);
 }
 
 static inline void
-lnet_ptl_setopt(lnet_portal_t *ptl, int opt)
+lnet_ptl_setopt(struct lnet_portal *ptl, int opt)
 {
        ptl->ptl_options |= opt;
 }
 
 static inline void
-lnet_ptl_unsetopt(lnet_portal_t *ptl, int opt)
+lnet_ptl_unsetopt(struct lnet_portal *ptl, int opt)
 {
        ptl->ptl_options &= ~opt;
 }
 
 /* match-table functions */
 struct list_head *lnet_mt_match_head(struct lnet_match_table *mtable,
-                              lnet_process_id_t id, __u64 mbits);
+                              struct lnet_process_id id, __u64 mbits);
 struct lnet_match_table *lnet_mt_of_attach(unsigned int index,
-                                          lnet_process_id_t id, __u64 mbits,
-                                          __u64 ignore_bits,
-                                          lnet_ins_pos_t pos);
+                                          struct lnet_process_id id,
+                                          __u64 mbits, __u64 ignore_bits,
+                                          enum lnet_ins_pos pos);
 int lnet_mt_match_md(struct lnet_match_table *mtable,
                     struct lnet_match_info *info, struct lnet_msg *msg);
 
 /* portals match/attach functions */
-void lnet_ptl_attach_md(lnet_me_t *me, lnet_libmd_t *md,
+void lnet_ptl_attach_md(struct lnet_me *me, struct lnet_libmd *md,
                        struct list_head *matches, struct list_head *drops);
-void lnet_ptl_detach_md(lnet_me_t *me, lnet_libmd_t *md);
+void lnet_ptl_detach_md(struct lnet_me *me, struct lnet_libmd *md);
 int lnet_ptl_match_md(struct lnet_match_info *info, struct lnet_msg *msg);
 
 /* initialized and finalize portals */
@@ -620,23 +622,26 @@ int lnet_portals_create(void);
 void lnet_portals_destroy(void);
 
 /* message functions */
-int lnet_parse (lnet_ni_t *ni, lnet_hdr_t *hdr,
-               lnet_nid_t fromnid, void *private, int rdma_req);
-int lnet_parse_local(lnet_ni_t *ni, lnet_msg_t *msg);
-int lnet_parse_forward_locked(lnet_ni_t *ni, lnet_msg_t *msg);
-
-void lnet_recv(lnet_ni_t *ni, void *private, lnet_msg_t *msg, int delayed,
-              unsigned int offset, unsigned int mlen, unsigned int rlen);
-void lnet_ni_recv(lnet_ni_t *ni, void *private, lnet_msg_t *msg,
+int lnet_parse(struct lnet_ni *ni, struct lnet_hdr *hdr,
+              lnet_nid_t fromnid, void *private, int rdma_req);
+int lnet_parse_local(struct lnet_ni *ni, struct lnet_msg *msg);
+int lnet_parse_forward_locked(struct lnet_ni *ni, struct lnet_msg *msg);
+
+void lnet_recv(struct lnet_ni *ni, void *private, struct lnet_msg *msg,
+              int delayed, unsigned int offset, unsigned int mlen,
+              unsigned int rlen);
+void lnet_ni_recv(struct lnet_ni *ni, void *private, struct lnet_msg *msg,
                  int delayed, unsigned int offset,
                  unsigned int mlen, unsigned int rlen);
 
-lnet_msg_t *lnet_create_reply_msg (lnet_ni_t *ni, lnet_msg_t *get_msg);
-void lnet_set_reply_msg_len(lnet_ni_t *ni, lnet_msg_t *msg, unsigned int len);
+struct lnet_msg *lnet_create_reply_msg(struct lnet_ni *ni,
+                                      struct lnet_msg *get_msg);
+void lnet_set_reply_msg_len(struct lnet_ni *ni, struct lnet_msg *msg,
+                           unsigned int len);
 
-void lnet_finalize(lnet_ni_t *ni, lnet_msg_t *msg, int rc);
+void lnet_finalize(struct lnet_ni *ni, struct lnet_msg *msg, int rc);
 
-void lnet_drop_message(lnet_ni_t *ni, int cpt, void *private,
+void lnet_drop_message(struct lnet_ni *ni, int cpt, void *private,
                       unsigned int nob);
 void lnet_drop_delayed_msg_list(struct list_head *head, char *reason);
 void lnet_recv_delayed_msg_list(struct list_head *head);
@@ -646,8 +651,8 @@ void lnet_msg_container_cleanup(struct lnet_msg_container *container);
 void lnet_msg_containers_destroy(void);
 int lnet_msg_containers_create(void);
 
-char *lnet_msgtyp2str (int type);
-void lnet_print_hdr (lnet_hdr_t * hdr);
+char *lnet_msgtyp2str(int type);
+void lnet_print_hdr(struct lnet_hdr *hdr);
 int lnet_fail_nid(lnet_nid_t nid, unsigned int threshold);
 
 /** \addtogroup lnet_fault_simulation @{ */
@@ -656,7 +661,7 @@ int lnet_fault_ctl(int cmd, struct libcfs_ioctl_data *data);
 int lnet_fault_init(void);
 void lnet_fault_fini(void);
 
-bool lnet_drop_rule_match(lnet_hdr_t *hdr);
+bool lnet_drop_rule_match(struct lnet_hdr *hdr);
 
 int lnet_delay_rule_add(struct lnet_fault_attr *attr);
 int lnet_delay_rule_del(lnet_nid_t src, lnet_nid_t dst, bool shutdown);
@@ -664,11 +669,11 @@ int lnet_delay_rule_list(int pos, struct lnet_fault_attr *attr,
                         struct lnet_fault_stat *stat);
 void lnet_delay_rule_reset(void);
 void lnet_delay_rule_check(void);
-bool lnet_delay_rule_match_locked(lnet_hdr_t *hdr, struct lnet_msg *msg);
+bool lnet_delay_rule_match_locked(struct lnet_hdr *hdr, struct lnet_msg *msg);
 
 /** @} lnet_fault_simulation */
 
-void lnet_counters_get(lnet_counters_t *counters);
+void lnet_counters_get(struct lnet_counters *counters);
 void lnet_counters_reset(void);
 
 unsigned int lnet_iov_nob(unsigned int niov, struct kvec *iov);
@@ -740,14 +745,14 @@ lnet_copy_flat2kiov(unsigned int ndiov, lnet_kiov_t *dkiov,
                           1, &siov, soffset, nob);
 }
 
-void lnet_me_unlink(lnet_me_t *me);
+void lnet_me_unlink(struct lnet_me *me);
 
-void lnet_md_unlink(lnet_libmd_t *md);
-void lnet_md_deconstruct(lnet_libmd_t *lmd, lnet_md_t *umd);
-int lnet_cpt_of_md(lnet_libmd_t *md);
+void lnet_md_unlink(struct lnet_libmd *md);
+void lnet_md_deconstruct(struct lnet_libmd *lmd, struct lnet_md *umd);
+int lnet_cpt_of_md(struct lnet_libmd *md);
 
-void lnet_register_lnd(lnd_t *lnd);
-void lnet_unregister_lnd(lnd_t *lnd);
+void lnet_register_lnd(struct lnet_lnd *lnd);
+void lnet_unregister_lnd(struct lnet_lnd *lnd);
 
 int lnet_connect(struct socket **sockp, lnet_nid_t peer_nid,
                 __u32 local_ip, __u32 peer_ip, int peer_port);
index 13ca7d5..cfa4c39 100644 (file)
@@ -67,7 +67,7 @@ typedef struct lnet_msg {
        struct list_head        msg_activelist;
        struct list_head        msg_list;       /* Q for credits/MD */
 
-       lnet_process_id_t       msg_target;
+       struct lnet_process_id  msg_target;
        /* Primary NID of the source. */
        lnet_nid_t              msg_initiator;
        /* where is it from, it's only for building event */
@@ -118,11 +118,10 @@ typedef struct lnet_msg {
        struct kvec          *msg_iov;
        lnet_kiov_t          *msg_kiov;
 
-       lnet_event_t          msg_ev;
-       lnet_hdr_t            msg_hdr;
+       struct lnet_event       msg_ev;
+       struct lnet_hdr         msg_hdr;
 } lnet_msg_t;
 
-
 typedef struct lnet_libhandle {
        struct list_head        lh_hash_chain;
        __u64                   lh_cookie;
@@ -133,31 +132,31 @@ typedef struct lnet_libhandle {
 
 typedef struct lnet_eq {
        struct list_head        eq_list;
-       lnet_libhandle_t        eq_lh;
-       lnet_seq_t              eq_enq_seq;
-       lnet_seq_t              eq_deq_seq;
+       struct lnet_libhandle   eq_lh;
+       unsigned long           eq_enq_seq;
+       unsigned long           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 */
 } lnet_eq_t;
 
 typedef struct lnet_me {
        struct list_head        me_list;
-       lnet_libhandle_t        me_lh;
-       lnet_process_id_t       me_match_id;
+       struct lnet_libhandle   me_lh;
+       struct lnet_process_id  me_match_id;
        unsigned int            me_portal;
        unsigned int            me_pos;         /* hash offset in mt_hash */
        __u64                   me_match_bits;
        __u64                   me_ignore_bits;
-       lnet_unlink_t           me_unlink;
+       enum lnet_unlink        me_unlink;
        struct lnet_libmd      *me_md;
 } lnet_me_t;
 
 typedef struct lnet_libmd {
        struct list_head        md_list;
-       lnet_libhandle_t        md_lh;
-       lnet_me_t              *md_me;
+       struct lnet_libhandle   md_lh;
+       struct lnet_me         *md_me;
        char                   *md_start;
        unsigned int            md_offset;
        unsigned int            md_length;
@@ -168,8 +167,8 @@ typedef struct lnet_libmd {
        unsigned int            md_flags;
        unsigned int            md_niov;        /* # frags at end of struct */
        void                   *md_user_ptr;
-       lnet_eq_t              *md_eq;
-       lnet_handle_md_t       md_bulk_handle;
+       struct lnet_eq         *md_eq;
+       struct lnet_handle_md   md_bulk_handle;
        union {
                struct kvec     iov[LNET_MAX_IOV];
                lnet_kiov_t     kiov[LNET_MAX_IOV];
@@ -180,7 +179,7 @@ typedef struct lnet_libmd {
 #define LNET_MD_FLAG_AUTO_UNLINK (1 << 1)
 #define LNET_MD_FLAG_ABORTED    (1 << 2)
 
-typedef struct {
+typedef struct lnet_test_peer {
        /* info about peers we are trying to fail */
        struct list_head        tp_list;        /* ln_test_peers */
        lnet_nid_t              tp_nid;         /* matching nid */
@@ -196,8 +195,7 @@ typedef struct {
 struct lnet_ni;                                         /* forward ref */
 struct socket;
 
-typedef struct lnet_lnd
-{
+typedef struct lnet_lnd {
        /* fields managed by portals */
        struct list_head        lnd_list;       /* stash in the LND table */
        int                     lnd_refcount;   /* # active instances */
@@ -225,14 +223,15 @@ typedef struct lnet_lnd
         * and 'private' is the 'private' passed to lnet_parse().  Return
         * non-zero for immediate failure, otherwise complete later with
         * lnet_finalize() */
-       int (*lnd_send)(struct lnet_ni *ni, void *private, lnet_msg_t *msg);
+       int (*lnd_send)(struct lnet_ni *ni, void *private,
+                       struct lnet_msg *msg);
 
        /* Start receiving 'mlen' bytes of payload data, skipping the following
         * 'rlen' - 'mlen' bytes. 'private' is the 'private' passed to
         * lnet_parse().  Return non-zero for immedaite failure, otherwise
         * complete later with lnet_finalize().  This also gives back a receive
         * credit if the LND does flow control. */
-       int (*lnd_recv)(struct lnet_ni *ni, void *private, lnet_msg_t *msg,
+       int (*lnd_recv)(struct lnet_ni *ni, void *private, struct lnet_msg *msg,
                        int delayed, unsigned int niov,
                        struct kvec *iov, lnet_kiov_t *kiov,
                        unsigned int offset, unsigned int mlen, unsigned int rlen);
@@ -243,8 +242,8 @@ typedef struct lnet_lnd
         * for success and do NOT give back a receive credit; that has to wait
         * until lnd_recv() gets called.  On failure return < 0 and
         * release resources; lnd_recv() will not be called. */
-       int (*lnd_eager_recv)(struct lnet_ni *ni, void *private, lnet_msg_t *msg,
-                             void **new_privatep);
+       int (*lnd_eager_recv)(struct lnet_ni *ni, void *private,
+                             struct lnet_msg *msg, void **new_privatep);
 
        /* notification of peer health */
        void (*lnd_notify)(struct lnet_ni *ni, lnet_nid_t peer, int alive);
@@ -328,7 +327,7 @@ struct lnet_net {
        bool                    net_tunables_set;
 
        /* procedural interface */
-       lnd_t                   *net_lnd;
+       struct lnet_lnd         *net_lnd;
 
        /* list of NIs on this net */
        struct list_head        net_ni_list;
@@ -380,7 +379,7 @@ typedef struct lnet_ni {
        struct lnet_net         *ni_net;
 
        /* my health status */
-       lnet_ni_status_t        *ni_status;
+       struct lnet_ni_status   *ni_status;
 
        /* NI FSM */
        enum lnet_ni_state      ni_state;
@@ -431,10 +430,10 @@ typedef struct lnet_ping_info {
 /* router checker data, per router */
 #define LNET_MAX_RTR_NIS   16
 #define LNET_PINGINFO_SIZE offsetof(struct lnet_ping_info, pi_ni[LNET_MAX_RTR_NIS])
-typedef struct {
+typedef struct lnet_rc_data {
        /* chain on the_lnet.ln_zombie_rcd or ln_deathrow_rcd */
        struct list_head        rcd_list;
-       lnet_handle_md_t        rcd_mdh;        /* ping buffer MD */
+       struct lnet_handle_md   rcd_mdh;        /* ping buffer MD */
        struct lnet_peer_ni     *rcd_gateway;   /* reference to gateway */
        struct lnet_ping_info   *rcd_pinginfo;  /* ping buffer */
 } lnet_rc_data_t;
@@ -515,7 +514,7 @@ struct lnet_peer_ni {
        /* number of preferred NIDs in lnpi_pref_nids */
        __u32                   lpni_pref_nnids;
        /* router checker state */
-       lnet_rc_data_t          *lpni_rcd;
+       struct lnet_rc_data     *lpni_rcd;
 };
 
 struct lnet_peer {
@@ -561,12 +560,13 @@ struct lnet_peer_table {
 };
 
 /* peer aliveness is enabled only on routers for peers in a network where the
- * lnet_ni_t::ni_peertimeout has been set to a positive value */
+ * struct lnet_ni::ni_peertimeout has been set to a positive value
+ */
 #define lnet_peer_aliveness_enabled(lp) (the_lnet.ln_routing != 0 && \
                                        ((lp)->lpni_net) && \
                                        (lp)->lpni_net->net_tunables.lct_peer_timeout > 0)
 
-typedef struct {
+typedef struct lnet_route {
        struct list_head        lr_list;        /* chain on net */
        struct list_head        lr_gwlist;      /* chain on gateway */
        struct lnet_peer_ni     *lr_gateway;    /* router node */
@@ -581,7 +581,7 @@ typedef struct {
 #define LNET_REMOTE_NETS_HASH_MAX      (1U << 16)
 #define LNET_REMOTE_NETS_HASH_SIZE     (1 << the_lnet.ln_remote_nets_hbits)
 
-typedef struct {
+typedef struct lnet_remotenet {
        /* chain on ln_remote_nets_hash */
        struct list_head        lrn_list;
        /* routes to me */
@@ -595,7 +595,7 @@ typedef struct {
 /** lnet message is waiting for credit */
 #define LNET_CREDIT_WAIT       1
 
-typedef struct {
+typedef struct lnet_rtrbufpool {
        /* my free buffer pool */
        struct list_head        rbp_bufs;
        /* messages blocking for a buffer */
@@ -612,15 +612,15 @@ typedef struct {
        int                     rbp_mincredits;
 } lnet_rtrbufpool_t;
 
-typedef struct {
+typedef struct lnet_rtrbuf {
        struct list_head         rb_list;       /* chain on rbp_bufs */
-       lnet_rtrbufpool_t       *rb_pool;       /* owning pool */
+       struct lnet_rtrbufpool  *rb_pool;       /* owning pool */
        lnet_kiov_t              rb_kiov[0];    /* the buffer space */
 } lnet_rtrbuf_t;
 
 #define LNET_PEER_HASHSIZE   503               /* prime! */
 
-enum {
+enum lnet_match_flags {
        /* Didn't match anything */
        LNET_MATCHMD_NONE       = (1 << 0),
        /* Matched OK */
@@ -633,7 +633,7 @@ enum {
        LNET_MATCHMD_FINISH     = (LNET_MATCHMD_OK | LNET_MATCHMD_DROP),
 };
 
-/* Options for lnet_portal_t::ptl_options */
+/* Options for struct lnet_portal::ptl_options */
 #define LNET_PTL_LAZY              (1 << 0)
 #define LNET_PTL_MATCH_UNIQUE      (1 << 1)    /* unique match, for RDMA */
 #define LNET_PTL_MATCH_WILDCARD     (1 << 2)   /* wildcard match, request portal */
@@ -641,7 +641,7 @@ enum {
 /* parameter for matching operations (GET, PUT) */
 struct lnet_match_info {
        __u64                   mi_mbits;
-       lnet_process_id_t       mi_id;
+       struct lnet_process_id  mi_id;
        unsigned int            mi_cpt;
        unsigned int            mi_opc;
        unsigned int            mi_portal;
@@ -734,8 +734,7 @@ struct lnet_msg_container {
 #define LNET_RC_STATE_RUNNING          1       /* started up OK */
 #define LNET_RC_STATE_STOPPING         2       /* telling thread to stop */
 
-typedef struct
-{
+typedef struct lnet {
        /* CPU partition table of LNet */
        struct cfs_cpt_table            *ln_cpt_table;
        /* number of CPTs in ln_cpt_table */
@@ -747,7 +746,7 @@ typedef struct
        /* # portals */
        int                             ln_nportals;
        /* the vector of portals */
-       lnet_portal_t                   **ln_portals;
+       struct lnet_portal              **ln_portals;
        /* percpt ME containers */
        struct lnet_res_container       **ln_me_containers;
        /* percpt MD container */
@@ -764,7 +763,7 @@ typedef struct
        struct cfs_percpt_lock          *ln_net_lock;
        /* percpt message containers for active/finalizing/freed message */
        struct lnet_msg_container       **ln_msg_containers;
-       lnet_counters_t                 **ln_counters;
+       struct lnet_counters            **ln_counters;
        struct lnet_peer_table          **ln_peer_tables;
        /* list of configured or discovered peers */
        struct list_head                ln_peers;
@@ -790,16 +789,16 @@ typedef struct
        /* validity stamp */
        __u64                           ln_routers_version;
        /* percpt router buffer pools */
-       lnet_rtrbufpool_t               **ln_rtrpools;
+       struct lnet_rtrbufpool          **ln_rtrpools;
 
-       lnet_handle_md_t                ln_ping_target_md;
-       lnet_handle_eq_t                ln_ping_target_eq;
+       struct lnet_handle_md           ln_ping_target_md;
+       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 */
index cbe01f0..a43978f 100644 (file)
@@ -83,7 +83,7 @@ struct lst_bid {
 #define LST_NODE_UNKNOWN       0x8     /* node not in session */
 
 struct lstcon_node_ent {
-       lnet_process_id_t       nde_id;         /* id of node */
+       struct lnet_process_id  nde_id;         /* id of node */
        int                     nde_state;      /* state of node */
 };                                             /*** node entry, for list_group command */
 
@@ -119,7 +119,7 @@ struct lstcon_test_batch_ent {
 
 struct lstcon_rpc_ent {
        struct list_head        rpe_link;               /* link chain */
-       lnet_process_id_t       rpe_peer;               /* peer's id */
+       struct lnet_process_id  rpe_peer;               /* peer's id */
        struct timeval          rpe_stamp;              /* time stamp of RPC */
        int                     rpe_state;              /* peer's state */
        int                     rpe_rpc_errno;          /* RPC errno */
@@ -271,7 +271,7 @@ struct lstio_debug_args {
        int                     lstio_dbg_nmlen;        /* IN: len of name */
        char __user            *lstio_dbg_namep;        /* IN: name of group|batch */
        int                     lstio_dbg_count;        /* IN: # of test nodes to debug */
-       lnet_process_id_t __user *lstio_dbg_idsp;       /* IN: id of test nodes */
+       struct lnet_process_id __user *lstio_dbg_idsp;  /* IN: id of test nodes */
        /* OUT: list head of result buffer */
        struct list_head __user *lstio_dbg_resultp;
 };
@@ -299,7 +299,7 @@ struct lstio_group_update_args {
        int                     lstio_grp_nmlen;        /* IN: name length */
        char __user            *lstio_grp_namep;        /* IN: group name */
        int                     lstio_grp_count;        /* IN: # of nodes id */
-       lnet_process_id_t __user *lstio_grp_idsp;       /* IN: array of nodes */
+       struct lnet_process_id __user *lstio_grp_idsp;  /* IN: array of nodes */
        /* OUT: list head of result buffer */
        struct list_head __user *lstio_grp_resultp;
 };
@@ -311,7 +311,7 @@ struct lstio_group_nodes_args {
        int                      lstio_grp_count;       /* IN: # of nodes */
        /** OUT: session features */
        unsigned __user         *lstio_grp_featp;
-       lnet_process_id_t __user *lstio_grp_idsp;       /* IN: nodes */
+       struct lnet_process_id __user *lstio_grp_idsp;  /* IN: nodes */
        /* OUT: list head of result buffer */
        struct list_head __user *lstio_grp_resultp;
 };
@@ -424,7 +424,7 @@ struct lstio_stat_args {
        /* IN: # of pid */
        int                     lstio_sta_count;
        /* IN: pid */
-       lnet_process_id_t __user *lstio_sta_idsp;
+       struct lnet_process_id __user *lstio_sta_idsp;
        /* OUT: list head of result buffer */
        struct list_head __user *lstio_sta_resultp;
 };
index 460672e..b90e320 100644 (file)
@@ -83,7 +83,7 @@ static inline char *libcfs_nid2str(lnet_nid_t nid)
 __u32 libcfs_str2net(const char *str);
 lnet_nid_t libcfs_str2nid(const char *str);
 int libcfs_str2anynid(lnet_nid_t *nid, const char *str);
-char *libcfs_id2str(lnet_process_id_t id);
+char *libcfs_id2str(struct lnet_process_id id);
 void cfs_free_nidlist(struct list_head *list);
 int cfs_parse_nidlist(char *str, int len, struct list_head *list);
 int cfs_print_nidlist(char *buffer, int count, struct list_head *list);
index 45d8320..843d35c 100644 (file)
@@ -60,7 +60,7 @@ struct ksock_hello_msg {
 } WIRE_ATTR;
 
 struct ksock_lnet_msg {
-       lnet_hdr_t              ksnm_hdr;       /* lnet hdr */
+       struct lnet_hdr         ksnm_hdr;       /* lnet hdr */
 
        /*
         * ksnm_payload is removed because of winnt compiler's limitation:
index 6b9a949..4b11517 100644 (file)
  * \see LNET_NIDNET, LNET_NIDADDR, and LNET_MKNID.
  */
 typedef __u64 lnet_nid_t;
+
 /**
  * ID of a process in a node. Shortened as PID to distinguish from
- * lnet_process_id_t, the global process ID.
+ * lnet_process_id, the global process ID.
  */
 typedef __u32 lnet_pid_t;
 
@@ -108,11 +109,11 @@ static inline __u32 LNET_MKNET(__u32 type, __u32 num)
 
 #define WIRE_ATTR      __attribute__((packed))
 
-/* Packed version of lnet_process_id_t to transfer via network */
+/* Packed version of struct lnet_process_id to transfer via network */
 typedef struct lnet_process_id_packed {
        lnet_nid_t nid;
        lnet_pid_t pid; /* node id / process id */
-} WIRE_ATTR lnet_process_id_packed_t;
+} WIRE_ATTR lnet_process_id_packed;
 
 /* The wire handle's interface cookie only matches one network interface in
  * one epoch (i.e. new cookie when the interface restarts or the node
@@ -123,7 +124,7 @@ typedef struct lnet_handle_wire {
        __u64 wh_object_cookie;
 } WIRE_ATTR lnet_handle_wire_t;
 
-typedef enum {
+typedef enum lnet_msg_type {
        LNET_MSG_ACK = 0,
        LNET_MSG_PUT,
        LNET_MSG_GET,
@@ -171,7 +172,7 @@ typedef struct lnet_hdr {
        lnet_nid_t      src_nid;
        lnet_pid_t      dest_pid;
        lnet_pid_t      src_pid;
-       __u32           type;           /* lnet_msg_type_t */
+       __u32           type;           /* enum lnet_msg_type */
        __u32           payload_length; /* payload data to follow */
        /*<------__u64 aligned------->*/
        union {
@@ -190,13 +191,13 @@ typedef struct lnet_hdr {
  * This is for use by byte-stream LNDs (e.g. TCP/IP) to check the peer is
  * running the same protocol and to find out its NID. These LNDs should
  * exchange HELLO messages when a connection is first established.  Individual
- * LNDs can put whatever else they fancy in lnet_hdr_t::msg.
+ * LNDs can put whatever else they fancy in lnet_hdr::msg.
  */
 typedef struct lnet_magicversion {
        __u32   magic;          /* LNET_PROTO_TCP_MAGIC */
        __u16   version_major;  /* increment on incompatible change */
        __u16   version_minor;  /* increment on compatible change */
-} WIRE_ATTR lnet_magicversion_t;
+} WIRE_ATTR lnet_magic_version_t;
 
 /* PROTO MAGIC for LNDs */
 #define LNET_PROTO_IB_MAGIC            0x0be91b91
@@ -244,56 +245,65 @@ typedef struct lnet_counters {
 
 /**
  * Objects maintained by the LNet are accessed through handles. Handle types
- * have names of the form lnet_handle_xx_t, where xx is one of the two letter
+ * have names of the form lnet_handle_xx, where xx is one of the two letter
  * object type codes ('eq' for event queue, 'md' for memory descriptor, and
- * 'me' for match entry).
- * Each type of object is given a unique handle type to enhance type checking.
- * The type lnet_handle_any_t can be used when a generic handle is needed.
- * Every handle value can be converted into a value of type lnet_handle_any_t
- * without loss of information.
+ * 'me' for match entry). Each type of object is given a unique handle type
+ * to enhance type checking.
  */
-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;
-
 #define LNET_WIRE_HANDLE_COOKIE_NONE   (-1)
 
+typedef struct lnet_handle_eq {
+       __u64   cookie;
+} lnet_handle_eq_t;
+
 /**
- * Invalidate handle \a h.
+ * Invalidate eq handle \a h.
  */
-static inline void LNetInvalidateHandle(lnet_handle_any_t *h)
+static inline void LNetInvalidateEQHandle(struct lnet_handle_eq *h)
 {
        h->cookie = LNET_WIRE_HANDLE_COOKIE_NONE;
 }
 
 /**
- * Compare handles \a h1 and \a h2.
+ * Check whether eq handle \a h is invalid.
  *
- * \return 1 if handles are equal, 0 if otherwise.
+ * \return 1 if handle is invalid, 0 if valid.
  */
-static inline int LNetHandleIsEqual (lnet_handle_any_t h1, lnet_handle_any_t h2)
+static inline int LNetEQHandleIsInvalid(struct lnet_handle_eq h)
 {
-       return (h1.cookie == h2.cookie);
+       return (LNET_WIRE_HANDLE_COOKIE_NONE == h.cookie);
 }
 
+typedef struct lnet_handle_md {
+       __u64   cookie;
+} lnet_handle_md_t;
+
 /**
- * Check whether handle \a h is invalid.
+ * Invalidate md handle \a h.
+ */
+static inline void LNetInvalidateMDHandle(struct lnet_handle_md *h)
+{
+       h->cookie = LNET_WIRE_HANDLE_COOKIE_NONE;
+}
+
+/**
+ * Check whether eq handle \a h is invalid.
  *
  * \return 1 if handle is invalid, 0 if valid.
  */
-static inline int LNetHandleIsInvalid(lnet_handle_any_t h)
+static inline int LNetMDHandleIsInvalid(struct lnet_handle_md h)
 {
        return (LNET_WIRE_HANDLE_COOKIE_NONE == h.cookie);
 }
 
+typedef struct lnet_handle_me {
+       __u64   cookie;
+} lnet_handle_me_t;
+
 /**
  * Global process ID.
  */
-typedef struct {
+typedef struct lnet_process_id {
        /** node id */
        lnet_nid_t nid;
        /** process id */
@@ -308,26 +318,26 @@ typedef struct {
  * Specifies whether the match entry or memory descriptor should be unlinked
  * automatically (LNET_UNLINK) or not (LNET_RETAIN).
  */
-typedef enum {
+typedef enum lnet_unlink {
        LNET_RETAIN = 0,
        LNET_UNLINK
 } lnet_unlink_t;
 
 /**
- * Values of the type lnet_ins_pos_t are used to control where a new match
+ * Values of the type enum lnet_ins_pos are used to control where a new match
  * entry is inserted. The value LNET_INS_BEFORE is used to insert the new
  * entry before the current entry or before the head of the list. The value
  * LNET_INS_AFTER is used to insert the new entry after the current entry
  * or after the last item in the list.
  */
-typedef enum {
+typedef enum lnet_ins_pos {
        /** insert ME before current position or head of the list */
        LNET_INS_BEFORE,
        /** insert ME after current position or tail of the list */
        LNET_INS_AFTER,
        /** attach ME at tail of local CPU partition ME list */
        LNET_INS_LOCAL
-} lnet_ins_pos_t;
+} lnet_ins_pos;
 
 /** @} lnet_me */
 
@@ -338,7 +348,7 @@ typedef enum {
  * Defines the visible parts of a memory descriptor. Values of this type
  * are used to initialize memory descriptors.
  */
-typedef struct {
+typedef struct lnet_md {
        /**
         * Specify the memory region associated with the memory descriptor.
         * If the options field has:
@@ -432,7 +442,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;
        /**
         * The bulk MD handle which was registered to describe the buffers
         * either to be used to transfer data to the peer or receive data
@@ -441,7 +451,7 @@ typedef struct {
         * nearest local network interface. This value is only used
         * if the LNET_MD_BULK_HANDLE option is set.
         */
-       lnet_handle_md_t bulk_handle;
+       struct lnet_handle_md bulk_handle;
 } lnet_md_t;
 
 /* Max Transfer Unit (minimum supported everywhere).
@@ -454,36 +464,33 @@ typedef struct {
 #define LNET_MAX_IOV   256
 
 /**
- * Options for the MD structure. See lnet_md_t::options.
+ * Options for the MD structure. See struct lnet_md::options.
  */
 #define LNET_MD_OP_PUT              (1 << 0)
-/** See lnet_md_t::options. */
+/** See struct lnet_md::options. */
 #define LNET_MD_OP_GET              (1 << 1)
-/** See lnet_md_t::options. */
+/** See struct lnet_md::options. */
 #define LNET_MD_MANAGE_REMOTE       (1 << 2)
 /* unused                           (1 << 3) */
-/** See lnet_md_t::options. */
+/** See struct lnet_md::options. */
 #define LNET_MD_TRUNCATE            (1 << 4)
-/** See lnet_md_t::options. */
+/** See struct lnet_md::options. */
 #define LNET_MD_ACK_DISABLE         (1 << 5)
-/** See lnet_md_t::options. */
+/** See struct lnet_md::options. */
 #define LNET_MD_IOVEC               (1 << 6)
-/** See lnet_md_t::options. */
+/** See struct lnet_md::options. */
 #define LNET_MD_MAX_SIZE            (1 << 7)
-/** See lnet_md_t::options. */
+/** See struct lnet_md::options. */
 #define LNET_MD_KIOV                (1 << 8)
-/** See lnet_md_t::options. */
+/** See struct lnet_md::options. */
 #define LNET_MD_BULK_HANDLE         (1 << 9)
 
 /* For compatibility with Cray Portals */
 #define LNET_MD_PHYS                        0
 
-/** Infinite threshold on MD operations. See lnet_md_t::threshold */
+/** Infinite threshold on MD operations. See struct lnet_md::threshold */
 #define LNET_MD_THRESH_INF      (-1)
 
-/* NB lustre portals uses struct iovec internally! */
-typedef struct iovec lnet_md_iovec_t;
-
 /**
  * A page-based fragment of a MD.
  */
@@ -507,7 +514,7 @@ typedef struct {
 /**
  * Six types of events can be logged in an event queue.
  */
-typedef enum {
+typedef enum lnet_event_kind {
        /** An incoming GET operation has completed on the MD. */
        LNET_EVENT_GET          = 1,
        /**
@@ -545,20 +552,18 @@ typedef enum {
        LNET_EVENT_UNLINK,
 } lnet_event_kind_t;
 
-#define LNET_SEQ_BASETYPE      long
-typedef unsigned LNET_SEQ_BASETYPE lnet_seq_t;
-#define LNET_SEQ_GT(a, b)      (((signed LNET_SEQ_BASETYPE)((a) - (b))) > 0)
+#define LNET_SEQ_GT(a, b)      (((signed long)((a) - (b))) > 0)
 
 /**
  * Information about an event on a MD.
  */
-typedef struct {
+typedef struct lnet_event {
        /** The identifier (nid, pid) of the target. */
-       lnet_process_id_t   target;
+       struct lnet_process_id   target;
        /** The identifier (nid, pid) of the initiator. */
-       lnet_process_id_t   initiator;
+       struct lnet_process_id   initiator;
        /** The source NID on the initiator. */
-       lnet_process_id_t   source;
+       struct lnet_process_id   source;
        /**
         * The NID of the immediate sender. If the request has been forwarded
         * by routers, this is the NID of the last hop; otherwise it's the
@@ -566,7 +571,7 @@ typedef struct {
         */
        lnet_nid_t          sender;
        /** Indicates the type of the event. */
-       lnet_event_kind_t   type;
+       enum lnet_event_kind    type;
        /** The portal table index specified in the request */
        unsigned int        pt_index;
        /** A copy of the match bits specified in the request. */
@@ -577,7 +582,7 @@ typedef struct {
         * The length (in bytes) of the data that was manipulated by the
         * operation. For truncated operations, the manipulated length will be
         * the number of bytes specified by the MD (possibly with an offset,
-        * see lnet_md_t). For all other operations, the manipulated length
+        * see struct lnet_md). For all other operations, the manipulated length
         * will be the length of the requested operation, i.e. rlength.
         */
        unsigned int        mlength;
@@ -585,13 +590,13 @@ typedef struct {
         * The handle to the MD associated with the event. The handle may be
         * invalid if the MD has been unlinked.
         */
-       lnet_handle_md_t    md_handle;
+       struct lnet_handle_md   md_handle;
        /**
         * A snapshot of the state of the MD immediately after the event has
         * been processed. In particular, the threshold field in md will
         * reflect the value of the threshold after the operation occurred.
         */
-       lnet_md_t           md;
+       struct lnet_md           md;
        /**
         * 64 bits of out-of-band user data. Only valid for LNET_EVENT_PUT.
         * \see LNetPut
@@ -613,14 +618,14 @@ typedef struct {
         * The displacement (in bytes) into the memory region that the
         * operation used. The offset can be determined by the operation for
         * a remote managed MD or by the local MD.
-        * \see lnet_md_t::options
+        * \see struct lnet_md::options
         */
        unsigned int        offset;
        /**
         * The sequence number for this event. Sequence numbers are unique
         * to each event.
         */
-       volatile lnet_seq_t sequence;
+       volatile unsigned long sequence;
 } lnet_event_t;
 
 /**
@@ -633,7 +638,7 @@ typedef struct {
  * 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 */
 
@@ -645,10 +650,10 @@ typedef void (*lnet_eq_handler_t)(lnet_event_t *event);
  * operation completes (i.e., when the data has been written to a MD of the
  * target process).
  *
- * \see lnet_md_t::options for the discussion on LNET_MD_ACK_DISABLE by which
- * acknowledgments can be disabled for a MD.
+ * \see struct lnet_md::options for the discussion on LNET_MD_ACK_DISABLE
+ * by which acknowledgments can be disabled for a MD.
  */
-typedef enum {
+typedef enum lnet_ack_req {
        /** Request an acknowledgment */
        LNET_ACK_REQ,
        /** Request that no acknowledgment should be generated. */
index 9f43d21..dd9669c 100644 (file)
@@ -395,12 +395,12 @@ typedef struct {
 } WIRE_ATTR kgn_rdma_desc_t;
 
 typedef struct {
-       lnet_hdr_t        gnim_hdr;             /* LNet header */
+       struct lnet_hdr   gnim_hdr;             /* LNet header */
        /* LNet payload is in FMA "Message Data" */
 } WIRE_ATTR kgn_immediate_msg_t;
 
 typedef struct {
-       lnet_hdr_t        gnprm_hdr;            /* LNet header */
+       struct lnet_hdr   gnprm_hdr;            /* LNet header */
        __u64             gnprm_cookie;         /* opaque completion cookie */
 } WIRE_ATTR kgn_putreq_msg_t;
 
@@ -412,7 +412,7 @@ typedef struct {
 } WIRE_ATTR kgn_putack_msg_t;
 
 typedef struct {
-       lnet_hdr_t        gngm_hdr;             /* LNet header */
+       struct lnet_hdr   gngm_hdr;             /* LNet header */
        __u64             gngm_cookie;          /* opaque completion cookie */
        __u16             gngm_payload_cksum;   /* checksum for put msg */
        kgn_rdma_desc_t   gngm_desc;            /* sender's sink buffer */
index bcf5c6d..0f8f7e2 100644 (file)
@@ -2111,7 +2111,7 @@ kgnilnd_consume_rx(kgn_rx_t *rx)
 int
 kgnilnd_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
 {
-       lnet_hdr_t       *hdr = &lntmsg->msg_hdr;
+       struct lnet_hdr  *hdr = &lntmsg->msg_hdr;
        int               type = lntmsg->msg_type;
        lnet_process_id_t target = lntmsg->msg_target;
        int               target_is_router = lntmsg->msg_target_is_router;
index 0124636..5a2850a 100644 (file)
@@ -37,7 +37,7 @@
 #include <asm/page.h>
 #include "o2iblnd.h"
 
-static lnd_t the_o2iblnd;
+static struct lnet_lnd the_o2iblnd;
 
 kib_data_t              kiblnd_data;
 
@@ -176,8 +176,8 @@ kiblnd_unpack_rd(kib_msg_t *msg, int flip)
 }
 
 void
-kiblnd_pack_msg (lnet_ni_t *ni, kib_msg_t *msg, int version,
-                 int credits, lnet_nid_t dstnid, __u64 dststamp)
+kiblnd_pack_msg(struct lnet_ni *ni, kib_msg_t *msg, int version,
+               int credits, lnet_nid_t dstnid, __u64 dststamp)
 {
         kib_net_t *net = ni->ni_data;
 
@@ -313,7 +313,7 @@ kiblnd_unpack_msg(kib_msg_t *msg, int nob)
 }
 
 int
-kiblnd_create_peer(lnet_ni_t *ni, kib_peer_ni_t **peerp, lnet_nid_t nid)
+kiblnd_create_peer(struct lnet_ni *ni, kib_peer_ni_t **peerp, lnet_nid_t nid)
 {
        kib_peer_ni_t   *peer_ni;
        kib_net_t       *net = ni->ni_data;
@@ -420,7 +420,7 @@ kiblnd_unlink_peer_locked (kib_peer_ni_t *peer_ni)
 }
 
 static int
-kiblnd_get_peer_info(lnet_ni_t *ni, int index,
+kiblnd_get_peer_info(struct lnet_ni *ni, int index,
                     lnet_nid_t *nidp, int *count)
 {
        kib_peer_ni_t           *peer_ni;
@@ -478,7 +478,7 @@ kiblnd_del_peer_locked (kib_peer_ni_t *peer_ni)
 }
 
 static int
-kiblnd_del_peer (lnet_ni_t *ni, lnet_nid_t nid)
+kiblnd_del_peer(struct lnet_ni *ni, lnet_nid_t nid)
 {
        struct list_head        zombies = LIST_HEAD_INIT(zombies);
        struct list_head        *ptmp;
@@ -530,7 +530,7 @@ kiblnd_del_peer (lnet_ni_t *ni, lnet_nid_t nid)
 }
 
 static kib_conn_t *
-kiblnd_get_conn_by_idx(lnet_ni_t *ni, int index)
+kiblnd_get_conn_by_idx(struct lnet_ni *ni, int index)
 {
        kib_peer_ni_t           *peer_ni;
        struct list_head        *ptmp;
@@ -1046,7 +1046,7 @@ kiblnd_close_stale_conns_locked(kib_peer_ni_t *peer_ni,
 }
 
 static int
-kiblnd_close_matching_conns(lnet_ni_t *ni, lnet_nid_t nid)
+kiblnd_close_matching_conns(struct lnet_ni *ni, lnet_nid_t nid)
 {
        kib_peer_ni_t           *peer_ni;
        struct list_head        *ptmp;
@@ -1092,7 +1092,7 @@ kiblnd_close_matching_conns(lnet_ni_t *ni, lnet_nid_t nid)
 }
 
 static int
-kiblnd_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg)
+kiblnd_ctl(struct lnet_ni *ni, unsigned int cmd, void *arg)
 {
         struct libcfs_ioctl_data *data = arg;
         int                       rc = -EINVAL;
@@ -1146,7 +1146,7 @@ kiblnd_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg)
 }
 
 static void
-kiblnd_query(lnet_ni_t *ni, lnet_nid_t nid, cfs_time_t *when)
+kiblnd_query(struct lnet_ni *ni, lnet_nid_t nid, cfs_time_t *when)
 {
        cfs_time_t      last_alive = 0;
        cfs_time_t      now = cfs_time_current();
@@ -2394,7 +2394,8 @@ kiblnd_net_fini_pools(kib_net_t *net)
 }
 
 static int
-kiblnd_net_init_pools(kib_net_t *net, lnet_ni_t *ni, __u32 *cpts, int ncpts)
+kiblnd_net_init_pools(kib_net_t *net, struct lnet_ni *ni, __u32 *cpts,
+                     int ncpts)
 {
        struct lnet_ioctl_config_o2iblnd_tunables *tunables;
        unsigned long   flags;
@@ -2906,7 +2907,7 @@ kiblnd_base_shutdown(void)
 }
 
 static void
-kiblnd_shutdown (lnet_ni_t *ni)
+kiblnd_shutdown(struct lnet_ni *ni)
 {
         kib_net_t        *net = ni->ni_data;
        rwlock_t     *g_lock = &kiblnd_data.kib_global_lock;
@@ -3174,7 +3175,7 @@ kiblnd_dev_search(char *ifname)
 }
 
 static int
-kiblnd_startup (lnet_ni_t *ni)
+kiblnd_startup(struct lnet_ni *ni)
 {
         char                     *ifname;
         kib_dev_t                *ibdev = NULL;
@@ -3266,7 +3267,7 @@ failed:
         return -ENETDOWN;
 }
 
-static lnd_t the_o2iblnd = {
+static struct lnet_lnd the_o2iblnd = {
        .lnd_type       = O2IBLND,
        .lnd_startup    = kiblnd_startup,
        .lnd_shutdown   = kiblnd_shutdown,
index 25382c2..11958bc 100644 (file)
@@ -445,8 +445,8 @@ typedef struct kib_connparams
 
 typedef struct
 {
-        lnet_hdr_t        ibim_hdr;             /* portals header */
-        char              ibim_payload[0];      /* piggy-backed payload */
+       struct lnet_hdr         ibim_hdr;       /* portals header */
+       char                    ibim_payload[0];/* piggy-backed payload */
 } WIRE_ATTR kib_immediate_msg_t;
 
 typedef struct
@@ -464,8 +464,8 @@ typedef struct
 
 typedef struct
 {
-        lnet_hdr_t        ibprm_hdr;            /* portals header */
-        __u64             ibprm_cookie;         /* opaque completion cookie */
+       struct lnet_hdr         ibprm_hdr;      /* portals header */
+       __u64                   ibprm_cookie;   /* opaque completion cookie */
 } WIRE_ATTR kib_putreq_msg_t;
 
 typedef struct
@@ -477,9 +477,9 @@ typedef struct
 
 typedef struct
 {
-        lnet_hdr_t        ibgm_hdr;             /* portals header */
-        __u64             ibgm_cookie;          /* opaque completion cookie */
-        kib_rdma_desc_t   ibgm_rd;              /* rdma descriptor */
+       struct lnet_hdr         ibgm_hdr;       /* portals header */
+       __u64                   ibgm_cookie;    /* opaque completion cookie */
+       kib_rdma_desc_t         ibgm_rd;        /* rdma descriptor */
 } WIRE_ATTR kib_get_msg_t;
 
 typedef struct
@@ -602,7 +602,7 @@ typedef struct kib_tx                           /* transmit message */
        /* completion cookie */
        __u64                   tx_cookie;
        /* lnet msgs to finalize on completion */
-       lnet_msg_t              *tx_lntmsg[2];
+       struct lnet_msg         *tx_lntmsg[2];
        /* message buffer (host vaddr) */
        kib_msg_t               *tx_msg;
        /* message buffer (I/O addr) */
@@ -725,7 +725,7 @@ typedef struct kib_peer
        /* who's on the other end(s) */
        lnet_nid_t              ibp_nid;
        /* LNet interface */
-       lnet_ni_t               *ibp_ni;
+       struct lnet_ni          *ibp_ni;
        /* all active connections */
        struct list_head        ibp_conns;
        /* msgs waiting for a conn */
@@ -937,7 +937,7 @@ kiblnd_send_keepalive(kib_conn_t *conn)
 static inline int
 kiblnd_need_noop(kib_conn_t *conn)
 {
-       lnet_ni_t *ni = conn->ibc_peer->ibp_ni;
+       struct lnet_ni *ni = conn->ibc_peer->ibp_ni;
        struct lnet_ioctl_config_o2iblnd_tunables *tunables;
 
        LASSERT(conn->ibc_state >= IBLND_CONN_ESTABLISHED);
@@ -1179,7 +1179,8 @@ int  kiblnd_cm_callback(struct rdma_cm_id *cmid,
 int  kiblnd_translate_mtu(int value);
 
 int  kiblnd_dev_failover(kib_dev_t *dev);
-int  kiblnd_create_peer(lnet_ni_t *ni, kib_peer_ni_t **peerp, lnet_nid_t nid);
+int kiblnd_create_peer(struct lnet_ni *ni, kib_peer_ni_t **peerp,
+                      lnet_nid_t nid);
 void kiblnd_destroy_peer (kib_peer_ni_t *peer);
 bool kiblnd_reconnect_peer(kib_peer_ni_t *peer);
 void kiblnd_destroy_dev (kib_dev_t *dev);
@@ -1195,20 +1196,22 @@ void kiblnd_destroy_conn(kib_conn_t *conn, bool free_conn);
 void kiblnd_close_conn (kib_conn_t *conn, int error);
 void kiblnd_close_conn_locked (kib_conn_t *conn, int error);
 
-void kiblnd_launch_tx (lnet_ni_t *ni, kib_tx_t *tx, lnet_nid_t nid);
-void kiblnd_txlist_done(lnet_ni_t *ni, struct list_head *txlist, int status);
+void kiblnd_launch_tx(struct lnet_ni *ni, kib_tx_t *tx, lnet_nid_t nid);
+void kiblnd_txlist_done(struct lnet_ni *ni, struct list_head *txlist,
+                       int status);
 
 void kiblnd_qp_event(struct ib_event *event, void *arg);
 void kiblnd_cq_event(struct ib_event *event, void *arg);
 void kiblnd_cq_completion(struct ib_cq *cq, void *arg);
 
-void kiblnd_pack_msg (lnet_ni_t *ni, kib_msg_t *msg, int version,
-                      int credits, lnet_nid_t dstnid, __u64 dststamp);
+void kiblnd_pack_msg(struct lnet_ni *ni, kib_msg_t *msg, int version,
+                    int credits, lnet_nid_t dstnid, __u64 dststamp);
 int  kiblnd_unpack_msg(kib_msg_t *msg, int nob);
 int  kiblnd_post_rx (kib_rx_t *rx, int credit);
 
-int  kiblnd_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg);
-int  kiblnd_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg, int delayed,
-                unsigned int niov, struct kvec *iov, lnet_kiov_t *kiov,
-                 unsigned int offset, unsigned int mlen, unsigned int rlen);
+int  kiblnd_send(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg);
+int kiblnd_recv(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg,
+               int delayed, unsigned int niov, struct kvec *iov,
+               lnet_kiov_t *kiov, unsigned int offset, unsigned int mlen,
+               unsigned int rlen);
 
index 3901be7..da2c084 100644 (file)
 
 static void kiblnd_peer_alive(kib_peer_ni_t *peer_ni);
 static void kiblnd_peer_connect_failed(kib_peer_ni_t *peer_ni, int active, int error);
-static void kiblnd_init_tx_msg(lnet_ni_t *ni, kib_tx_t *tx,
+static void kiblnd_init_tx_msg(struct lnet_ni *ni, kib_tx_t *tx,
                               int type, int body_nob);
 static int kiblnd_init_rdma(kib_conn_t *conn, kib_tx_t *tx, int type,
                            int resid, kib_rdma_desc_t *dstrd, __u64 dstcookie);
 static void kiblnd_queue_tx_locked(kib_tx_t *tx, kib_conn_t *conn);
 static void kiblnd_queue_tx(kib_tx_t *tx, kib_conn_t *conn);
-static void kiblnd_unmap_tx(lnet_ni_t *ni, kib_tx_t *tx);
+static void kiblnd_unmap_tx(struct lnet_ni *ni, kib_tx_t *tx);
 static void kiblnd_check_sends_locked(kib_conn_t *conn);
 
 void
-kiblnd_tx_done (lnet_ni_t *ni, kib_tx_t *tx)
+kiblnd_tx_done(struct lnet_ni *ni, kib_tx_t *tx)
 {
-       lnet_msg_t *lntmsg[2];
+       struct lnet_msg *lntmsg[2];
        kib_net_t  *net = ni->ni_data;
        int         rc;
        int         i;
@@ -93,7 +93,7 @@ kiblnd_tx_done (lnet_ni_t *ni, kib_tx_t *tx)
 }
 
 void
-kiblnd_txlist_done(lnet_ni_t *ni, struct list_head *txlist, int status)
+kiblnd_txlist_done(struct lnet_ni *ni, struct list_head *txlist, int status)
 {
        kib_tx_t *tx;
 
@@ -109,7 +109,7 @@ kiblnd_txlist_done(lnet_ni_t *ni, struct list_head *txlist, int status)
 }
 
 static kib_tx_t *
-kiblnd_get_idle_tx(lnet_ni_t *ni, lnet_nid_t target)
+kiblnd_get_idle_tx(struct lnet_ni *ni, lnet_nid_t target)
 {
        kib_net_t               *net = (kib_net_t *)ni->ni_data;
        struct list_head        *node;
@@ -250,7 +250,7 @@ static void
 kiblnd_handle_completion(kib_conn_t *conn, int txtype, int status, __u64 cookie)
 {
        kib_tx_t    *tx;
-       lnet_ni_t   *ni = conn->ibc_peer->ibp_ni;
+       struct lnet_ni   *ni = conn->ibc_peer->ibp_ni;
        int          idle;
 
        spin_lock(&conn->ibc_lock);
@@ -288,7 +288,7 @@ kiblnd_handle_completion(kib_conn_t *conn, int txtype, int status, __u64 cookie)
 static void
 kiblnd_send_completion(kib_conn_t *conn, int type, int status, __u64 cookie)
 {
-       lnet_ni_t   *ni = conn->ibc_peer->ibp_ni;
+       struct lnet_ni   *ni = conn->ibc_peer->ibp_ni;
        kib_tx_t    *tx = kiblnd_get_idle_tx(ni, conn->ibc_peer->ibp_nid);
 
         if (tx == NULL) {
@@ -309,7 +309,7 @@ kiblnd_handle_rx (kib_rx_t *rx)
 {
         kib_msg_t    *msg = rx->rx_msg;
         kib_conn_t   *conn = rx->rx_conn;
-        lnet_ni_t    *ni = conn->ibc_peer->ibp_ni;
+       struct lnet_ni    *ni = conn->ibc_peer->ibp_ni;
         int           credits = msg->ibm_credits;
         kib_tx_t     *tx;
         int           rc = 0;
@@ -470,7 +470,7 @@ kiblnd_rx_complete (kib_rx_t *rx, int status, int nob)
 {
         kib_msg_t    *msg = rx->rx_msg;
         kib_conn_t   *conn = rx->rx_conn;
-        lnet_ni_t    *ni = conn->ibc_peer->ibp_ni;
+       struct lnet_ni    *ni = conn->ibc_peer->ibp_ni;
         kib_net_t    *net = ni->ni_data;
         int           rc;
         int           err = -EIO;
@@ -591,7 +591,7 @@ kiblnd_fmr_map_tx(kib_net_t *net, kib_tx_t *tx, kib_rdma_desc_t *rd, __u32 nob)
 }
 
 static void
-kiblnd_unmap_tx(lnet_ni_t *ni, kib_tx_t *tx)
+kiblnd_unmap_tx(struct lnet_ni *ni, kib_tx_t *tx)
 {
        kib_net_t  *net = ni->ni_data;
 
@@ -608,7 +608,7 @@ kiblnd_unmap_tx(lnet_ni_t *ni, kib_tx_t *tx)
 }
 
 static int
-kiblnd_map_tx(lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd, int nfrags)
+kiblnd_map_tx(struct lnet_ni *ni, kib_tx_t *tx, kib_rdma_desc_t *rd, int nfrags)
 {
        kib_net_t     *net   = ni->ni_data;
        kib_hca_dev_t *hdev  = net->ibn_dev->ibd_hdev;
@@ -649,7 +649,7 @@ kiblnd_map_tx(lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd, int nfrags)
 
 
 static int
-kiblnd_setup_rd_iov(lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd,
+kiblnd_setup_rd_iov(struct lnet_ni *ni, kib_tx_t *tx, kib_rdma_desc_t *rd,
                    unsigned int niov, struct kvec *iov, int offset, int nob)
 {
         kib_net_t          *net = ni->ni_data;
@@ -706,8 +706,8 @@ kiblnd_setup_rd_iov(lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd,
 }
 
 static int
-kiblnd_setup_rd_kiov (lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd,
-                      int nkiov, lnet_kiov_t *kiov, int offset, int nob)
+kiblnd_setup_rd_kiov(struct lnet_ni *ni, kib_tx_t *tx, kib_rdma_desc_t *rd,
+                    int nkiov, lnet_kiov_t *kiov, int offset, int nob)
 {
         kib_net_t          *net = ni->ni_data;
         struct scatterlist *sg;
@@ -906,7 +906,7 @@ static void
 kiblnd_check_sends_locked(kib_conn_t *conn)
 {
         int        ver = conn->ibc_version;
-        lnet_ni_t *ni = conn->ibc_peer->ibp_ni;
+       struct lnet_ni *ni = conn->ibc_peer->ibp_ni;
         kib_tx_t  *tx;
 
         /* Don't send anything until after the connection is established */
@@ -1018,7 +1018,7 @@ kiblnd_tx_complete (kib_tx_t *tx, int status)
 }
 
 static void
-kiblnd_init_tx_msg (lnet_ni_t *ni, kib_tx_t *tx, int type, int body_nob)
+kiblnd_init_tx_msg(struct lnet_ni *ni, kib_tx_t *tx, int type, int body_nob)
 {
        kib_hca_dev_t *hdev = tx->tx_pool->tpo_hdev;
        struct ib_sge *sge = &tx->tx_sge[tx->tx_nwrq];
@@ -1361,7 +1361,7 @@ kiblnd_reconnect_peer(kib_peer_ni_t *peer_ni)
 }
 
 void
-kiblnd_launch_tx (lnet_ni_t *ni, kib_tx_t *tx, lnet_nid_t nid)
+kiblnd_launch_tx(struct lnet_ni *ni, kib_tx_t *tx, lnet_nid_t nid)
 {
         kib_peer_ni_t        *peer_ni;
         kib_peer_ni_t        *peer2;
@@ -1480,11 +1480,11 @@ kiblnd_launch_tx (lnet_ni_t *ni, kib_tx_t *tx, lnet_nid_t nid)
 }
 
 int
-kiblnd_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
+kiblnd_send(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg)
 {
-        lnet_hdr_t       *hdr = &lntmsg->msg_hdr;
+       struct lnet_hdr *hdr = &lntmsg->msg_hdr;
        int               type = lntmsg->msg_type;
-       lnet_process_id_t target = lntmsg->msg_target;
+       struct lnet_process_id target = lntmsg->msg_target;
        int               target_is_router = lntmsg->msg_target_is_router;
        int               routing = lntmsg->msg_routing;
        unsigned int      payload_niov = lntmsg->msg_niov;
@@ -1650,9 +1650,9 @@ kiblnd_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
 }
 
 static void
-kiblnd_reply (lnet_ni_t *ni, kib_rx_t *rx, lnet_msg_t *lntmsg)
+kiblnd_reply(struct lnet_ni *ni, kib_rx_t *rx, struct lnet_msg *lntmsg)
 {
-        lnet_process_id_t target = lntmsg->msg_target;
+       struct lnet_process_id target = lntmsg->msg_target;
         unsigned int      niov = lntmsg->msg_niov;
        struct kvec      *iov = lntmsg->msg_iov;
         lnet_kiov_t      *kiov = lntmsg->msg_kiov;
@@ -1712,8 +1712,8 @@ kiblnd_reply (lnet_ni_t *ni, kib_rx_t *rx, lnet_msg_t *lntmsg)
 }
 
 int
-kiblnd_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg, int delayed,
-           unsigned int niov, struct kvec *iov, lnet_kiov_t *kiov,
+kiblnd_recv(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg,
+           int delayed, unsigned int niov, struct kvec *iov, lnet_kiov_t *kiov,
            unsigned int offset, unsigned int mlen, unsigned int rlen)
 {
         kib_rx_t    *rx = private;
@@ -2162,7 +2162,7 @@ kiblnd_connreq_done(kib_conn_t *conn, int status)
 
         if (!kiblnd_peer_active(peer_ni) ||        /* peer_ni has been deleted */
             conn->ibc_comms_error != 0) {       /* error has happened already */
-                lnet_ni_t *ni = peer_ni->ibp_ni;
+               struct lnet_ni *ni = peer_ni->ibp_ni;
 
                 /* start to shut down connection */
                 kiblnd_close_conn_locked(conn, -ECONNABORTED);
@@ -2218,7 +2218,7 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
         kib_peer_ni_t            *peer_ni;
         kib_peer_ni_t            *peer2;
         kib_conn_t            *conn;
-        lnet_ni_t             *ni  = NULL;
+       struct lnet_ni             *ni  = NULL;
         kib_net_t             *net = NULL;
         lnet_nid_t             nid;
         struct rdma_conn_param cp;
@@ -2772,7 +2772,7 @@ static void
 kiblnd_check_connreply (kib_conn_t *conn, void *priv, int priv_nob)
 {
         kib_peer_ni_t    *peer_ni = conn->ibc_peer;
-        lnet_ni_t     *ni   = peer_ni->ibp_ni;
+       struct lnet_ni *ni   = peer_ni->ibp_ni;
         kib_net_t     *net  = ni->ni_data;
         kib_msg_t     *msg  = priv;
         int            ver  = conn->ibc_version;
index 54a81b5..f2195cb 100644 (file)
@@ -159,7 +159,7 @@ static struct lnet_ioctl_config_o2iblnd_tunables default_tunables;
 
 /* # messages/RDMAs in-flight */
 int
-kiblnd_msg_queue_size(int version, lnet_ni_t *ni)
+kiblnd_msg_queue_size(int version, struct lnet_ni *ni)
 {
        if (version == IBLND_MSG_VERSION_1)
                return IBLND_MSG_QUEUE_SIZE_V1;
@@ -170,7 +170,7 @@ kiblnd_msg_queue_size(int version, lnet_ni_t *ni)
 }
 
 int
-kiblnd_tunables_setup(lnet_ni_t *ni)
+kiblnd_tunables_setup(struct lnet_ni *ni)
 {
        struct lnet_ioctl_config_o2iblnd_tunables *tunables;
        struct lnet_ioctl_config_lnd_cmn_tunables *net_tunables;
index ad32457..0db9d6d 100644 (file)
 #include <linux/pci.h>
 #include "socklnd.h"
 
-static lnd_t                   the_ksocklnd;
+static struct lnet_lnd the_ksocklnd;
 ksock_nal_data_t        ksocknal_data;
 
 static ksock_interface_t *
-ksocknal_ip2iface(lnet_ni_t *ni, __u32 ip)
+ksocknal_ip2iface(struct lnet_ni *ni, __u32 ip)
 {
         ksock_net_t       *net = ni->ni_data;
         int                i;
@@ -97,7 +97,8 @@ ksocknal_destroy_route (ksock_route_t *route)
 }
 
 static int
-ksocknal_create_peer(ksock_peer_ni_t **peerp, lnet_ni_t *ni, lnet_process_id_t id)
+ksocknal_create_peer(ksock_peer_ni_t **peerp, struct lnet_ni *ni,
+                    struct lnet_process_id id)
 {
        int             cpt = lnet_cpt_of_nid(id.nid, ni);
        ksock_net_t     *net = ni->ni_data;
@@ -171,7 +172,7 @@ ksocknal_destroy_peer (ksock_peer_ni_t *peer_ni)
 }
 
 ksock_peer_ni_t *
-ksocknal_find_peer_locked (lnet_ni_t *ni, lnet_process_id_t id)
+ksocknal_find_peer_locked(struct lnet_ni *ni, struct lnet_process_id id)
 {
        struct list_head *peer_list = ksocknal_nid2peerlist(id.nid);
        struct list_head *tmp;
@@ -199,7 +200,7 @@ ksocknal_find_peer_locked (lnet_ni_t *ni, lnet_process_id_t id)
 }
 
 ksock_peer_ni_t *
-ksocknal_find_peer (lnet_ni_t *ni, lnet_process_id_t id)
+ksocknal_find_peer(struct lnet_ni *ni, struct lnet_process_id id)
 {
         ksock_peer_ni_t     *peer_ni;
 
@@ -243,9 +244,9 @@ ksocknal_unlink_peer_locked (ksock_peer_ni_t *peer_ni)
 }
 
 static int
-ksocknal_get_peer_info (lnet_ni_t *ni, int index,
-                        lnet_process_id_t *id, __u32 *myip, __u32 *peer_ip,
-                        int *port, int *conn_count, int *share_count)
+ksocknal_get_peer_info(struct lnet_ni *ni, int index,
+                      struct lnet_process_id *id, __u32 *myip, __u32 *peer_ip,
+                      int *port, int *conn_count, int *share_count)
 {
        ksock_peer_ni_t   *peer_ni;
        struct list_head  *ptmp;
@@ -442,7 +443,8 @@ ksocknal_del_route_locked (ksock_route_t *route)
 }
 
 int
-ksocknal_add_peer(lnet_ni_t *ni, lnet_process_id_t id, __u32 ipaddr, int port)
+ksocknal_add_peer(struct lnet_ni *ni, struct lnet_process_id id, __u32 ipaddr,
+                 int port)
 {
        struct list_head *tmp;
        ksock_peer_ni_t  *peer_ni;
@@ -559,7 +561,7 @@ ksocknal_del_peer_locked (ksock_peer_ni_t *peer_ni, __u32 ip)
 }
 
 static int
-ksocknal_del_peer (lnet_ni_t *ni, lnet_process_id_t id, __u32 ip)
+ksocknal_del_peer(struct lnet_ni *ni, struct lnet_process_id id, __u32 ip)
 {
        struct list_head  zombies = LIST_HEAD_INIT(zombies);
        struct list_head *ptmp;
@@ -622,7 +624,7 @@ ksocknal_del_peer (lnet_ni_t *ni, lnet_process_id_t id, __u32 ip)
 }
 
 static ksock_conn_t *
-ksocknal_get_conn_by_idx (lnet_ni_t *ni, int index)
+ksocknal_get_conn_by_idx(struct lnet_ni *ni, int index)
 {
        ksock_peer_ni_t  *peer_ni;
        struct list_head *ptmp;
@@ -683,7 +685,7 @@ ksocknal_choose_scheduler_locked(unsigned int cpt)
 }
 
 static int
-ksocknal_local_ipvec (lnet_ni_t *ni, __u32 *ipaddrs)
+ksocknal_local_ipvec(struct lnet_ni *ni, __u32 *ipaddrs)
 {
         ksock_net_t       *net = ni->ni_data;
         int                i;
@@ -854,7 +856,7 @@ ksocknal_create_routes(ksock_peer_ni_t *peer_ni, int port,
 {
        ksock_route_t           *newroute = NULL;
        rwlock_t                *global_lock = &ksocknal_data.ksnd_global_lock;
-       lnet_ni_t               *ni = peer_ni->ksnp_ni;
+       struct lnet_ni *ni = peer_ni->ksnp_ni;
        ksock_net_t             *net = ni->ni_data;
        struct list_head        *rtmp;
        ksock_route_t           *route;
@@ -967,7 +969,7 @@ ksocknal_create_routes(ksock_peer_ni_t *peer_ni, int port,
 }
 
 int
-ksocknal_accept(lnet_ni_t *ni, struct socket *sock)
+ksocknal_accept(struct lnet_ni *ni, struct socket *sock)
 {
        ksock_connreq_t *cr;
        int              rc;
@@ -1010,12 +1012,12 @@ ksocknal_connecting (ksock_peer_ni_t *peer_ni, __u32 ipaddr)
 }
 
 int
-ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *route,
+ksocknal_create_conn(struct lnet_ni *ni, ksock_route_t *route,
                     struct socket *sock, int type)
 {
        rwlock_t                *global_lock = &ksocknal_data.ksnd_global_lock;
        struct list_head        zombies = LIST_HEAD_INIT(zombies);
-       lnet_process_id_t       peerid;
+       struct lnet_process_id peerid;
        struct list_head        *tmp;
         __u64              incarnation;
         ksock_conn_t      *conn;
@@ -1721,7 +1723,7 @@ ksocknal_close_conn_and_siblings (ksock_conn_t *conn, int why)
 }
 
 int
-ksocknal_close_matching_conns (lnet_process_id_t id, __u32 ipaddr)
+ksocknal_close_matching_conns(struct lnet_process_id id, __u32 ipaddr)
 {
         ksock_peer_ni_t       *peer_ni;
        struct list_head         *ptmp;
@@ -1763,14 +1765,15 @@ ksocknal_close_matching_conns (lnet_process_id_t id, __u32 ipaddr)
 }
 
 void
-ksocknal_notify (lnet_ni_t *ni, lnet_nid_t gw_nid, int alive)
+ksocknal_notify(struct lnet_ni *ni, lnet_nid_t gw_nid, int alive)
 {
-        /* The router is telling me she's been notified of a change in
-         * gateway state.... */
-        lnet_process_id_t  id = {0};
-
-        id.nid = gw_nid;
-        id.pid = LNET_PID_ANY;
+       /* The router is telling me she's been notified of a change in
+        * gateway state....
+        */
+       struct lnet_process_id id = {
+               .nid    = gw_nid,
+               .pid    = LNET_PID_ANY,
+       };
 
         CDEBUG (D_NET, "gw %s %s\n", libcfs_nid2str(gw_nid),
                 alive ? "up" : "down");
@@ -1786,14 +1789,14 @@ ksocknal_notify (lnet_ni_t *ni, lnet_nid_t gw_nid, int alive)
 }
 
 void
-ksocknal_query(lnet_ni_t *ni, lnet_nid_t nid, cfs_time_t *when)
+ksocknal_query(struct lnet_ni *ni, lnet_nid_t nid, cfs_time_t *when)
 {
        int connect = 1;
        time64_t last_alive = 0;
        time64_t now = ktime_get_real_seconds();
        ksock_peer_ni_t *peer_ni = NULL;
        rwlock_t *glock = &ksocknal_data.ksnd_global_lock;
-       lnet_process_id_t id = {
+       struct lnet_process_id id = {
                .nid = nid,
                .pid = LNET_PID_LUSTRE,
        };
@@ -1883,7 +1886,7 @@ ksocknal_push_peer (ksock_peer_ni_t *peer_ni)
 }
 
 static int
-ksocknal_push (lnet_ni_t *ni, lnet_process_id_t id)
+ksocknal_push(struct lnet_ni *ni, struct lnet_process_id id)
 {
        struct list_head *start;
        struct list_head *end;
@@ -1932,7 +1935,7 @@ ksocknal_push (lnet_ni_t *ni, lnet_process_id_t id)
 }
 
 static int
-ksocknal_add_interface(lnet_ni_t *ni, __u32 ipaddress, __u32 netmask)
+ksocknal_add_interface(struct lnet_ni *ni, __u32 ipaddress, __u32 netmask)
 {
         ksock_net_t       *net = ni->ni_data;
         ksock_interface_t *iface;
@@ -2035,7 +2038,7 @@ ksocknal_peer_del_interface_locked(ksock_peer_ni_t *peer_ni, __u32 ipaddr)
 }
 
 static int
-ksocknal_del_interface(lnet_ni_t *ni, __u32 ipaddress)
+ksocknal_del_interface(struct lnet_ni *ni, __u32 ipaddress)
 {
         ksock_net_t       *net = ni->ni_data;
         int                rc = -ENOENT;
@@ -2083,9 +2086,9 @@ ksocknal_del_interface(lnet_ni_t *ni, __u32 ipaddress)
 }
 
 int
-ksocknal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg)
+ksocknal_ctl(struct lnet_ni *ni, unsigned int cmd, void *arg)
 {
-       lnet_process_id_t id = {0};
+       struct lnet_process_id id = {0};
         struct libcfs_ioctl_data *data = arg;
         int rc;
 
@@ -2493,7 +2496,7 @@ ksocknal_base_startup(void)
 }
 
 static void
-ksocknal_debug_peerhash (lnet_ni_t *ni)
+ksocknal_debug_peerhash(struct lnet_ni *ni)
 {
        ksock_peer_ni_t *peer_ni = NULL;
        struct list_head        *tmp;
@@ -2547,14 +2550,14 @@ ksocknal_debug_peerhash (lnet_ni_t *ni)
 }
 
 void
-ksocknal_shutdown (lnet_ni_t *ni)
+ksocknal_shutdown(struct lnet_ni *ni)
 {
-        ksock_net_t      *net = ni->ni_data;
-        int               i;
-        lnet_process_id_t anyid = {0};
-
-        anyid.nid =  LNET_NID_ANY;
-        anyid.pid =  LNET_PID_ANY;
+       ksock_net_t *net = ni->ni_data;
+       struct lnet_process_id anyid = {
+               .nid = LNET_NID_ANY,
+               .pid = LNET_PID_ANY,
+       };
+       int i;
 
         LASSERT(ksocknal_data.ksnd_init == SOCKNAL_INIT_ALL);
         LASSERT(ksocknal_data.ksnd_nnets > 0);
@@ -2771,7 +2774,7 @@ ksocknal_net_start_threads(ksock_net_t *net, __u32 *cpts, int ncpts)
 }
 
 int
-ksocknal_startup (lnet_ni_t *ni)
+ksocknal_startup(struct lnet_ni *ni)
 {
        ksock_net_t  *net;
        int           rc;
index fd24314..e3634c0 100644 (file)
@@ -286,7 +286,7 @@ typedef struct                                  /* transmit packet */
         unsigned short tx_nonblk:1;    /* it's a non-blocking ACK */
         lnet_kiov_t   *tx_kiov;        /* packet page frags */
        struct ksock_conn *tx_conn;        /* owning conn */
-        lnet_msg_t    *tx_lnetmsg;     /* lnet message for lnet_finalize() */
+       struct lnet_msg   *tx_lnetmsg;  /* lnet message for lnet_finalize() */
         cfs_time_t     tx_deadline;    /* when (in jiffies) tx times out */
        struct ksock_msg    tx_msg;         /* socklnd message buffer */
         int            tx_desc_size;   /* size of this descriptor */
@@ -358,13 +358,13 @@ typedef struct ksock_conn
         ksock_rxiovspace_t    ksnc_rx_iov_space;/* space for frag descriptors */
         __u32                 ksnc_rx_csum;     /* partial checksum for incoming data */
         void                 *ksnc_cookie;      /* rx lnet_finalize passthru arg */
-       struct ksock_msg           ksnc_msg;         /* incoming message buffer:
-                                                 * V2.x message takes the
-                                                 * whole struct
-                                                 * V1.x message is a bare
-                                                 * lnet_hdr_t, it's stored in
-                                                 * ksnc_msg.ksm_u.lnetmsg */
-
+       struct ksock_msg        ksnc_msg;       /* incoming message buffer:
+                                                * V2.x message takes the
+                                                * whole struct
+                                                * V1.x message is a bare
+                                                * struct lnet_hdr, it's stored
+                                                * in ksnc_msg.ksm_u.lnetmsg
+                                                */
        /* -- WRITER -- */
        /* where I enq waiting for output space */
        struct list_head        ksnc_tx_list;
@@ -411,7 +411,7 @@ typedef struct ksock_peer
 {
        struct list_head        ksnp_list;      /* stash on global peer_ni list */
        cfs_time_t            ksnp_last_alive;  /* when (in jiffies) I was last alive */
-       lnet_process_id_t     ksnp_id;       /* who's on the other end(s) */
+       struct lnet_process_id  ksnp_id;        /* who's on the other end(s) */
        atomic_t              ksnp_refcount; /* # users */
        int                   ksnp_sharecount;  /* lconf usage counter */
        int                   ksnp_closing;  /* being closed */
@@ -427,7 +427,7 @@ typedef struct ksock_peer
        /* zero copy requests wait for ACK  */
        struct list_head        ksnp_zc_req_list;
         cfs_time_t            ksnp_send_keepalive; /* time to send keepalive */
-        lnet_ni_t            *ksnp_ni;       /* which network */
+       struct lnet_ni            *ksnp_ni;       /* which network */
         int                   ksnp_n_passive_ips; /* # of... */
         __u32                 ksnp_passive_ips[LNET_MAX_INTERFACES]; /* preferred local interfaces */
 } ksock_peer_ni_t;
@@ -437,7 +437,7 @@ typedef struct ksock_connreq
        /* stash on ksnd_connd_connreqs */
        struct list_head        ksncr_list;
        /* chosen NI */
-       lnet_ni_t               *ksncr_ni;
+       struct lnet_ni          *ksncr_ni;
        /* accepted socket */
        struct socket           *ksncr_sock;
 } ksock_connreq_t;
@@ -564,7 +564,7 @@ ksocknal_tx_addref (ksock_tx_t *tx)
 }
 
 extern void ksocknal_tx_prep (ksock_conn_t *, ksock_tx_t *tx);
-extern void ksocknal_tx_done (lnet_ni_t *ni, ksock_tx_t *tx);
+extern void ksocknal_tx_done(struct lnet_ni *ni, ksock_tx_t *tx);
 
 static inline void
 ksocknal_tx_decref (ksock_tx_t *tx)
@@ -608,42 +608,45 @@ ksocknal_peer_decref (ksock_peer_ni_t *peer_ni)
                ksocknal_destroy_peer (peer_ni);
 }
 
-int ksocknal_startup (lnet_ni_t *ni);
-void ksocknal_shutdown (lnet_ni_t *ni);
-int ksocknal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg);
-int ksocknal_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg);
-int ksocknal_recv(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg,
+int ksocknal_startup(struct lnet_ni *ni);
+void ksocknal_shutdown(struct lnet_ni *ni);
+int ksocknal_ctl(struct lnet_ni *ni, unsigned int cmd, void *arg);
+int ksocknal_send(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg);
+int ksocknal_recv(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg,
                  int delayed, unsigned int niov,
                  struct kvec *iov, lnet_kiov_t *kiov,
                   unsigned int offset, unsigned int mlen, unsigned int rlen);
-int ksocknal_accept(lnet_ni_t *ni, struct socket *sock);
-
-extern int ksocknal_add_peer(lnet_ni_t *ni, lnet_process_id_t id, __u32 ip, int port);
-extern ksock_peer_ni_t *ksocknal_find_peer_locked (lnet_ni_t *ni, lnet_process_id_t id);
-extern ksock_peer_ni_t *ksocknal_find_peer (lnet_ni_t *ni, lnet_process_id_t id);
+int ksocknal_accept(struct lnet_ni *ni, struct socket *sock);
+
+int ksocknal_add_peer(struct lnet_ni *ni, struct lnet_process_id id, __u32 ip,
+                     int port);
+ksock_peer_ni_t *ksocknal_find_peer_locked(struct lnet_ni *ni,
+                                          struct lnet_process_id id);
+ksock_peer_ni_t *ksocknal_find_peer(struct lnet_ni *ni,
+                                   struct lnet_process_id id);
 extern void ksocknal_peer_failed (ksock_peer_ni_t *peer_ni);
-extern int ksocknal_create_conn (lnet_ni_t *ni, ksock_route_t *route,
-                                struct socket *sock, int type);
+extern int ksocknal_create_conn(struct lnet_ni *ni, ksock_route_t *route,
+                               struct socket *sock, int type);
 extern void ksocknal_close_conn_locked (ksock_conn_t *conn, int why);
 extern void ksocknal_terminate_conn (ksock_conn_t *conn);
 extern void ksocknal_destroy_conn (ksock_conn_t *conn);
 extern int  ksocknal_close_peer_conns_locked (ksock_peer_ni_t *peer_ni,
                                               __u32 ipaddr, int why);
 extern int ksocknal_close_conn_and_siblings (ksock_conn_t *conn, int why);
-extern int ksocknal_close_matching_conns(lnet_process_id_t id, __u32 ipaddr);
+int ksocknal_close_matching_conns(struct lnet_process_id id, __u32 ipaddr);
 extern ksock_conn_t *ksocknal_find_conn_locked(ksock_peer_ni_t *peer_ni,
                                                ksock_tx_t *tx, int nonblk);
 
-extern int  ksocknal_launch_packet(lnet_ni_t *ni, ksock_tx_t *tx,
-                                   lnet_process_id_t id);
+extern int  ksocknal_launch_packet(struct lnet_ni *ni, ksock_tx_t *tx,
+                                  struct lnet_process_id id);
 extern ksock_tx_t *ksocknal_alloc_tx(int type, int size);
 extern void ksocknal_free_tx (ksock_tx_t *tx);
 extern ksock_tx_t *ksocknal_alloc_tx_noop(__u64 cookie, int nonblk);
 extern void ksocknal_next_tx_carrier(ksock_conn_t *conn);
 extern void ksocknal_queue_tx_locked (ksock_tx_t *tx, ksock_conn_t *conn);
-extern void ksocknal_txlist_done(lnet_ni_t *ni, struct list_head *txlist,
+extern void ksocknal_txlist_done(struct lnet_ni *ni, struct list_head *txlist,
                                 int error);
-extern void ksocknal_notify (lnet_ni_t *ni, lnet_nid_t gw_nid, int alive);
+extern void ksocknal_notify(struct lnet_ni *ni, lnet_nid_t gw_nid, int alive);
 extern void ksocknal_query (struct lnet_ni *ni, lnet_nid_t nid, cfs_time_t *when);
 extern int ksocknal_thread_start(int (*fn)(void *arg), void *arg, char *name);
 extern void ksocknal_thread_fini (void);
@@ -654,11 +657,12 @@ extern int ksocknal_new_packet (ksock_conn_t *conn, int skip);
 extern int ksocknal_scheduler (void *arg);
 extern int ksocknal_connd (void *arg);
 extern int ksocknal_reaper (void *arg);
-extern int ksocknal_send_hello(lnet_ni_t *ni, ksock_conn_t *conn,
-                               lnet_nid_t peer_nid, struct ksock_hello_msg *hello);
-extern int ksocknal_recv_hello(lnet_ni_t *ni, ksock_conn_t *conn,
-                              struct ksock_hello_msg *hello, lnet_process_id_t *id,
-                              __u64 *incarnation);
+int ksocknal_send_hello(struct lnet_ni *ni, ksock_conn_t *conn,
+                       lnet_nid_t peer_nid, struct ksock_hello_msg *hello);
+int ksocknal_recv_hello(struct lnet_ni *ni, ksock_conn_t *conn,
+                       struct ksock_hello_msg *hello,
+                       struct lnet_process_id *id,
+                       __u64 *incarnation);
 extern void ksocknal_read_callback(ksock_conn_t *conn);
 extern void ksocknal_write_callback(ksock_conn_t *conn);
 
index b69599b..17c889f 100644 (file)
@@ -389,9 +389,9 @@ ksocknal_receive (ksock_conn_t *conn)
 }
 
 void
-ksocknal_tx_done (lnet_ni_t *ni, ksock_tx_t *tx)
+ksocknal_tx_done(struct lnet_ni *ni, ksock_tx_t *tx)
 {
-        lnet_msg_t  *lnetmsg = tx->tx_lnetmsg;
+       struct lnet_msg *lnetmsg = tx->tx_lnetmsg;
         int          rc = (tx->tx_resid == 0 && !tx->tx_zc_aborted) ? 0 : -EIO;
         ENTRY;
 
@@ -411,9 +411,9 @@ ksocknal_tx_done (lnet_ni_t *ni, ksock_tx_t *tx)
 }
 
 void
-ksocknal_txlist_done(lnet_ni_t *ni, struct list_head *txlist, int error)
+ksocknal_txlist_done(struct lnet_ni *ni, struct list_head *txlist, int error)
 {
-        ksock_tx_t *tx;
+       ksock_tx_t *tx;
 
        while (!list_empty(txlist)) {
                tx = list_entry(txlist->next, ksock_tx_t, tx_list);
@@ -832,7 +832,8 @@ ksocknal_find_connecting_route_locked (ksock_peer_ni_t *peer_ni)
 }
 
 int
-ksocknal_launch_packet (lnet_ni_t *ni, ksock_tx_t *tx, lnet_process_id_t id)
+ksocknal_launch_packet(struct lnet_ni *ni, ksock_tx_t *tx,
+                      struct lnet_process_id id)
 {
         ksock_peer_ni_t     *peer_ni;
         ksock_conn_t     *conn;
@@ -923,11 +924,11 @@ ksocknal_launch_packet (lnet_ni_t *ni, ksock_tx_t *tx, lnet_process_id_t id)
 }
 
 int
-ksocknal_send(lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
+ksocknal_send(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg)
 {
-        int               mpflag = 1;
-        int               type = lntmsg->msg_type;
-        lnet_process_id_t target = lntmsg->msg_target;
+       int mpflag = 1;
+       int type = lntmsg->msg_type;
+       struct lnet_process_id target = lntmsg->msg_target;
         unsigned int      payload_niov = lntmsg->msg_niov;
        struct kvec *payload_iov = lntmsg->msg_iov;
         lnet_kiov_t      *payload_kiov = lntmsg->msg_kiov;
@@ -1061,15 +1062,15 @@ ksocknal_new_packet (ksock_conn_t *conn, int nob_to_skip)
                        conn->ksnc_rx_iov[0].iov_len  = offsetof(struct ksock_msg, ksm_u);
                         break;
 
-                case KSOCK_PROTO_V1:
-                        /* Receiving bare lnet_hdr_t */
-                        conn->ksnc_rx_state = SOCKNAL_RX_LNET_HEADER;
-                        conn->ksnc_rx_nob_wanted = sizeof(lnet_hdr_t);
-                        conn->ksnc_rx_nob_left = sizeof(lnet_hdr_t);
+               case KSOCK_PROTO_V1:
+                       /* Receiving bare struct lnet_hdr */
+                       conn->ksnc_rx_state = SOCKNAL_RX_LNET_HEADER;
+                       conn->ksnc_rx_nob_wanted = sizeof(struct lnet_hdr);
+                       conn->ksnc_rx_nob_left = sizeof(struct lnet_hdr);
 
                        conn->ksnc_rx_iov = (struct kvec *)&conn->ksnc_rx_iov_space;
-                        conn->ksnc_rx_iov[0].iov_base = (char *)&conn->ksnc_msg.ksm_u.lnetmsg;
-                        conn->ksnc_rx_iov[0].iov_len  = sizeof (lnet_hdr_t);
+                       conn->ksnc_rx_iov[0].iov_base = (char *)&conn->ksnc_msg.ksm_u.lnetmsg;
+                       conn->ksnc_rx_iov[0].iov_len = sizeof(struct lnet_hdr);
                         break;
 
                 default:
@@ -1114,9 +1115,9 @@ ksocknal_new_packet (ksock_conn_t *conn, int nob_to_skip)
 static int
 ksocknal_process_receive (ksock_conn_t *conn)
 {
-        lnet_hdr_t        *lhdr;
-        lnet_process_id_t *id;
-        int                rc;
+       struct lnet_hdr *lhdr;
+       struct lnet_process_id *id;
+       int rc;
 
        LASSERT (atomic_read(&conn->ksnc_conn_refcount) > 0);
 
@@ -1131,10 +1132,11 @@ ksocknal_process_receive (ksock_conn_t *conn)
                 rc = ksocknal_receive(conn);
 
                if (rc <= 0) {
-                       lnet_process_id_t ksnp_id = conn->ksnc_peer->ksnp_id;
+                       struct lnet_process_id ksnp_id;
 
-                       LASSERT(rc != -EAGAIN);
+                       ksnp_id = conn->ksnc_peer->ksnp_id;
 
+                       LASSERT(rc != -EAGAIN);
                        if (rc == 0)
                                CDEBUG(D_NET, "[%p] EOF from %s "
                                       "ip %pI4h:%d\n", conn,
@@ -1318,9 +1320,10 @@ ksocknal_process_receive (ksock_conn_t *conn)
 }
 
 int
-ksocknal_recv (lnet_ni_t *ni, void *private, lnet_msg_t *msg, int delayed,
-              unsigned int niov, struct kvec *iov, lnet_kiov_t *kiov,
-               unsigned int offset, unsigned int mlen, unsigned int rlen)
+ksocknal_recv(struct lnet_ni *ni, void *private, struct lnet_msg *msg,
+             int delayed, unsigned int niov, struct kvec *iov,
+             lnet_kiov_t *kiov, unsigned int offset, unsigned int mlen,
+             unsigned int rlen)
 {
         ksock_conn_t  *conn = (ksock_conn_t *)private;
         ksock_sched_t *sched = conn->ksnc_scheduler;
@@ -1645,10 +1648,12 @@ ksocknal_parse_proto_version (struct ksock_hello_msg *hello)
         }
 
         if (hello->kshm_magic == le32_to_cpu(LNET_PROTO_TCP_MAGIC)) {
-                lnet_magicversion_t *hmv = (lnet_magicversion_t *)hello;
+               struct lnet_magicversion *hmv;
+
+               CLASSERT(sizeof(struct lnet_magicversion) ==
+                        offsetof(struct ksock_hello_msg, kshm_src_nid));
 
-                CLASSERT (sizeof (lnet_magicversion_t) ==
-                         offsetof (struct ksock_hello_msg, kshm_src_nid));
+               hmv = (struct lnet_magicversion *)hello;
 
                 if (hmv->version_major == cpu_to_le16 (KSOCK_PROTO_V1_MAJOR) &&
                     hmv->version_minor == cpu_to_le16 (KSOCK_PROTO_V1_MINOR))
@@ -1659,8 +1664,8 @@ ksocknal_parse_proto_version (struct ksock_hello_msg *hello)
 }
 
 int
-ksocknal_send_hello (lnet_ni_t *ni, ksock_conn_t *conn,
-                    lnet_nid_t peer_nid, struct ksock_hello_msg *hello)
+ksocknal_send_hello(struct lnet_ni *ni, ksock_conn_t *conn,
+                   lnet_nid_t peer_nid, struct ksock_hello_msg *hello)
 {
         /* CAVEAT EMPTOR: this byte flips 'ipaddrs' */
         ksock_net_t         *net = (ksock_net_t *)ni->ni_data;
@@ -1698,8 +1703,9 @@ ksocknal_invert_type(int type)
 }
 
 int
-ksocknal_recv_hello(lnet_ni_t *ni, ksock_conn_t *conn,
-                   struct ksock_hello_msg *hello, lnet_process_id_t *peerid,
+ksocknal_recv_hello(struct lnet_ni *ni, ksock_conn_t *conn,
+                   struct ksock_hello_msg *hello,
+                   struct lnet_process_id *peerid,
                    __u64 *incarnation)
 {
         /* Return < 0        fatal error
@@ -1713,7 +1719,7 @@ ksocknal_recv_hello(lnet_ni_t *ni, ksock_conn_t *conn,
         int                  proto_match;
         int                  rc;
         ksock_proto_t       *proto;
-        lnet_process_id_t    recv_id;
+       struct lnet_process_id    recv_id;
 
        /* socket type set on active connections - not set on passive */
        LASSERT(!active == !(conn->ksnc_type != SOCKLND_CONN_NONE));
index dff1166..8938089 100644 (file)
@@ -286,7 +286,7 @@ ksocknal_match_tx(ksock_conn_t *conn, ksock_tx_t *tx, int nonblk)
         } else {
                 nob = tx->tx_lnetmsg->msg_len +
                       ((conn->ksnc_proto == &ksocknal_protocol_v1x) ?
-                      sizeof(lnet_hdr_t) : sizeof(struct ksock_msg));
+                      sizeof(struct lnet_hdr) : sizeof(struct ksock_msg));
         }
 
         /* default checking for typed connection */
@@ -451,23 +451,24 @@ ksocknal_handle_zcack(ksock_conn_t *conn, __u64 cookie1, __u64 cookie2)
 static int
 ksocknal_send_hello_v1 (ksock_conn_t *conn, struct ksock_hello_msg *hello)
 {
-       struct socket        *sock = conn->ksnc_sock;
-        lnet_hdr_t          *hdr;
-        lnet_magicversion_t *hmv;
-        int                  rc;
-        int                  i;
-
-        CLASSERT(sizeof(lnet_magicversion_t) == offsetof(lnet_hdr_t, src_nid));
-
-        LIBCFS_ALLOC(hdr, sizeof(*hdr));
-        if (hdr == NULL) {
-                CERROR("Can't allocate lnet_hdr_t\n");
-                return -ENOMEM;
-        }
+       struct socket *sock = conn->ksnc_sock;
+       struct lnet_hdr *hdr;
+       struct lnet_magicversion *hmv;
+       int rc;
+       int i;
+
+       CLASSERT(sizeof(struct lnet_magicversion) ==
+                offsetof(struct lnet_hdr, src_nid));
+
+       LIBCFS_ALLOC(hdr, sizeof(*hdr));
+       if (hdr == NULL) {
+               CERROR("Can't allocate struct lnet_hdr\n");
+               return -ENOMEM;
+       }
 
-        hmv = (lnet_magicversion_t *)&hdr->dest_nid;
+       hmv = (struct lnet_magicversion *)&hdr->dest_nid;
 
-        /* Re-organize V2.x message header to V1.x (lnet_hdr_t)
+       /* Re-organize V2.x message header to V1.x (struct lnet_hdr)
          * header and send out */
         hmv->magic         = cpu_to_le32 (LNET_PROTO_TCP_MAGIC);
         hmv->version_major = cpu_to_le16 (KSOCK_PROTO_V1_MAJOR);
@@ -568,19 +569,19 @@ ksocknal_send_hello_v2 (ksock_conn_t *conn, struct ksock_hello_msg *hello)
 static int
 ksocknal_recv_hello_v1(ksock_conn_t *conn, struct ksock_hello_msg *hello,int timeout)
 {
-       struct socket        *sock = conn->ksnc_sock;
-        lnet_hdr_t          *hdr;
-        int                  rc;
-        int                  i;
-
-        LIBCFS_ALLOC(hdr, sizeof(*hdr));
-        if (hdr == NULL) {
-                CERROR("Can't allocate lnet_hdr_t\n");
-                return -ENOMEM;
-        }
+       struct socket *sock = conn->ksnc_sock;
+       struct lnet_hdr *hdr;
+       int rc;
+       int i;
+
+       LIBCFS_ALLOC(hdr, sizeof(*hdr));
+       if (hdr == NULL) {
+               CERROR("Can't allocate struct lnet_hdr\n");
+               return -ENOMEM;
+       }
 
        rc = lnet_sock_read(sock, &hdr->src_nid,
-                             sizeof(*hdr) - offsetof(lnet_hdr_t, src_nid),
+                             sizeof(*hdr) - offsetof(struct lnet_hdr, src_nid),
                              timeout);
        if (rc != 0) {
                CERROR("Error %d reading rest of HELLO hdr from %pI4h\n",
@@ -711,14 +712,15 @@ ksocknal_recv_hello_v2(ksock_conn_t *conn, struct ksock_hello_msg *hello,
 static void
 ksocknal_pack_msg_v1(ksock_tx_t *tx)
 {
-        /* V1.x has no KSOCK_MSG_NOOP */
-        LASSERT(tx->tx_msg.ksm_type != KSOCK_MSG_NOOP);
-        LASSERT(tx->tx_lnetmsg != NULL);
+       /* V1.x has no KSOCK_MSG_NOOP */
+       LASSERT(tx->tx_msg.ksm_type != KSOCK_MSG_NOOP);
+       LASSERT(tx->tx_lnetmsg != NULL);
 
-        tx->tx_iov[0].iov_base = (void *)&tx->tx_lnetmsg->msg_hdr;
-        tx->tx_iov[0].iov_len  = sizeof(lnet_hdr_t);
+       tx->tx_iov[0].iov_base = (void *)&tx->tx_lnetmsg->msg_hdr;
+       tx->tx_iov[0].iov_len  = sizeof(struct lnet_hdr);
 
-        tx->tx_resid = tx->tx_nob = tx->tx_lnetmsg->msg_len + sizeof(lnet_hdr_t);
+       tx->tx_nob = tx->tx_lnetmsg->msg_len + sizeof(struct lnet_hdr);
+       tx->tx_resid = tx->tx_nob;
 }
 
 static void
index 8230ceb..885cd85 100644 (file)
@@ -152,7 +152,7 @@ int
 lnet_connect(struct socket **sockp, lnet_nid_t peer_nid,
            __u32 local_ip, __u32 peer_ip, int peer_port)
 {
-       lnet_acceptor_connreq_t cr;
+       struct lnet_acceptor_connreq cr;
        struct socket           *sock;
        int                     rc;
        int                     port;
@@ -217,12 +217,12 @@ EXPORT_SYMBOL(lnet_connect);
 static int
 lnet_accept(struct socket *sock, __u32 magic)
 {
-       lnet_acceptor_connreq_t cr;
+       struct lnet_acceptor_connreq cr;
        __u32                   peer_ip;
        int                     peer_port;
        int                     rc;
        int                     flip;
-       lnet_ni_t              *ni;
+       struct lnet_ni *ni;
        char                   *str;
 
        LASSERT(sizeof(cr) <= 16);              /* not too big for the stack */
@@ -299,7 +299,7 @@ lnet_accept(struct socket *sock, __u32 magic)
 
        rc = lnet_sock_read(sock, &cr.acr_nid,
                              sizeof(cr) -
-                             offsetof(lnet_acceptor_connreq_t, acr_nid),
+                             offsetof(struct lnet_acceptor_connreq, acr_nid),
                              accept_timeout);
        if (rc != 0) {
                CERROR("Error %d reading connection request from "
index 84825a1..1ffe5b9 100644 (file)
@@ -38,7 +38,7 @@
 
 #define D_LNI D_CONSOLE
 
-lnet_t     the_lnet;                           /* THE state of the network */
+struct lnet the_lnet;          /* THE state of the network */
 EXPORT_SYMBOL(the_lnet);
 
 static char *ip2nets = "";
@@ -76,8 +76,8 @@ MODULE_PARM_DESC(lnet_numa_range,
  */
 static atomic_t lnet_dlc_seq_no = ATOMIC_INIT(0);
 
-static int lnet_ping(lnet_process_id_t id, signed long timeout,
-                    lnet_process_id_t __user *ids, int n_ids);
+static int lnet_ping(struct lnet_process_id id, signed long timeout,
+                    struct lnet_process_id __user *ids, int n_ids);
 
 static char *
 lnet_get_routes(void)
@@ -133,7 +133,7 @@ lnet_descriptor_setup(void)
        /* create specific kmem_cache for MEs and small MDs (i.e., originally
         * allocated in <size-xxx> kmem_cache).
         */
-       lnet_mes_cachep = kmem_cache_create("lnet_MEs", sizeof(lnet_me_t),
+       lnet_mes_cachep = kmem_cache_create("lnet_MEs", sizeof(struct lnet_me),
                                            0, 0, NULL);
        if (!lnet_mes_cachep)
                return -ENOMEM;
@@ -259,83 +259,83 @@ static void lnet_assert_wire_constants(void)
        CLASSERT((int)offsetof(struct lnet_handle_wire, wh_object_cookie) == 8);
        CLASSERT((int)sizeof(((struct lnet_handle_wire *)0)->wh_object_cookie) == 8);
 
-       /* Checks for struct lnet_magicversion_t */
-       CLASSERT((int)sizeof(lnet_magicversion_t) == 8);
-       CLASSERT((int)offsetof(lnet_magicversion_t, magic) == 0);
-       CLASSERT((int)sizeof(((lnet_magicversion_t *)0)->magic) == 4);
-       CLASSERT((int)offsetof(lnet_magicversion_t, version_major) == 4);
-       CLASSERT((int)sizeof(((lnet_magicversion_t *)0)->version_major) == 2);
-       CLASSERT((int)offsetof(lnet_magicversion_t, version_minor) == 6);
-       CLASSERT((int)sizeof(((lnet_magicversion_t *)0)->version_minor) == 2);
-
-       /* Checks for struct lnet_hdr_t */
-       CLASSERT((int)sizeof(lnet_hdr_t) == 72);
-       CLASSERT((int)offsetof(lnet_hdr_t, dest_nid) == 0);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->dest_nid) == 8);
-       CLASSERT((int)offsetof(lnet_hdr_t, src_nid) == 8);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->src_nid) == 8);
-       CLASSERT((int)offsetof(lnet_hdr_t, dest_pid) == 16);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->dest_pid) == 4);
-       CLASSERT((int)offsetof(lnet_hdr_t, src_pid) == 20);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->src_pid) == 4);
-       CLASSERT((int)offsetof(lnet_hdr_t, type) == 24);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->type) == 4);
-       CLASSERT((int)offsetof(lnet_hdr_t, payload_length) == 28);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->payload_length) == 4);
-       CLASSERT((int)offsetof(lnet_hdr_t, msg) == 32);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg) == 40);
+       /* Checks for struct struct lnet_magicversion */
+       CLASSERT((int)sizeof(struct lnet_magicversion) == 8);
+       CLASSERT((int)offsetof(struct lnet_magicversion, magic) == 0);
+       CLASSERT((int)sizeof(((struct lnet_magicversion *)0)->magic) == 4);
+       CLASSERT((int)offsetof(struct lnet_magicversion, version_major) == 4);
+       CLASSERT((int)sizeof(((struct lnet_magicversion *)0)->version_major) == 2);
+       CLASSERT((int)offsetof(struct lnet_magicversion, version_minor) == 6);
+       CLASSERT((int)sizeof(((struct lnet_magicversion *)0)->version_minor) == 2);
+
+       /* Checks for struct struct lnet_hdr */
+       CLASSERT((int)sizeof(struct lnet_hdr) == 72);
+       CLASSERT((int)offsetof(struct lnet_hdr, dest_nid) == 0);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->dest_nid) == 8);
+       CLASSERT((int)offsetof(struct lnet_hdr, src_nid) == 8);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->src_nid) == 8);
+       CLASSERT((int)offsetof(struct lnet_hdr, dest_pid) == 16);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->dest_pid) == 4);
+       CLASSERT((int)offsetof(struct lnet_hdr, src_pid) == 20);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->src_pid) == 4);
+       CLASSERT((int)offsetof(struct lnet_hdr, type) == 24);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->type) == 4);
+       CLASSERT((int)offsetof(struct lnet_hdr, payload_length) == 28);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->payload_length) == 4);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg) == 32);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg) == 40);
 
        /* Ack */
-       CLASSERT((int)offsetof(lnet_hdr_t, msg.ack.dst_wmd) == 32);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.ack.dst_wmd) == 16);
-       CLASSERT((int)offsetof(lnet_hdr_t, msg.ack.match_bits) == 48);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.ack.match_bits) == 8);
-       CLASSERT((int)offsetof(lnet_hdr_t, msg.ack.mlength) == 56);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.ack.mlength) == 4);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg.ack.dst_wmd) == 32);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.ack.dst_wmd) == 16);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg.ack.match_bits) == 48);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.ack.match_bits) == 8);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg.ack.mlength) == 56);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.ack.mlength) == 4);
 
        /* Put */
-       CLASSERT((int)offsetof(lnet_hdr_t, msg.put.ack_wmd) == 32);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.put.ack_wmd) == 16);
-       CLASSERT((int)offsetof(lnet_hdr_t, msg.put.match_bits) == 48);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.put.match_bits) == 8);
-       CLASSERT((int)offsetof(lnet_hdr_t, msg.put.hdr_data) == 56);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.put.hdr_data) == 8);
-       CLASSERT((int)offsetof(lnet_hdr_t, msg.put.ptl_index) == 64);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.put.ptl_index) == 4);
-       CLASSERT((int)offsetof(lnet_hdr_t, msg.put.offset) == 68);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.put.offset) == 4);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg.put.ack_wmd) == 32);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.put.ack_wmd) == 16);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg.put.match_bits) == 48);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.put.match_bits) == 8);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg.put.hdr_data) == 56);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.put.hdr_data) == 8);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg.put.ptl_index) == 64);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.put.ptl_index) == 4);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg.put.offset) == 68);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.put.offset) == 4);
 
        /* Get */
-       CLASSERT((int)offsetof(lnet_hdr_t, msg.get.return_wmd) == 32);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.get.return_wmd) == 16);
-       CLASSERT((int)offsetof(lnet_hdr_t, msg.get.match_bits) == 48);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.get.match_bits) == 8);
-       CLASSERT((int)offsetof(lnet_hdr_t, msg.get.ptl_index) == 56);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.get.ptl_index) == 4);
-       CLASSERT((int)offsetof(lnet_hdr_t, msg.get.src_offset) == 60);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.get.src_offset) == 4);
-       CLASSERT((int)offsetof(lnet_hdr_t, msg.get.sink_length) == 64);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.get.sink_length) == 4);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg.get.return_wmd) == 32);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.get.return_wmd) == 16);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg.get.match_bits) == 48);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.get.match_bits) == 8);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg.get.ptl_index) == 56);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.get.ptl_index) == 4);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg.get.src_offset) == 60);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.get.src_offset) == 4);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg.get.sink_length) == 64);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.get.sink_length) == 4);
 
        /* Reply */
-       CLASSERT((int)offsetof(lnet_hdr_t, msg.reply.dst_wmd) == 32);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.reply.dst_wmd) == 16);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg.reply.dst_wmd) == 32);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.reply.dst_wmd) == 16);
 
        /* Hello */
-       CLASSERT((int)offsetof(lnet_hdr_t, msg.hello.incarnation) == 32);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.hello.incarnation) == 8);
-       CLASSERT((int)offsetof(lnet_hdr_t, msg.hello.type) == 40);
-       CLASSERT((int)sizeof(((lnet_hdr_t *)0)->msg.hello.type) == 4);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg.hello.incarnation) == 32);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.hello.incarnation) == 8);
+       CLASSERT((int)offsetof(struct lnet_hdr, msg.hello.type) == 40);
+       CLASSERT((int)sizeof(((struct lnet_hdr *)0)->msg.hello.type) == 4);
 }
 
-static lnd_t *lnet_find_lnd_by_type(__u32 type)
+static struct lnet_lnd *lnet_find_lnd_by_type(__u32 type)
 {
-       lnd_t            *lnd;
+       struct lnet_lnd *lnd;
        struct list_head *tmp;
 
        /* holding lnd mutex */
        list_for_each(tmp, &the_lnet.ln_lnds) {
-               lnd = list_entry(tmp, lnd_t, lnd_list);
+               lnd = list_entry(tmp, struct lnet_lnd, lnd_list);
 
                if (lnd->lnd_type == type)
                        return lnd;
@@ -344,7 +344,7 @@ static lnd_t *lnet_find_lnd_by_type(__u32 type)
 }
 
 void
-lnet_register_lnd (lnd_t *lnd)
+lnet_register_lnd(struct lnet_lnd *lnd)
 {
        mutex_lock(&the_lnet.ln_lnd_mutex);
 
@@ -361,7 +361,7 @@ lnet_register_lnd (lnd_t *lnd)
 EXPORT_SYMBOL(lnet_register_lnd);
 
 void
-lnet_unregister_lnd (lnd_t *lnd)
+lnet_unregister_lnd(struct lnet_lnd *lnd)
 {
        mutex_lock(&the_lnet.ln_lnd_mutex);
 
@@ -376,9 +376,9 @@ lnet_unregister_lnd (lnd_t *lnd)
 EXPORT_SYMBOL(lnet_unregister_lnd);
 
 void
-lnet_counters_get(lnet_counters_t *counters)
+lnet_counters_get(struct lnet_counters *counters)
 {
-       lnet_counters_t *ctr;
+       struct lnet_counters *ctr;
        int             i;
 
        memset(counters, 0, sizeof(*counters));
@@ -406,13 +406,13 @@ EXPORT_SYMBOL(lnet_counters_get);
 void
 lnet_counters_reset(void)
 {
-       lnet_counters_t *counters;
+       struct lnet_counters *counters;
        int             i;
 
        lnet_net_lock(LNET_LOCK_EX);
 
        cfs_percpt_for_each(counters, i, the_lnet.ln_counters)
-               memset(counters, 0, sizeof(lnet_counters_t));
+               memset(counters, 0, sizeof(struct lnet_counters));
 
        lnet_net_unlock(LNET_LOCK_EX);
 }
@@ -445,10 +445,10 @@ lnet_res_container_cleanup(struct lnet_res_container *rec)
 
                list_del_init(e);
                if (rec->rec_type == LNET_COOKIE_TYPE_EQ) {
-                       lnet_eq_free(list_entry(e, lnet_eq_t, eq_list));
+                       lnet_eq_free(list_entry(e, struct lnet_eq, eq_list));
 
                } else if (rec->rec_type == LNET_COOKIE_TYPE_MD) {
-                       lnet_md_free(list_entry(e, lnet_libmd_t, md_list));
+                       lnet_md_free(list_entry(e, struct lnet_libmd, md_list));
 
                } else { /* NB: Active MEs should be attached on portals */
                        LBUG();
@@ -544,12 +544,12 @@ lnet_res_containers_create(int type)
        return recs;
 }
 
-lnet_libhandle_t *
+struct lnet_libhandle *
 lnet_res_lh_lookup(struct lnet_res_container *rec, __u64 cookie)
 {
        /* ALWAYS called with lnet_res_lock held */
        struct list_head        *head;
-       lnet_libhandle_t        *lh;
+       struct lnet_libhandle   *lh;
        unsigned int            hash;
 
        if ((cookie & LNET_COOKIE_MASK) != rec->rec_type)
@@ -567,7 +567,8 @@ lnet_res_lh_lookup(struct lnet_res_container *rec, __u64 cookie)
 }
 
 void
-lnet_res_lh_initialize(struct lnet_res_container *rec, lnet_libhandle_t *lh)
+lnet_res_lh_initialize(struct lnet_res_container *rec,
+                      struct lnet_libhandle *lh)
 {
        /* ALWAYS called with lnet_res_lock held */
        unsigned int    ibits = LNET_COOKIE_TYPE_BITS + LNET_CPT_BITS;
@@ -625,7 +626,7 @@ lnet_prepare(lnet_pid_t requested_pid)
        the_lnet.ln_interface_cookie = ktime_get_real_ns();
 
        the_lnet.ln_counters = cfs_percpt_alloc(lnet_cpt_table(),
-                                               sizeof(lnet_counters_t));
+                                               sizeof(struct lnet_counters));
        if (the_lnet.ln_counters == NULL) {
                CERROR("Failed to allocate counters for LNet\n");
                rc = -ENOMEM;
@@ -716,7 +717,7 @@ lnet_unprepare (void)
        return 0;
 }
 
-lnet_ni_t  *
+struct lnet_ni  *
 lnet_net2ni_locked(__u32 net_id, int cpt)
 {
        struct lnet_ni   *ni;
@@ -735,10 +736,10 @@ lnet_net2ni_locked(__u32 net_id, int cpt)
        return NULL;
 }
 
-lnet_ni_t *
+struct lnet_ni *
 lnet_net2ni_addref(__u32 net)
 {
-       lnet_ni_t *ni;
+       struct lnet_ni *ni;
 
        lnet_net_lock(0);
        ni = lnet_net2ni_locked(net, 0);
@@ -863,7 +864,7 @@ lnet_is_ni_healthy_locked(struct lnet_ni *ni)
        return false;
 }
 
-lnet_ni_t  *
+struct lnet_ni  *
 lnet_nid2ni_locked(lnet_nid_t nid, int cpt)
 {
        struct lnet_net  *net;
@@ -881,10 +882,10 @@ lnet_nid2ni_locked(lnet_nid_t nid, int cpt)
        return NULL;
 }
 
-lnet_ni_t *
+struct lnet_ni *
 lnet_nid2ni_addref(lnet_nid_t nid)
 {
-       lnet_ni_t *ni;
+       struct lnet_ni *ni;
 
        lnet_net_lock(0);
        ni = lnet_nid2ni_locked(nid, 0);
@@ -1025,7 +1026,7 @@ lnet_ping_info_destroy(void)
 }
 
 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;
 
@@ -1034,13 +1035,17 @@ lnet_ping_event_handler(lnet_event_t *event)
 }
 
 static int
-lnet_ping_info_setup(struct lnet_ping_info **ppinfo, lnet_handle_md_t *md_handle,
+lnet_ping_info_setup(struct lnet_ping_info **ppinfo,
+                    struct lnet_handle_md *md_handle,
                     int ni_count, bool set_eq)
 {
-       lnet_handle_me_t  me_handle;
-       lnet_process_id_t id = { .nid = LNET_NID_ANY, .pid = LNET_PID_ANY};
-       lnet_md_t         md = {NULL};
-       int               rc, rc2;
+       struct lnet_process_id id = {
+               .nid = LNET_NID_ANY,
+               .pid = LNET_PID_ANY
+       };
+       struct lnet_handle_me me_handle;
+       struct lnet_md md = { NULL };
+       int rc, rc2;
 
        if (set_eq) {
                rc = LNetEQAlloc(0, lnet_ping_event_handler,
@@ -1099,12 +1104,12 @@ failed_0:
 }
 
 static void
-lnet_ping_md_unlink(struct lnet_ping_info *pinfo, lnet_handle_md_t *md_handle)
+lnet_ping_md_unlink(struct lnet_ping_info *pinfo, struct lnet_handle_md *md_handle)
 {
        sigset_t        blocked = cfs_block_allsigs();
 
        LNetMDUnlink(*md_handle);
-       LNetInvalidateHandle(md_handle);
+       LNetInvalidateMDHandle(md_handle);
 
        /* NB md could be busy; this just starts the unlink */
        while (pinfo->pi_features != LNET_PING_FEAT_INVAL) {
@@ -1147,10 +1152,11 @@ lnet_ping_info_install_locked(struct lnet_ping_info *ping_info)
 }
 
 static void
-lnet_ping_target_update(struct lnet_ping_info *pinfo, lnet_handle_md_t md_handle)
+lnet_ping_target_update(struct lnet_ping_info *pinfo,
+                       struct lnet_handle_md md_handle)
 {
        struct lnet_ping_info *old_pinfo = NULL;
-       lnet_handle_md_t old_md;
+       struct lnet_handle_md old_md;
 
        /* switch the NIs to point to the new ping info created */
        lnet_net_lock(LNET_LOCK_EX);
@@ -1190,7 +1196,7 @@ lnet_ping_target_fini(void)
 }
 
 static int
-lnet_ni_tq_credits(lnet_ni_t *ni)
+lnet_ni_tq_credits(struct lnet_ni *ni)
 {
        int     credits;
 
@@ -1207,7 +1213,7 @@ lnet_ni_tq_credits(lnet_ni_t *ni)
 }
 
 static void
-lnet_ni_unlink_locked(lnet_ni_t *ni)
+lnet_ni_unlink_locked(struct lnet_ni *ni)
 {
        if (!list_empty(&ni->ni_cptlist)) {
                list_del_init(&ni->ni_cptlist);
@@ -1225,7 +1231,7 @@ lnet_clear_zombies_nis_locked(struct lnet_net *net)
 {
        int             i;
        int             islo;
-       lnet_ni_t       *ni;
+       struct lnet_ni  *ni;
        struct list_head *zombie_list = &net->net_ni_zombie;
 
        /*
@@ -1238,7 +1244,7 @@ lnet_clear_zombies_nis_locked(struct lnet_net *net)
                int     j;
 
                ni = list_entry(zombie_list->next,
-                               lnet_ni_t, ni_netlist);
+                               struct lnet_ni, ni_netlist);
                list_del_init(&ni->ni_netlist);
                /* the ni should be in deleting state. If it's not it's
                 * a bug */
@@ -1317,7 +1323,7 @@ lnet_shutdown_lndnet(struct lnet_net *net)
 
        while (!list_empty(&net->net_ni_list)) {
                ni = list_entry(net->net_ni_list.next,
-                               lnet_ni_t, ni_netlist);
+                               struct lnet_ni, ni_netlist);
                lnet_net_unlock(LNET_LOCK_EX);
                lnet_shutdown_lndni(ni);
                lnet_net_lock(LNET_LOCK_EX);
@@ -1464,13 +1470,13 @@ failed0:
 static int
 lnet_startup_lndnet(struct lnet_net *net, struct lnet_lnd_tunables *tun)
 {
-       struct lnet_ni          *ni;
-       struct lnet_net         *net_l = NULL;
+       struct lnet_ni *ni;
+       struct lnet_net *net_l = NULL;
        struct list_head        local_ni_list;
        int                     rc;
        int                     ni_count = 0;
        __u32                   lnd_type;
-       lnd_t                   *lnd;
+       struct lnet_lnd *lnd;
        int                     peer_timeout =
                net->net_tunables.lct_peer_timeout;
        int                     maxtxcredits =
@@ -1711,7 +1717,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_net_zombie);
        INIT_LIST_HEAD(&the_lnet.ln_rcd_zombie);
@@ -1746,7 +1752,7 @@ void lnet_lib_exit(void)
 
        while (!list_empty(&the_lnet.ln_lnds))
                lnet_unregister_lnd(list_entry(the_lnet.ln_lnds.next,
-                                              lnd_t, lnd_list));
+                                              struct lnet_lnd, lnd_list));
        lnet_destroy_locks();
 }
 
@@ -1772,7 +1778,7 @@ LNetNIInit(lnet_pid_t requested_pid)
        int                     rc;
        int                     ni_count;
        struct lnet_ping_info   *pinfo;
-       lnet_handle_md_t        md_handle;
+       struct lnet_handle_md   md_handle;
        struct list_head        net_head;
        struct lnet_net         *net;
 
@@ -2208,10 +2214,10 @@ static int lnet_add_net_common(struct lnet_net *net,
                               struct lnet_ioctl_config_lnd_tunables *tun)
 {
        __u32                   net_id;
-       lnet_ping_info_t        *pinfo;
-       lnet_handle_md_t        md_handle;
+       struct lnet_ping_info   *pinfo;
+       struct lnet_handle_md   md_handle;
        int                     rc;
-       lnet_remotenet_t        *rnet;
+       struct lnet_remotenet *rnet;
        int                     net_ni_count;
        int                     num_acceptor_nets;
 
@@ -2390,8 +2396,8 @@ int lnet_dyn_del_ni(struct lnet_ioctl_config_ni *conf)
        struct lnet_net  *net;
        struct lnet_ni *ni;
        __u32 net_id = LNET_NIDNET(conf->lic_nid);
-       lnet_ping_info_t *pinfo;
-       lnet_handle_md_t  md_handle;
+       struct lnet_ping_info *pinfo;
+       struct lnet_handle_md md_handle;
        int               rc;
        int               net_count;
        __u32             addr;
@@ -2541,7 +2547,7 @@ lnet_dyn_del_net(__u32 net_id)
 {
        struct lnet_net  *net;
        struct lnet_ping_info *pinfo;
-       lnet_handle_md_t  md_handle;
+       struct lnet_handle_md md_handle;
        int               rc;
        int               net_ni_count;
 
@@ -2601,8 +2607,8 @@ LNetCtl(unsigned int cmd, void *arg)
 {
        struct libcfs_ioctl_data *data = arg;
        struct lnet_ioctl_config_data *config;
-       lnet_process_id_t         id = {0};
-       lnet_ni_t                *ni;
+       struct lnet_process_id    id = {0};
+       struct lnet_ni           *ni;
        int                       rc;
 
        BUILD_BUG_ON(sizeof(struct lnet_ioctl_net_config) +
@@ -2903,7 +2909,7 @@ LNetCtl(unsigned int cmd, void *arg)
                        timeout = msecs_to_jiffies(data->ioc_u32[1]);
 
                rc = lnet_ping(id, timeout, data->ioc_pbuf1,
-                              data->ioc_plen1 / sizeof(lnet_process_id_t));
+                              data->ioc_plen1 / sizeof(struct lnet_process_id));
                if (rc < 0)
                        return rc;
                data->ioc_count = rc;
@@ -2940,25 +2946,25 @@ LNetCtl(unsigned int cmd, void *arg)
 }
 EXPORT_SYMBOL(LNetCtl);
 
-void LNetDebugPeer(lnet_process_id_t id)
+void LNetDebugPeer(struct lnet_process_id id)
 {
        lnet_debug_peer(id.nid);
 }
 EXPORT_SYMBOL(LNetDebugPeer);
 
 /**
- * Retrieve the lnet_process_id_t ID of LNet interface at \a index. Note that
- * all interfaces share a same PID, as requested by LNetNIInit().
+ * Retrieve the struct lnet_process_id ID of LNet interface at \a index.
+ * Note that all interfaces share a same PID, as requested by LNetNIInit().
  *
  * \param index Index of the interface to look up.
  * \param id On successful return, this location will hold the
- * lnet_process_id_t ID of the interface.
+ * struct lnet_process_id ID of the interface.
  *
  * \retval 0 If an interface exists at \a index.
  * \retval -ENOENT If no interface has been found.
  */
 int
-LNetGetId(unsigned int index, lnet_process_id_t *id)
+LNetGetId(unsigned int index, struct lnet_process_id *id)
 {
        struct lnet_ni   *ni;
        struct lnet_net  *net;
@@ -2986,31 +2992,20 @@ LNetGetId(unsigned int index, lnet_process_id_t *id)
 }
 EXPORT_SYMBOL(LNetGetId);
 
-/**
- * Print a string representation of handle \a h into buffer \a str of
- * \a len bytes.
- */
-void
-LNetSnprintHandle(char *str, int len, lnet_handle_any_t h)
-{
-       snprintf(str, len, "%#llx", h.cookie);
-}
-EXPORT_SYMBOL(LNetSnprintHandle);
-
-static int lnet_ping(lnet_process_id_t id, signed long timeout,
-                    lnet_process_id_t __user *ids, int n_ids)
+static int lnet_ping(struct lnet_process_id id, signed long timeout,
+                    struct lnet_process_id __user *ids, int n_ids)
 {
-       lnet_handle_eq_t     eqh;
-       lnet_handle_md_t     mdh;
-       lnet_event_t         event;
-       lnet_md_t            md = { NULL };
+       struct lnet_handle_eq eqh;
+       struct lnet_handle_md mdh;
+       struct lnet_event event;
+       struct lnet_md md = { NULL };
        int                  which;
        int                  unlinked = 0;
        int                  replied = 0;
        const signed long a_long_time = msecs_to_jiffies(60 * MSEC_PER_SEC);
        int                  infosz;
-       struct lnet_ping_info    *info;
-       lnet_process_id_t    tmpid;
+       struct lnet_ping_info *info;
+       struct lnet_process_id tmpid;
        int                  i;
        int                  nob;
        int                  rc;
index 4ff2ba6..c827e65 100644 (file)
@@ -64,9 +64,9 @@
  */
 int
 LNetEQAlloc(unsigned int count, lnet_eq_handler_t callback,
-           lnet_handle_eq_t *handle)
+           struct lnet_handle_eq *handle)
 {
-       lnet_eq_t     *eq;
+       struct lnet_eq *eq;
 
        LASSERT(the_lnet.ln_refcount > 0);
 
@@ -94,7 +94,7 @@ LNetEQAlloc(unsigned int count, lnet_eq_handler_t callback,
                return -ENOMEM;
 
        if (count != 0) {
-               LIBCFS_ALLOC(eq->eq_events, count * sizeof(lnet_event_t));
+               LIBCFS_ALLOC(eq->eq_events, count * sizeof(struct lnet_event));
                if (eq->eq_events == NULL)
                        goto failed;
                /* NB allocator has set all event sequence numbers to 0,
@@ -128,7 +128,7 @@ LNetEQAlloc(unsigned int count, lnet_eq_handler_t callback,
 
 failed:
        if (eq->eq_events != NULL)
-               LIBCFS_FREE(eq->eq_events, count * sizeof(lnet_event_t));
+               LIBCFS_FREE(eq->eq_events, count * sizeof(struct lnet_event));
 
        if (eq->eq_refs != NULL)
                cfs_percpt_free(eq->eq_refs);
@@ -149,10 +149,10 @@ 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;
+       struct lnet_event       *events = NULL;
        int             **refs = NULL;
        int             *ref;
        int             rc = 0;
@@ -196,7 +196,7 @@ LNetEQFree(lnet_handle_eq_t eqh)
        lnet_res_unlock(LNET_LOCK_EX);
 
        if (events != NULL)
-               LIBCFS_FREE(events, size * sizeof(lnet_event_t));
+               LIBCFS_FREE(events, size * sizeof(struct lnet_event));
        if (refs != NULL)
                cfs_percpt_free(refs);
 
@@ -205,7 +205,7 @@ LNetEQFree(lnet_handle_eq_t eqh)
 EXPORT_SYMBOL(LNetEQFree);
 
 void
-lnet_eq_enqueue_event(lnet_eq_t *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;
@@ -234,10 +234,10 @@ lnet_eq_enqueue_event(lnet_eq_t *eq, lnet_event_t *ev)
 }
 
 static int
-lnet_eq_dequeue_event(lnet_eq_t *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;
        ENTRY;
 
@@ -283,7 +283,7 @@ lnet_eq_dequeue_event(lnet_eq_t *eq, lnet_event_t *ev)
  * EQ has been dropped due to limited space in the EQ.
  */
 int
-LNetEQGet (lnet_handle_eq_t eventq, lnet_event_t *event)
+LNetEQGet(struct lnet_handle_eq eventq, struct lnet_event *event)
 {
        int which;
 
@@ -309,7 +309,7 @@ EXPORT_SYMBOL(LNetEQGet);
  * EQ has been dropped due to limited space in the EQ.
  */
 int
-LNetEQWait (lnet_handle_eq_t eventq, lnet_event_t *event)
+LNetEQWait(struct lnet_handle_eq eventq, struct lnet_event *event)
 {
        int which;
 
@@ -371,8 +371,8 @@ __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, signed long timeout,
-          lnet_event_t *event, int *which)
+LNetEQPoll(struct lnet_handle_eq *eventqs, int neq, signed long timeout,
+          struct lnet_event *event, int *which)
 {
        int     wait = 1;
        int     rc;
@@ -388,7 +388,7 @@ LNetEQPoll(lnet_handle_eq_t *eventqs, int neq, signed long timeout,
 
        for (;;) {
                for (i = 0; i < neq; i++) {
-                       lnet_eq_t *eq = lnet_handle2eq(&eventqs[i]);
+                       struct lnet_eq *eq = lnet_handle2eq(&eventqs[i]);
 
                        if (eq == NULL) {
                                lnet_eq_wait_unlock();
index 2236980..c53a486 100644 (file)
 
 /* must be called with lnet_res_lock held */
 void
-lnet_md_unlink(lnet_libmd_t *md)
+lnet_md_unlink(struct lnet_libmd *md)
 {
        if ((md->md_flags & LNET_MD_FLAG_ZOMBIE) == 0) {
                /* first unlink attempt... */
-               lnet_me_t *me = md->md_me;
+               struct lnet_me *me = md->md_me;
 
                md->md_flags |= LNET_MD_FLAG_ZOMBIE;
 
@@ -81,7 +81,7 @@ lnet_md_unlink(lnet_libmd_t *md)
 }
 
 int
-lnet_cpt_of_md(lnet_libmd_t *md)
+lnet_cpt_of_md(struct lnet_libmd *md)
 {
        int cpt = CFS_CPT_ANY;
 
@@ -89,7 +89,7 @@ lnet_cpt_of_md(lnet_libmd_t *md)
                return CFS_CPT_ANY;
 
        if ((md->md_options & LNET_MD_BULK_HANDLE) != 0 &&
-           !LNetHandleIsInvalid(md->md_bulk_handle)) {
+           !LNetMDHandleIsInvalid(md->md_bulk_handle)) {
                md = lnet_handle2md(&md->md_bulk_handle);
 
                if (!md)
@@ -109,7 +109,7 @@ lnet_cpt_of_md(lnet_libmd_t *md)
 }
 
 static int
-lnet_md_build(lnet_libmd_t *lmd, lnet_md_t *umd, int unlink)
+lnet_md_build(struct lnet_libmd *lmd, struct lnet_md *umd, int unlink)
 {
        int          i;
        unsigned int niov;
@@ -188,7 +188,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(struct lnet_libmd *md, struct lnet_handle_eq eq_handle, int cpt)
 {
        struct lnet_res_container *container = the_lnet.ln_md_containers[cpt];
 
@@ -204,7 +204,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 == NULL);
         */
-       if (!LNetHandleIsInvalid(eq_handle)) {
+       if (!LNetEQHandleIsInvalid(eq_handle)) {
                md->md_eq = lnet_handle2eq(&eq_handle);
 
                if (md->md_eq == NULL)
@@ -223,7 +223,7 @@ lnet_md_link(lnet_libmd_t *md, lnet_handle_eq_t eq_handle, int cpt)
 
 /* must be called with lnet_res_lock held */
 void
-lnet_md_deconstruct(lnet_libmd_t *lmd, lnet_md_t *umd)
+lnet_md_deconstruct(struct lnet_libmd *lmd, struct lnet_md *umd)
 {
        /* NB this doesn't copy out all the iov entries so when a
         * discontiguous MD is copied out, the target gets to know the
@@ -241,7 +241,7 @@ lnet_md_deconstruct(lnet_libmd_t *lmd, lnet_md_t *umd)
 }
 
 static int
-lnet_md_validate(lnet_md_t *umd)
+lnet_md_validate(struct lnet_md *umd)
 {
        if (umd->start == NULL && umd->length != 0) {
                CERROR("MD start pointer can not be NULL with length %u\n",
@@ -285,8 +285,8 @@ lnet_md_validate(lnet_md_t *umd)
  * a MD.
  */
 int
-LNetMDAttach(lnet_handle_me_t meh, lnet_md_t umd,
-            lnet_unlink_t unlink, lnet_handle_md_t *handle)
+LNetMDAttach(struct lnet_handle_me meh, struct lnet_md umd,
+            enum lnet_unlink unlink, struct lnet_handle_md *handle)
 {
        struct list_head        matches = LIST_HEAD_INIT(matches);
        struct list_head        drops = LIST_HEAD_INIT(drops);
@@ -366,9 +366,10 @@ EXPORT_SYMBOL(LNetMDAttach);
  * LNetInvalidateHandle() on it.
  */
 int
-LNetMDBind(lnet_md_t umd, lnet_unlink_t unlink, lnet_handle_md_t *handle)
+LNetMDBind(struct lnet_md umd, enum lnet_unlink unlink,
+          struct lnet_handle_md *handle)
 {
-       lnet_libmd_t    *md;
+       struct lnet_libmd       *md;
        int             cpt;
        int             rc;
 
@@ -441,11 +442,11 @@ EXPORT_SYMBOL(LNetMDBind);
  * \retval -ENOENT If \a mdh does not point to a valid MD object.
  */
 int
-LNetMDUnlink (lnet_handle_md_t mdh)
+LNetMDUnlink(struct lnet_handle_md mdh)
 {
-       lnet_event_t    ev;
-       lnet_libmd_t    *md;
-       int             cpt;
+       struct lnet_event ev;
+       struct lnet_libmd *md;
+       int cpt;
 
        LASSERT(the_lnet.ln_refcount > 0);
 
index 8c9faab..1a1d9b1 100644 (file)
@@ -46,7 +46,7 @@
  * \param portal The portal table index where the ME should be attached.
  * \param match_id Specifies the match criteria for the process ID of
  * the requester. The constants LNET_PID_ANY and LNET_NID_ANY can be
- * used to wildcard either of the identifiers in the lnet_process_id_t
+ * used to wildcard either of the identifiers in the struct lnet_process_id
  * structure.
  * \param match_bits,ignore_bits Specify the match criteria to apply
  * to the match bits in the incoming request. The ignore bits are used
  */
 int
 LNetMEAttach(unsigned int portal,
-            lnet_process_id_t match_id,
+            struct lnet_process_id match_id,
             __u64 match_bits, __u64 ignore_bits,
-            lnet_unlink_t unlink, lnet_ins_pos_t pos,
-            lnet_handle_me_t *handle)
+            enum lnet_unlink unlink, enum lnet_ins_pos pos,
+            struct lnet_handle_me *handle)
 {
        struct lnet_match_table *mtable;
        struct lnet_me          *me;
@@ -140,11 +140,11 @@ EXPORT_SYMBOL(LNetMEAttach);
  * \retval -ENOENT If \a current_meh does not point to a valid match entry.
  */
 int
-LNetMEInsert(lnet_handle_me_t current_meh,
-            lnet_process_id_t match_id,
+LNetMEInsert(struct lnet_handle_me current_meh,
+            struct lnet_process_id match_id,
             __u64 match_bits, __u64 ignore_bits,
-            lnet_unlink_t unlink, lnet_ins_pos_t pos,
-            lnet_handle_me_t *handle)
+            enum lnet_unlink unlink, enum lnet_ins_pos pos,
+            struct lnet_handle_me *handle)
 {
        struct lnet_me          *current_me;
        struct lnet_me          *new_me;
@@ -220,12 +220,12 @@ EXPORT_SYMBOL(LNetMEInsert);
  * \see LNetMDUnlink() for the discussion on delivering unlink event.
  */
 int
-LNetMEUnlink(lnet_handle_me_t meh)
+LNetMEUnlink(struct lnet_handle_me meh)
 {
-       lnet_me_t       *me;
-       lnet_libmd_t    *md;
-       lnet_event_t    ev;
-       int             cpt;
+       struct lnet_me *me;
+       struct lnet_libmd *md;
+       struct lnet_event ev;
+       int cpt;
 
        LASSERT(the_lnet.ln_refcount > 0);
 
@@ -256,12 +256,12 @@ EXPORT_SYMBOL(LNetMEUnlink);
 
 /* call with lnet_res_lock please */
 void
-lnet_me_unlink(lnet_me_t *me)
+lnet_me_unlink(struct lnet_me *me)
 {
        list_del(&me->me_list);
 
        if (me->me_md != NULL) {
-               lnet_libmd_t *md = me->me_md;
+               struct lnet_libmd *md = me->me_md;
 
                /* detach MD from portal of this ME */
                lnet_ptl_detach_md(me, md);
@@ -274,7 +274,7 @@ lnet_me_unlink(lnet_me_t *me)
 
 #if 0
 static void
-lib_me_dump(lnet_me_t *me)
+lib_me_dump(struct lnet_me *me)
 {
        CWARN("Match Entry %p (%#llx)\n", me,
              me->me_lh.lh_cookie);
@@ -284,8 +284,8 @@ lib_me_dump(lnet_me_t *me)
 
        CWARN("\tMD\t= %p\n", me->md);
        CWARN("\tprev\t= %p\n",
-             list_entry(me->me_list.prev, lnet_me_t, me_list));
+             list_entry(me->me_list.prev, struct lnet_me, me_list));
        CWARN("\tnext\t= %p\n",
-             list_entry(me->me_list.next, lnet_me_t, me_list));
+             list_entry(me->me_list.next, struct lnet_me, me_list));
 }
 #endif
index e9dd9b3..988c549 100644 (file)
@@ -47,7 +47,7 @@ MODULE_PARM_DESC(local_nid_dist_zero, "Reserved");
 int
 lnet_fail_nid(lnet_nid_t nid, unsigned int threshold)
 {
-       lnet_test_peer_t *tp;
+       struct lnet_test_peer *tp;
        struct list_head *el;
        struct list_head *next;
        struct list_head  cull;
@@ -74,7 +74,7 @@ lnet_fail_nid(lnet_nid_t nid, unsigned int threshold)
        lnet_net_lock(0);
 
        list_for_each_safe(el, next, &the_lnet.ln_test_peers) {
-               tp = list_entry(el, lnet_test_peer_t, tp_list);
+               tp = list_entry(el, struct lnet_test_peer, tp_list);
 
                if (tp->tp_threshold == 0 ||    /* needs culling anyway */
                    nid == LNET_NID_ANY ||      /* removing all entries */
@@ -87,7 +87,7 @@ lnet_fail_nid(lnet_nid_t nid, unsigned int threshold)
        lnet_net_unlock(0);
 
        while (!list_empty(&cull)) {
-               tp = list_entry(cull.next, lnet_test_peer_t, tp_list);
+               tp = list_entry(cull.next, struct lnet_test_peer, tp_list);
 
                list_del(&tp->tp_list);
                LIBCFS_FREE(tp, sizeof(*tp));
@@ -98,7 +98,7 @@ lnet_fail_nid(lnet_nid_t nid, unsigned int threshold)
 static int
 fail_peer (lnet_nid_t nid, int outgoing)
 {
-       lnet_test_peer_t *tp;
+       struct lnet_test_peer *tp;
        struct list_head *el;
        struct list_head *next;
        struct list_head  cull;
@@ -110,7 +110,7 @@ fail_peer (lnet_nid_t nid, int outgoing)
        lnet_net_lock(0);
 
        list_for_each_safe(el, next, &the_lnet.ln_test_peers) {
-               tp = list_entry(el, lnet_test_peer_t, tp_list);
+               tp = list_entry(el, struct lnet_test_peer, tp_list);
 
                if (tp->tp_threshold == 0) {
                        /* zombie entry */
@@ -144,7 +144,7 @@ fail_peer (lnet_nid_t nid, int outgoing)
        lnet_net_unlock(0);
 
        while (!list_empty(&cull)) {
-               tp = list_entry(cull.next, lnet_test_peer_t, tp_list);
+               tp = list_entry(cull.next, struct lnet_test_peer, tp_list);
                list_del(&tp->tp_list);
 
                LIBCFS_FREE(tp, sizeof(*tp));
@@ -558,8 +558,9 @@ lnet_extract_kiov(int dst_niov, lnet_kiov_t *dst,
 EXPORT_SYMBOL(lnet_extract_kiov);
 
 void
-lnet_ni_recv(lnet_ni_t *ni, void *private, lnet_msg_t *msg, int delayed,
-            unsigned int offset, unsigned int mlen, unsigned int rlen)
+lnet_ni_recv(struct lnet_ni *ni, void *private, struct lnet_msg *msg,
+            int delayed, unsigned int offset, unsigned int mlen,
+            unsigned int rlen)
 {
        unsigned int  niov = 0;
        struct kvec *iov = NULL;
@@ -597,9 +598,9 @@ lnet_ni_recv(lnet_ni_t *ni, void *private, lnet_msg_t *msg, int delayed,
 }
 
 static void
-lnet_setpayloadbuffer(lnet_msg_t *msg)
+lnet_setpayloadbuffer(struct lnet_msg *msg)
 {
-       lnet_libmd_t *md = msg->msg_md;
+       struct lnet_libmd *md = msg->msg_md;
 
        LASSERT(msg->msg_len > 0);
        LASSERT(!msg->msg_routing);
@@ -616,7 +617,7 @@ lnet_setpayloadbuffer(lnet_msg_t *msg)
 }
 
 void
-lnet_prep_send(lnet_msg_t *msg, int type, lnet_process_id_t target,
+lnet_prep_send(struct lnet_msg *msg, int type, struct lnet_process_id target,
               unsigned int offset, unsigned int len)
 {
        msg->msg_type = type;
@@ -636,7 +637,7 @@ lnet_prep_send(lnet_msg_t *msg, int type, lnet_process_id_t target,
 }
 
 static void
-lnet_ni_send(lnet_ni_t *ni, lnet_msg_t *msg)
+lnet_ni_send(struct lnet_ni *ni, struct lnet_msg *msg)
 {
        void   *priv = msg->msg_private;
        int     rc;
@@ -651,7 +652,7 @@ lnet_ni_send(lnet_ni_t *ni, lnet_msg_t *msg)
 }
 
 static int
-lnet_ni_eager_recv(lnet_ni_t *ni, lnet_msg_t *msg)
+lnet_ni_eager_recv(struct lnet_ni *ni, struct lnet_msg *msg)
 {
        int     rc;
 
@@ -683,7 +684,7 @@ lnet_ni_eager_recv(lnet_ni_t *ni, lnet_msg_t *msg)
  * lock before calling lnd_query()
  */
 static void
-lnet_ni_query_locked(lnet_ni_t *ni, struct lnet_peer_ni *lp)
+lnet_ni_query_locked(struct lnet_ni *ni, struct lnet_peer_ni *lp)
 {
        cfs_time_t last_alive = 0;
        int cpt = lnet_cpt_of_nid_locked(lp->lpni_nid, ni);
@@ -802,7 +803,7 @@ lnet_peer_alive_locked (struct lnet_ni *ni, struct lnet_peer_ni *lp)
  * \retval -ECANCELED If the MD of the message has been unlinked.
  */
 static int
-lnet_post_send_locked(lnet_msg_t *msg, int do_send)
+lnet_post_send_locked(struct lnet_msg *msg, int do_send)
 {
        struct lnet_peer_ni     *lp = msg->msg_txpeer;
        struct lnet_ni          *ni = msg->msg_txni;
@@ -854,7 +855,7 @@ lnet_post_send_locked(lnet_msg_t *msg, int do_send)
                        !list_empty(&lp->lpni_txq));
 
                msg->msg_peertxcredit = 1;
-               lp->lpni_txqnob += msg->msg_len + sizeof(lnet_hdr_t);
+               lp->lpni_txqnob += msg->msg_len + sizeof(struct lnet_hdr);
                lp->lpni_txcredits--;
 
                if (lp->lpni_txcredits < lp->lpni_mintxcredits)
@@ -896,10 +897,10 @@ lnet_post_send_locked(lnet_msg_t *msg, int do_send)
 }
 
 
-static lnet_rtrbufpool_t *
-lnet_msg2bufpool(lnet_msg_t *msg)
+static struct lnet_rtrbufpool *
+lnet_msg2bufpool(struct lnet_msg *msg)
 {
-       lnet_rtrbufpool_t       *rbp;
+       struct lnet_rtrbufpool  *rbp;
        int                     cpt;
 
        LASSERT(msg->msg_rx_committed);
@@ -917,15 +918,15 @@ lnet_msg2bufpool(lnet_msg_t *msg)
 }
 
 static int
-lnet_post_routed_recv_locked (lnet_msg_t *msg, int do_recv)
+lnet_post_routed_recv_locked(struct lnet_msg *msg, int do_recv)
 {
        /* lnet_parse is going to lnet_net_unlock immediately after this, so it
         * sets do_recv FALSE and I don't do the unlock/send/lock bit.
         * I return LNET_CREDIT_WAIT if msg blocked and LNET_CREDIT_OK if
         * received or OK to receive */
        struct lnet_peer_ni *lp = msg->msg_rxpeer;
-       lnet_rtrbufpool_t   *rbp;
-       lnet_rtrbuf_t       *rb;
+       struct lnet_rtrbufpool *rbp;
+       struct lnet_rtrbuf *rb;
 
        LASSERT (msg->msg_iov == NULL);
        LASSERT (msg->msg_kiov == NULL);
@@ -976,7 +977,7 @@ lnet_post_routed_recv_locked (lnet_msg_t *msg, int do_recv)
        }
 
        LASSERT(!list_empty(&rbp->rbp_bufs));
-       rb = list_entry(rbp->rbp_bufs.next, lnet_rtrbuf_t, rb_list);
+       rb = list_entry(rbp->rbp_bufs.next, struct lnet_rtrbuf, rb_list);
        list_del(&rb->rb_list);
 
        msg->msg_niov = rbp->rbp_npages;
@@ -994,11 +995,11 @@ lnet_post_routed_recv_locked (lnet_msg_t *msg, int do_recv)
 }
 
 void
-lnet_return_tx_credits_locked(lnet_msg_t *msg)
+lnet_return_tx_credits_locked(struct lnet_msg *msg)
 {
        struct lnet_peer_ni     *txpeer = msg->msg_txpeer;
        struct lnet_ni          *txni = msg->msg_txni;
-       lnet_msg_t              *msg2;
+       struct lnet_msg         *msg2;
 
        if (msg->msg_txcredit) {
                struct lnet_ni       *ni = msg->msg_txni;
@@ -1014,7 +1015,7 @@ lnet_return_tx_credits_locked(lnet_msg_t *msg)
                atomic_inc(&ni->ni_tx_credits);
                if (tq->tq_credits <= 0) {
                        msg2 = list_entry(tq->tq_delayed.next,
-                                         lnet_msg_t, msg_list);
+                                         struct lnet_msg, msg_list);
                        list_del(&msg2->msg_list);
 
                        LASSERT(msg2->msg_txni == ni);
@@ -1033,13 +1034,13 @@ lnet_return_tx_credits_locked(lnet_msg_t *msg)
                LASSERT((txpeer->lpni_txcredits < 0) ==
                        !list_empty(&txpeer->lpni_txq));
 
-               txpeer->lpni_txqnob -= msg->msg_len + sizeof(lnet_hdr_t);
+               txpeer->lpni_txqnob -= msg->msg_len + sizeof(struct lnet_hdr);
                LASSERT(txpeer->lpni_txqnob >= 0);
 
                txpeer->lpni_txcredits++;
                if (txpeer->lpni_txcredits <= 0) {
                        msg2 = list_entry(txpeer->lpni_txq.next,
-                                              lnet_msg_t, msg_list);
+                                             struct lnet_msg, msg_list);
                        list_del(&msg2->msg_list);
                        spin_unlock(&txpeer->lpni_lock);
 
@@ -1081,14 +1082,14 @@ lnet_return_tx_credits_locked(lnet_msg_t *msg)
 }
 
 void
-lnet_schedule_blocked_locked(lnet_rtrbufpool_t *rbp)
+lnet_schedule_blocked_locked(struct lnet_rtrbufpool *rbp)
 {
-       lnet_msg_t      *msg;
+       struct lnet_msg *msg;
 
        if (list_empty(&rbp->rbp_msgs))
                return;
        msg = list_entry(rbp->rbp_msgs.next,
-                        lnet_msg_t, msg_list);
+                        struct lnet_msg, msg_list);
        list_del(&msg->msg_list);
 
        (void)lnet_post_routed_recv_locked(msg, 1);
@@ -1097,8 +1098,8 @@ lnet_schedule_blocked_locked(lnet_rtrbufpool_t *rbp)
 void
 lnet_drop_routed_msgs_locked(struct list_head *list, int cpt)
 {
-       lnet_msg_t *msg;
-       lnet_msg_t *tmp;
+       struct lnet_msg *msg;
+       struct lnet_msg *tmp;
 
        lnet_net_unlock(cpt);
 
@@ -1113,23 +1114,23 @@ lnet_drop_routed_msgs_locked(struct list_head *list, int cpt)
 }
 
 void
-lnet_return_rx_credits_locked(lnet_msg_t *msg)
+lnet_return_rx_credits_locked(struct lnet_msg *msg)
 {
-       struct lnet_peer_ni     *rxpeer = msg->msg_rxpeer;
-       struct lnet_ni          *rxni = msg->msg_rxni;
-       lnet_msg_t              *msg2;
+       struct lnet_peer_ni *rxpeer = msg->msg_rxpeer;
+       struct lnet_ni *rxni = msg->msg_rxni;
+       struct lnet_msg *msg2;
 
        if (msg->msg_rtrcredit) {
                /* give back global router credits */
-               lnet_rtrbuf_t     *rb;
-               lnet_rtrbufpool_t *rbp;
+               struct lnet_rtrbuf *rb;
+               struct lnet_rtrbufpool *rbp;
 
                /* NB If a msg ever blocks for a buffer in rbp_msgs, it stays
                 * there until it gets one allocated, or aborts the wait
                 * itself */
                LASSERT(msg->msg_kiov != NULL);
 
-               rb = list_entry(msg->msg_kiov, lnet_rtrbuf_t, rb_kiov[0]);
+               rb = list_entry(msg->msg_kiov, struct lnet_rtrbuf, rb_kiov[0]);
                rbp = rb->rb_pool;
 
                msg->msg_kiov = NULL;
@@ -1184,7 +1185,7 @@ routing_off:
                        lnet_drop_routed_msgs_locked(&drop, msg->msg_rx_cpt);
                } else if (rxpeer->lpni_rtrcredits <= 0) {
                        msg2 = list_entry(rxpeer->lpni_rtrq.next,
-                                         lnet_msg_t, msg_list);
+                                         struct lnet_msg, msg_list);
                        list_del(&msg2->msg_list);
                        spin_unlock(&rxpeer->lpni_lock);
                        (void) lnet_post_routed_recv_locked(msg2, 1);
@@ -1221,7 +1222,7 @@ lnet_compare_peers(struct lnet_peer_ni *p1, struct lnet_peer_ni *p2)
 }
 
 static int
-lnet_compare_routes(lnet_route_t *r1, lnet_route_t *r2)
+lnet_compare_routes(struct lnet_route *r1, struct lnet_route *r2)
 {
        struct lnet_peer_ni *p1 = r1->lr_gateway;
        struct lnet_peer_ni *p2 = r2->lr_gateway;
@@ -1255,10 +1256,10 @@ static struct lnet_peer_ni *
 lnet_find_route_locked(struct lnet_net *net, lnet_nid_t target,
                       lnet_nid_t rtr_nid)
 {
-       lnet_remotenet_t        *rnet;
-       lnet_route_t            *route;
-       lnet_route_t            *best_route;
-       lnet_route_t            *last_route;
+       struct lnet_remotenet   *rnet;
+       struct lnet_route               *route;
+       struct lnet_route               *best_route;
+       struct lnet_route               *last_route;
        struct lnet_peer_ni     *lpni_best;
        struct lnet_peer_ni     *lp;
        int                     rc;
@@ -1907,7 +1908,7 @@ send:
 }
 
 int
-lnet_send(lnet_nid_t src_nid, lnet_msg_t *msg, lnet_nid_t rtr_nid)
+lnet_send(lnet_nid_t src_nid, struct lnet_msg *msg, lnet_nid_t rtr_nid)
 {
        lnet_nid_t              dst_nid = msg->msg_target.nid;
        int                     rc;
@@ -1939,7 +1940,7 @@ lnet_send(lnet_nid_t src_nid, lnet_msg_t *msg, lnet_nid_t rtr_nid)
 }
 
 void
-lnet_drop_message(lnet_ni_t *ni, int cpt, void *private, unsigned int nob)
+lnet_drop_message(struct lnet_ni *ni, int cpt, void *private, unsigned int nob)
 {
        lnet_net_lock(cpt);
        the_lnet.ln_counters[cpt]->drop_count++;
@@ -1950,9 +1951,9 @@ lnet_drop_message(lnet_ni_t *ni, int cpt, void *private, unsigned int nob)
 }
 
 static void
-lnet_recv_put(lnet_ni_t *ni, lnet_msg_t *msg)
+lnet_recv_put(struct lnet_ni *ni, struct lnet_msg *msg)
 {
-       lnet_hdr_t      *hdr = &msg->msg_hdr;
+       struct lnet_hdr *hdr = &msg->msg_hdr;
 
        if (msg->msg_wanted != 0)
                lnet_setpayloadbuffer(msg);
@@ -1969,9 +1970,9 @@ lnet_recv_put(lnet_ni_t *ni, lnet_msg_t *msg)
 }
 
 static int
-lnet_parse_put(lnet_ni_t *ni, lnet_msg_t *msg)
+lnet_parse_put(struct lnet_ni *ni, struct lnet_msg *msg)
 {
-       lnet_hdr_t              *hdr = &msg->msg_hdr;
+       struct lnet_hdr         *hdr = &msg->msg_hdr;
        struct lnet_match_info  info;
        int                     rc;
        bool                    ready_delay;
@@ -2028,13 +2029,13 @@ lnet_parse_put(lnet_ni_t *ni, lnet_msg_t *msg)
 }
 
 static int
-lnet_parse_get(lnet_ni_t *ni, lnet_msg_t *msg, int rdma_get)
+lnet_parse_get(struct lnet_ni *ni, struct lnet_msg *msg, int rdma_get)
 {
-       struct lnet_match_info  info;
-       lnet_hdr_t              *hdr = &msg->msg_hdr;
-       lnet_process_id_t       source_id;
+       struct lnet_match_info info;
+       struct lnet_hdr *hdr = &msg->msg_hdr;
+       struct lnet_process_id source_id;
        struct lnet_handle_wire reply_wmd;
-       int                     rc;
+       int rc;
 
        /* Convert get fields to host byte order */
        hdr->msg.get.match_bits   = le64_to_cpu(hdr->msg.get.match_bits);
@@ -2098,12 +2099,12 @@ lnet_parse_get(lnet_ni_t *ni, lnet_msg_t *msg, int rdma_get)
 }
 
 static int
-lnet_parse_reply(lnet_ni_t *ni, lnet_msg_t *msg)
+lnet_parse_reply(struct lnet_ni *ni, struct lnet_msg *msg)
 {
        void             *private = msg->msg_private;
-       lnet_hdr_t       *hdr = &msg->msg_hdr;
-       lnet_process_id_t src = {0};
-       lnet_libmd_t     *md;
+       struct lnet_hdr  *hdr = &msg->msg_hdr;
+       struct lnet_process_id src = {0};
+       struct lnet_libmd        *md;
        int               rlength;
        int               mlength;
        int                     cpt;
@@ -2165,11 +2166,11 @@ lnet_parse_reply(lnet_ni_t *ni, lnet_msg_t *msg)
 }
 
 static int
-lnet_parse_ack(lnet_ni_t *ni, lnet_msg_t *msg)
+lnet_parse_ack(struct lnet_ni *ni, struct lnet_msg *msg)
 {
-       lnet_hdr_t       *hdr = &msg->msg_hdr;
-       lnet_process_id_t src = {0};
-       lnet_libmd_t     *md;
+       struct lnet_hdr  *hdr = &msg->msg_hdr;
+       struct lnet_process_id src = {0};
+       struct lnet_libmd        *md;
        int                     cpt;
 
        src.nid = hdr->src_nid;
@@ -2220,7 +2221,7 @@ lnet_parse_ack(lnet_ni_t *ni, lnet_msg_t *msg)
  * \retval -ve                 error code
  */
 int
-lnet_parse_forward_locked(lnet_ni_t *ni, lnet_msg_t *msg)
+lnet_parse_forward_locked(struct lnet_ni *ni, struct lnet_msg *msg)
 {
        int     rc = 0;
 
@@ -2244,7 +2245,7 @@ lnet_parse_forward_locked(lnet_ni_t *ni, lnet_msg_t *msg)
 }
 
 int
-lnet_parse_local(lnet_ni_t *ni, lnet_msg_t *msg)
+lnet_parse_local(struct lnet_ni *ni, struct lnet_msg *msg)
 {
        int     rc;
 
@@ -2290,18 +2291,18 @@ lnet_msgtyp2str (int type)
 }
 
 void
-lnet_print_hdr(lnet_hdr_t * hdr)
+lnet_print_hdr(struct lnet_hdr *hdr)
 {
-       lnet_process_id_t src = {0};
-       lnet_process_id_t dst = {0};
+       struct lnet_process_id src = {
+               .nid = hdr->src_nid,
+               .pid = hdr->src_pid,
+       };
+       struct lnet_process_id dst = {
+               .nid = hdr->dest_nid,
+               .pid = hdr->dest_pid,
+       };
        char *type_str = lnet_msgtyp2str(hdr->type);
 
-       src.nid = hdr->src_nid;
-       src.pid = hdr->src_pid;
-
-       dst.nid = hdr->dest_nid;
-       dst.pid = hdr->dest_pid;
-
        CWARN("P3 Header at %p of type %s\n", hdr, type_str);
        CWARN("    From %s\n", libcfs_id2str(src));
        CWARN("    To   %s\n", libcfs_id2str(dst));
@@ -2352,7 +2353,7 @@ lnet_print_hdr(lnet_hdr_t * hdr)
 }
 
 int
-lnet_parse(lnet_ni_t *ni, lnet_hdr_t *hdr, lnet_nid_t from_nid,
+lnet_parse(struct lnet_ni *ni, struct lnet_hdr *hdr, lnet_nid_t from_nid,
           void *private, int rdma_req)
 {
        int             rc = 0;
@@ -2600,10 +2601,10 @@ void
 lnet_drop_delayed_msg_list(struct list_head *head, char *reason)
 {
        while (!list_empty(head)) {
-               lnet_process_id_t       id = {0};
-               lnet_msg_t              *msg;
+               struct lnet_process_id id = {0};
+               struct lnet_msg *msg;
 
-               msg = list_entry(head->next, lnet_msg_t, msg_list);
+               msg = list_entry(head->next, struct lnet_msg, msg_list);
                list_del(&msg->msg_list);
 
                id.nid = msg->msg_hdr.src_nid;
@@ -2641,10 +2642,10 @@ void
 lnet_recv_delayed_msg_list(struct list_head *head)
 {
        while (!list_empty(head)) {
-               lnet_msg_t        *msg;
-               lnet_process_id_t  id;
+               struct lnet_msg *msg;
+               struct lnet_process_id id;
 
-               msg = list_entry(head->next, lnet_msg_t, msg_list);
+               msg = list_entry(head->next, struct lnet_msg, msg_list);
                list_del(&msg->msg_list);
 
                /* md won't disappear under me, since each msg
@@ -2712,11 +2713,11 @@ lnet_recv_delayed_msg_list(struct list_head *head)
  * \retval -ENOMEM Memory allocation failure.
  * \retval -ENOENT Invalid MD object.
  *
- * \see lnet_event_t::hdr_data and lnet_event_kind_t.
+ * \see struct lnet_event::hdr_data and lnet_event_kind_t.
  */
 int
-LNetPut(lnet_nid_t self, lnet_handle_md_t mdh, lnet_ack_req_t ack,
-       lnet_process_id_t target, unsigned int portal,
+LNetPut(lnet_nid_t self, struct lnet_handle_md mdh, enum lnet_ack_req ack,
+       struct lnet_process_id target, unsigned int portal,
        __u64 match_bits, unsigned int offset,
        __u64 hdr_data)
 {
@@ -2736,7 +2737,7 @@ LNetPut(lnet_nid_t self, lnet_handle_md_t mdh, lnet_ack_req_t ack,
 
        msg = lnet_msg_alloc();
        if (msg == NULL) {
-               CERROR("Dropping PUT to %s: ENOMEM on lnet_msg_t\n",
+               CERROR("Dropping PUT to %s: ENOMEM on struct lnet_msg\n",
                       libcfs_id2str(target));
                return -ENOMEM;
        }
@@ -2799,20 +2800,21 @@ LNetPut(lnet_nid_t self, lnet_handle_md_t mdh, lnet_ack_req_t ack,
 }
 EXPORT_SYMBOL(LNetPut);
 
-lnet_msg_t *
-lnet_create_reply_msg (lnet_ni_t *ni, lnet_msg_t *getmsg)
+/*
+ * The LND can DMA direct to the GET md (i.e. no REPLY msg).  This
+ * returns a msg for the LND to pass to lnet_finalize() when the sink
+ * data has been received.
+ *
+ * CAVEAT EMPTOR: 'getmsg' is the original GET, which is freed when
+ * lnet_finalize() is called on it, so the LND must call this first
+ */
+struct lnet_msg *
+lnet_create_reply_msg(struct lnet_ni *ni, struct lnet_msg *getmsg)
 {
-       /* The LND can DMA direct to the GET md (i.e. no REPLY msg).  This
-        * returns a msg for the LND to pass to lnet_finalize() when the sink
-        * data has been received.
-        *
-        * CAVEAT EMPTOR: 'getmsg' is the original GET, which is freed when
-        * lnet_finalize() is called on it, so the LND must call this first */
-
-       struct lnet_msg         *msg = lnet_msg_alloc();
-       struct lnet_libmd       *getmd = getmsg->msg_md;
-       lnet_process_id_t       peer_id = getmsg->msg_target;
-       int                     cpt;
+       struct lnet_msg *msg = lnet_msg_alloc();
+       struct lnet_libmd *getmd = getmsg->msg_md;
+       struct lnet_process_id peer_id = getmsg->msg_target;
+       int cpt;
 
        LASSERT(!getmsg->msg_target_is_router);
        LASSERT(!getmsg->msg_routing);
@@ -2879,7 +2881,8 @@ lnet_create_reply_msg (lnet_ni_t *ni, lnet_msg_t *getmsg)
 EXPORT_SYMBOL(lnet_create_reply_msg);
 
 void
-lnet_set_reply_msg_len(lnet_ni_t *ni, lnet_msg_t *reply, unsigned int len)
+lnet_set_reply_msg_len(struct lnet_ni *ni, struct lnet_msg *reply,
+                      unsigned int len)
 {
        /* Set the REPLY length, now the RDMA that elides the REPLY message has
         * completed and I know it. */
@@ -2916,8 +2919,8 @@ EXPORT_SYMBOL(lnet_set_reply_msg_len);
  * \retval -ENOENT Invalid MD object.
  */
 int
-LNetGet(lnet_nid_t self, lnet_handle_md_t mdh,
-       lnet_process_id_t target, unsigned int portal,
+LNetGet(lnet_nid_t self, struct lnet_handle_md mdh,
+       struct lnet_process_id target, unsigned int portal,
        __u64 match_bits, unsigned int offset)
 {
        struct lnet_msg         *msg;
@@ -2937,7 +2940,7 @@ LNetGet(lnet_nid_t self, lnet_handle_md_t mdh,
 
        msg = lnet_msg_alloc();
        if (msg == NULL) {
-               CERROR("Dropping GET to %s: ENOMEM on lnet_msg_t\n",
+               CERROR("Dropping GET to %s: ENOMEM on struct lnet_msg\n",
                       libcfs_id2str(target));
                return -ENOMEM;
        }
@@ -3011,8 +3014,8 @@ int
 LNetDist(lnet_nid_t dstnid, lnet_nid_t *srcnidp, __u32 *orderp)
 {
        struct list_head        *e;
-       struct lnet_ni          *ni = NULL;
-       lnet_remotenet_t        *rnet;
+       struct lnet_ni *ni = NULL;
+       struct lnet_remotenet *rnet;
        __u32                   dstnet = LNET_NIDNET(dstnid);
        int                     hops;
        int                     cpt;
@@ -3064,11 +3067,11 @@ LNetDist(lnet_nid_t dstnid, lnet_nid_t *srcnidp, __u32 *orderp)
 
        rn_list = lnet_net2rnethash(dstnet);
        list_for_each(e, rn_list) {
-               rnet = list_entry(e, lnet_remotenet_t, lrn_list);
+               rnet = list_entry(e, struct lnet_remotenet, lrn_list);
 
                if (rnet->lrn_net == dstnet) {
-                       lnet_route_t *route;
-                       lnet_route_t *shortest = NULL;
+                       struct lnet_route *route;
+                       struct lnet_route *shortest = NULL;
                        __u32 shortest_hops = LNET_UNDEFINED_HOPS;
                        __u32 route_hops;
 
index a6ffe8e..cca7766 100644 (file)
@@ -39,7 +39,7 @@
 #include <lnet/lib-lnet.h>
 
 void
-lnet_build_unlink_event(lnet_libmd_t *md, lnet_event_t *ev)
+lnet_build_unlink_event(struct lnet_libmd *md, struct lnet_event *ev)
 {
        ENTRY;
 
@@ -57,10 +57,10 @@ lnet_build_unlink_event(lnet_libmd_t *md, lnet_event_t *ev)
  * Don't need any lock, must be called after lnet_commit_md
  */
 void
-lnet_build_msg_event(lnet_msg_t *msg, lnet_event_kind_t ev_type)
+lnet_build_msg_event(struct lnet_msg *msg, enum lnet_event_kind ev_type)
 {
-       lnet_hdr_t      *hdr = &msg->msg_hdr;
-       lnet_event_t    *ev  = &msg->msg_ev;
+       struct lnet_hdr *hdr = &msg->msg_hdr;
+       struct lnet_event *ev = &msg->msg_ev;
 
        LASSERT(!msg->msg_routing);
 
@@ -139,10 +139,10 @@ lnet_build_msg_event(lnet_msg_t *msg, lnet_event_kind_t ev_type)
 }
 
 void
-lnet_msg_commit(lnet_msg_t *msg, int cpt)
+lnet_msg_commit(struct lnet_msg *msg, int cpt)
 {
        struct lnet_msg_container *container = the_lnet.ln_msg_containers[cpt];
-       lnet_counters_t           *counters  = the_lnet.ln_counters[cpt];
+       struct lnet_counters *counters = the_lnet.ln_counters[cpt];
 
        /* routed message can be committed for both receiving and sending */
        LASSERT(!msg->msg_tx_committed);
@@ -172,10 +172,10 @@ lnet_msg_commit(lnet_msg_t *msg, int cpt)
 }
 
 static void
-lnet_msg_decommit_tx(lnet_msg_t *msg, int status)
+lnet_msg_decommit_tx(struct lnet_msg *msg, int status)
 {
-       lnet_counters_t *counters;
-       lnet_event_t    *ev = &msg->msg_ev;
+       struct lnet_counters *counters;
+       struct lnet_event *ev = &msg->msg_ev;
 
        LASSERT(msg->msg_tx_committed);
        if (status != 0)
@@ -226,10 +226,10 @@ lnet_msg_decommit_tx(lnet_msg_t *msg, int status)
 }
 
 static void
-lnet_msg_decommit_rx(lnet_msg_t *msg, int status)
+lnet_msg_decommit_rx(struct lnet_msg *msg, int status)
 {
-       lnet_counters_t *counters;
-       lnet_event_t    *ev = &msg->msg_ev;
+       struct lnet_counters *counters;
+       struct lnet_event *ev = &msg->msg_ev;
 
        LASSERT(!msg->msg_tx_committed); /* decommitted or never committed */
        LASSERT(msg->msg_rx_committed);
@@ -284,7 +284,7 @@ lnet_msg_decommit_rx(lnet_msg_t *msg, int status)
 }
 
 void
-lnet_msg_decommit(lnet_msg_t *msg, int cpt, int status)
+lnet_msg_decommit(struct lnet_msg *msg, int cpt, int status)
 {
        int     cpt2 = cpt;
 
@@ -318,7 +318,7 @@ lnet_msg_decommit(lnet_msg_t *msg, int cpt, int status)
 }
 
 void
-lnet_msg_attach_md(lnet_msg_t *msg, lnet_libmd_t *md,
+lnet_msg_attach_md(struct lnet_msg *msg, struct lnet_libmd *md,
                   unsigned int offset, unsigned int mlen)
 {
        /* NB: @offset and @len are only useful for receiving */
@@ -346,10 +346,10 @@ lnet_msg_attach_md(lnet_msg_t *msg, lnet_libmd_t *md,
 }
 
 void
-lnet_msg_detach_md(lnet_msg_t *msg, int status)
+lnet_msg_detach_md(struct lnet_msg *msg, int status)
 {
-       lnet_libmd_t    *md = msg->msg_md;
-       int             unlink;
+       struct lnet_libmd *md = msg->msg_md;
+       int unlink;
 
        /* Now it's safe to drop my caller's ref */
        md->md_refcount--;
@@ -369,7 +369,7 @@ lnet_msg_detach_md(lnet_msg_t *msg, int status)
 }
 
 static int
-lnet_complete_msg_locked(lnet_msg_t *msg, int cpt)
+lnet_complete_msg_locked(struct lnet_msg *msg, int cpt)
 {
        struct lnet_handle_wire ack_wmd;
        int                rc;
@@ -445,7 +445,7 @@ lnet_complete_msg_locked(lnet_msg_t *msg, int cpt)
 }
 
 void
-lnet_finalize(lnet_ni_t *ni, lnet_msg_t *msg, int status)
+lnet_finalize(struct lnet_ni *ni, struct lnet_msg *msg, int status)
 {
        struct lnet_msg_container       *container;
        int                             my_slot;
@@ -509,7 +509,7 @@ lnet_finalize(lnet_ni_t *ni, lnet_msg_t *msg, int status)
 
        while (!list_empty(&container->msc_finalizing)) {
                msg = list_entry(container->msc_finalizing.next,
-                                lnet_msg_t, msg_list);
+                                struct lnet_msg, msg_list);
 
                list_del(&msg->msg_list);
 
@@ -543,9 +543,10 @@ lnet_msg_container_cleanup(struct lnet_msg_container *container)
                return;
 
        while (!list_empty(&container->msc_active)) {
-               lnet_msg_t *msg = list_entry(container->msc_active.next,
-                                            lnet_msg_t, msg_activelist);
+               struct lnet_msg *msg;
 
+               msg  = list_entry(container->msc_active.next,
+                                 struct lnet_msg, msg_activelist);
                LASSERT(msg->msg_onactivelist);
                msg->msg_onactivelist = 0;
                list_del(&msg->msg_activelist);
index 0b31878..ec5151e 100644 (file)
@@ -44,7 +44,7 @@ module_param(portal_rotor, int, 0644);
 MODULE_PARM_DESC(portal_rotor, "redirect PUTs to different cpu-partitions");
 
 static int
-lnet_ptl_match_type(unsigned int index, lnet_process_id_t match_id,
+lnet_ptl_match_type(unsigned int index, struct lnet_process_id match_id,
                    __u64 mbits, __u64 ignore_bits)
 {
        struct lnet_portal      *ptl = the_lnet.ln_portals[index];
@@ -136,14 +136,14 @@ lnet_ptl_disable_mt(struct lnet_portal *ptl, int cpt)
 }
 
 static int
-lnet_try_match_md(lnet_libmd_t *md,
+lnet_try_match_md(struct lnet_libmd *md,
                  struct lnet_match_info *info, struct lnet_msg *msg)
 {
        /* ALWAYS called holding the lnet_res_lock, and can't lnet_res_unlock;
         * lnet_match_blocked_msg() relies on this to avoid races */
        unsigned int    offset;
        unsigned int    mlength;
-       lnet_me_t       *me = md->md_me;
+       struct lnet_me  *me = md->md_me;
 
        /* MD exhausted */
        if (lnet_md_exhausted(md))
@@ -215,7 +215,7 @@ lnet_try_match_md(lnet_libmd_t *md,
 }
 
 static struct lnet_match_table *
-lnet_match2mt(struct lnet_portal *ptl, lnet_process_id_t id, __u64 mbits)
+lnet_match2mt(struct lnet_portal *ptl, struct lnet_process_id id, __u64 mbits)
 {
        if (LNET_CPT_NUMBER == 1)
                return ptl->ptl_mtables[0]; /* the only one */
@@ -226,8 +226,8 @@ lnet_match2mt(struct lnet_portal *ptl, lnet_process_id_t id, __u64 mbits)
 }
 
 struct lnet_match_table *
-lnet_mt_of_attach(unsigned int index, lnet_process_id_t id,
-                 __u64 mbits, __u64 ignore_bits, lnet_ins_pos_t pos)
+lnet_mt_of_attach(unsigned int index, struct lnet_process_id id,
+                 __u64 mbits, __u64 ignore_bits, enum lnet_ins_pos pos)
 {
        struct lnet_portal      *ptl;
        struct lnet_match_table *mtable;
@@ -356,7 +356,7 @@ lnet_mt_set_exhausted(struct lnet_match_table *mtable, int pos, int exhausted)
 
 struct list_head *
 lnet_mt_match_head(struct lnet_match_table *mtable,
-                  lnet_process_id_t id, __u64 mbits)
+                  struct lnet_process_id id, __u64 mbits)
 {
        struct lnet_portal *ptl = the_lnet.ln_portals[mtable->mt_portal];
 
@@ -376,8 +376,8 @@ lnet_mt_match_md(struct lnet_match_table *mtable,
                 struct lnet_match_info *info, struct lnet_msg *msg)
 {
        struct list_head        *head;
-       lnet_me_t               *me;
-       lnet_me_t               *tmp;
+       struct lnet_me          *me;
+       struct lnet_me          *tmp;
        int                     exhausted = 0;
        int                     rc;
 
@@ -637,7 +637,7 @@ lnet_ptl_match_md(struct lnet_match_info *info, struct lnet_msg *msg)
 }
 
 void
-lnet_ptl_detach_md(lnet_me_t *me, lnet_libmd_t *md)
+lnet_ptl_detach_md(struct lnet_me *me, struct lnet_libmd *md)
 {
        LASSERT(me->me_md == md && md->md_me == me);
 
@@ -647,16 +647,16 @@ lnet_ptl_detach_md(lnet_me_t *me, lnet_libmd_t *md)
 
 /* called with lnet_res_lock held */
 void
-lnet_ptl_attach_md(lnet_me_t *me, lnet_libmd_t *md,
+lnet_ptl_attach_md(struct lnet_me *me, struct lnet_libmd *md,
                   struct list_head *matches, struct list_head *drops)
 {
-       struct lnet_portal      *ptl = the_lnet.ln_portals[me->me_portal];
+       struct lnet_portal *ptl = the_lnet.ln_portals[me->me_portal];
        struct lnet_match_table *mtable;
-       struct list_head        *head;
-       lnet_msg_t              *tmp;
-       lnet_msg_t              *msg;
-       int                     exhausted = 0;
-       int                     cpt;
+       struct list_head *head;
+       struct lnet_msg *tmp;
+       struct lnet_msg *msg;
+       int exhausted = 0;
+       int cpt;
 
        LASSERT(md->md_refcount == 0); /* a brand new MD */
 
@@ -676,7 +676,7 @@ lnet_ptl_attach_md(lnet_me_t *me, lnet_libmd_t *md,
  again:
        list_for_each_entry_safe(msg, tmp, head, msg_list) {
                struct lnet_match_info  info;
-               lnet_hdr_t              *hdr;
+               struct lnet_hdr         *hdr;
                int                     rc;
 
                LASSERT(msg->msg_rx_delayed || head == &ptl->ptl_msg_stealing);
@@ -754,7 +754,7 @@ lnet_ptl_cleanup(struct lnet_portal *ptl)
        LASSERT(list_empty(&ptl->ptl_msg_stealing));
        cfs_percpt_for_each(mtable, i, ptl->ptl_mtables) {
                struct list_head *mhash;
-               lnet_me_t        *me;
+               struct lnet_me   *me;
                int               j;
 
                if (mtable->mt_mhash == NULL) /* uninitialized match-table */
@@ -765,7 +765,7 @@ lnet_ptl_cleanup(struct lnet_portal *ptl)
                for (j = 0; j < LNET_MT_HASH_SIZE + 1; j++) {
                        while (!list_empty(&mhash[j])) {
                                me = list_entry(mhash[j].next,
-                                               lnet_me_t, me_list);
+                                               struct lnet_me, me_list);
                                CERROR("Active ME %p on exit\n", me);
                                list_del(&me->me_list);
                                lnet_me_free(me);
index 6408bd1..dae45a4 100644 (file)
@@ -32,7 +32,7 @@
 #include <lnet/lib-lnet.h>
 
 static int
-lolnd_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
+lolnd_send(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg)
 {
        LASSERT(!lntmsg->msg_routing);
        LASSERT(!lntmsg->msg_target_is_router);
@@ -41,12 +41,12 @@ lolnd_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg)
 }
 
 static int
-lolnd_recv (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg,
-           int delayed, unsigned int niov,
-           struct kvec *iov, lnet_kiov_t *kiov,
-           unsigned int offset, unsigned int mlen, unsigned int rlen)
+lolnd_recv(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg,
+          int delayed, unsigned int niov,
+          struct kvec *iov, lnet_kiov_t *kiov,
+          unsigned int offset, unsigned int mlen, unsigned int rlen)
 {
-       lnet_msg_t *sendmsg = private;
+       struct lnet_msg *sendmsg = private;
 
        if (lntmsg != NULL) {                   /* not discarding */
                if (sendmsg->msg_iov != NULL) {
@@ -83,7 +83,7 @@ lolnd_recv (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg,
 static int lolnd_instanced;
 
 static void
-lolnd_shutdown(lnet_ni_t *ni)
+lolnd_shutdown(struct lnet_ni *ni)
 {
        CDEBUG (D_NET, "shutdown\n");
        LASSERT(lolnd_instanced);
@@ -92,7 +92,7 @@ lolnd_shutdown(lnet_ni_t *ni)
 }
 
 static int
-lolnd_startup (lnet_ni_t *ni)
+lolnd_startup(struct lnet_ni *ni)
 {
        LASSERT (ni->ni_net->net_lnd == &the_lolnd);
        LASSERT (!lolnd_instanced);
@@ -101,7 +101,7 @@ lolnd_startup (lnet_ni_t *ni)
        return (0);
 }
 
-lnd_t the_lolnd = {
+struct lnet_lnd the_lolnd = {
        .lnd_list       = {
                                .next = &the_lolnd.lnd_list,
                                .prev = &the_lolnd.lnd_list
index 91c9c6b..3861a16 100644 (file)
@@ -360,7 +360,7 @@ drop_rule_match(struct lnet_drop_rule *rule, lnet_nid_t src,
  * Check if message from \a src to \a dst can match any existed drop rule
  */
 bool
-lnet_drop_rule_match(lnet_hdr_t *hdr)
+lnet_drop_rule_match(struct lnet_hdr *hdr)
 {
        struct lnet_drop_rule   *rule;
        lnet_nid_t               src = le64_to_cpu(hdr->src_nid);
@@ -544,7 +544,7 @@ delay_rule_match(struct lnet_delay_rule *rule, lnet_nid_t src,
  * will be delayed if there is a match.
  */
 bool
-lnet_delay_rule_match_locked(lnet_hdr_t *hdr, struct lnet_msg *msg)
+lnet_delay_rule_match_locked(struct lnet_hdr *hdr, struct lnet_msg *msg)
 {
        struct lnet_delay_rule  *rule;
        lnet_nid_t               src = le64_to_cpu(hdr->src_nid);
index f97b464..ee3def8 100644 (file)
@@ -1237,7 +1237,7 @@ libcfs_str2nid(const char *str)
 EXPORT_SYMBOL(libcfs_str2nid);
 
 char *
-libcfs_id2str(lnet_process_id_t id)
+libcfs_id2str(struct lnet_process_id id)
 {
        char *str = libcfs_next_nidstring();
 
index 502ff84..0e929bf 100644 (file)
@@ -142,7 +142,7 @@ lnet_notify_locked(struct lnet_peer_ni *lp, int notifylnd, int alive,
  * This function will always be called with lp->lpni_cpt lock held.
  */
 static void
-lnet_ni_notify_locked(lnet_ni_t *ni, struct lnet_peer_ni *lp)
+lnet_ni_notify_locked(struct lnet_ni *ni, struct lnet_peer_ni *lp)
 {
        int alive;
        int notifylnd;
@@ -203,10 +203,10 @@ lnet_rtr_addref_locked(struct lnet_peer_ni *lp)
 
                /* a simple insertion sort */
                list_for_each_prev(pos, &the_lnet.ln_routers) {
-                       struct lnet_peer_ni *rtr =
-                         list_entry(pos, struct lnet_peer_ni,
-                                    lpni_rtr_list);
+                       struct lnet_peer_ni *rtr;
 
+                       rtr = list_entry(pos, struct lnet_peer_ni,
+                                        lpni_rtr_list);
                        if (rtr->lpni_nid < lp->lpni_nid)
                                break;
                }
@@ -242,10 +242,10 @@ lnet_rtr_decref_locked(struct lnet_peer_ni *lp)
        }
 }
 
-lnet_remotenet_t *
+struct lnet_remotenet *
 lnet_find_rnet_locked(__u32 net)
 {
-       lnet_remotenet_t *rnet;
+       struct lnet_remotenet *rnet;
        struct list_head *tmp;
        struct list_head *rn_list;
 
@@ -253,7 +253,7 @@ lnet_find_rnet_locked(__u32 net)
 
        rn_list = lnet_net2rnethash(net);
        list_for_each(tmp, rn_list) {
-               rnet = list_entry(tmp, lnet_remotenet_t, lrn_list);
+               rnet = list_entry(tmp, struct lnet_remotenet, lrn_list);
 
                if (rnet->lrn_net == net)
                        return rnet;
@@ -267,7 +267,7 @@ static void lnet_shuffle_seed(void)
        __u32 lnd_type;
        __u32 seed[2];
        struct timespec64 ts;
-       lnet_ni_t *ni = NULL;
+       struct lnet_ni *ni = NULL;
 
        if (seeded)
                return;
@@ -291,7 +291,7 @@ static void lnet_shuffle_seed(void)
 
 /* NB expects LNET_LOCK held */
 static void
-lnet_add_route_to_rnet(lnet_remotenet_t *rnet, lnet_route_t *route)
+lnet_add_route_to_rnet(struct lnet_remotenet *rnet, struct lnet_route *route)
 {
        unsigned int      len = 0;
        unsigned int      offset = 0;
@@ -322,10 +322,10 @@ lnet_add_route(__u32 net, __u32 hops, lnet_nid_t gateway,
               unsigned int priority)
 {
        struct list_head        *e;
-       lnet_remotenet_t        *rnet;
-       lnet_remotenet_t        *rnet2;
-       lnet_route_t            *route;
-       lnet_ni_t               *ni;
+       struct lnet_remotenet   *rnet;
+       struct lnet_remotenet   *rnet2;
+       struct lnet_route               *route;
+       struct lnet_ni          *ni;
        struct lnet_peer_ni     *lpni;
        int                     add_route;
        int                     rc;
@@ -393,8 +393,9 @@ lnet_add_route(__u32 net, __u32 hops, lnet_nid_t gateway,
        /* Search for a duplicate route (it's a NOOP if it is) */
        add_route = 1;
        list_for_each(e, &rnet2->lrn_routes) {
-               lnet_route_t *route2 = list_entry(e, lnet_route_t, lr_list);
+               struct lnet_route *route2;
 
+               route2 = list_entry(e, struct lnet_route, lr_list);
                if (route2->lr_gateway == route->lr_gateway) {
                        add_route = 0;
                        break;
@@ -441,9 +442,9 @@ lnet_add_route(__u32 net, __u32 hops, lnet_nid_t gateway,
 int
 lnet_check_routes(void)
 {
-       lnet_remotenet_t *rnet;
-       lnet_route_t     *route;
-       lnet_route_t     *route2;
+       struct lnet_remotenet *rnet;
+       struct lnet_route        *route;
+       struct lnet_route        *route2;
        struct list_head *e1;
        struct list_head *e2;
        int               cpt;
@@ -455,7 +456,7 @@ lnet_check_routes(void)
        for (i = 0; i < LNET_REMOTE_NETS_HASH_SIZE; i++) {
                rn_list = &the_lnet.ln_remote_nets_hash[i];
                list_for_each(e1, rn_list) {
-                       rnet = list_entry(e1, lnet_remotenet_t, lrn_list);
+                       rnet = list_entry(e1, struct lnet_remotenet, lrn_list);
 
                        route2 = NULL;
                        list_for_each(e2, &rnet->lrn_routes) {
@@ -463,7 +464,7 @@ lnet_check_routes(void)
                                lnet_nid_t      nid2;
                                int             net;
 
-                               route = list_entry(e2, lnet_route_t,
+                               route = list_entry(e2, struct lnet_route,
                                                   lr_list);
 
                                if (route2 == NULL) {
@@ -499,8 +500,8 @@ int
 lnet_del_route(__u32 net, lnet_nid_t gw_nid)
 {
        struct lnet_peer_ni     *gateway;
-       lnet_remotenet_t        *rnet;
-       lnet_route_t            *route;
+       struct lnet_remotenet   *rnet;
+       struct lnet_route               *route;
        struct list_head        *e1;
        struct list_head        *e2;
        int                     rc = -ENOENT;
@@ -521,14 +522,14 @@ lnet_del_route(__u32 net, lnet_nid_t gw_nid)
 
 again:
        list_for_each(e1, rn_list) {
-               rnet = list_entry(e1, lnet_remotenet_t, lrn_list);
+               rnet = list_entry(e1, struct lnet_remotenet, lrn_list);
 
                if (!(net == LNET_NIDNET(LNET_NID_ANY) ||
                        net == rnet->lrn_net))
                        continue;
 
                list_for_each(e2, &rnet->lrn_routes) {
-                       route = list_entry(e2, lnet_route_t, lr_list);
+                       route = list_entry(e2, struct lnet_route, lr_list);
 
                        gateway = route->lr_gateway;
                        if (!(gw_nid == LNET_NID_ANY ||
@@ -584,7 +585,7 @@ int lnet_get_rtr_pool_cfg(int idx, struct lnet_ioctl_pool_cfg *pool_cfg)
                return rc;
 
        for (i = 0; i < LNET_NRBPOOLS; i++) {
-               lnet_rtrbufpool_t *rbp;
+               struct lnet_rtrbufpool *rbp;
 
                lnet_net_lock(LNET_LOCK_EX);
                cfs_percpt_for_each(rbp, j, the_lnet.ln_rtrpools) {
@@ -614,8 +615,8 @@ lnet_get_route(int idx, __u32 *net, __u32 *hops,
 {
        struct list_head *e1;
        struct list_head *e2;
-       lnet_remotenet_t *rnet;
-       lnet_route_t     *route;
+       struct lnet_remotenet *rnet;
+       struct lnet_route        *route;
        int               cpt;
        int               i;
        struct list_head *rn_list;
@@ -625,10 +626,10 @@ lnet_get_route(int idx, __u32 *net, __u32 *hops,
        for (i = 0; i < LNET_REMOTE_NETS_HASH_SIZE; i++) {
                rn_list = &the_lnet.ln_remote_nets_hash[i];
                list_for_each(e1, rn_list) {
-                       rnet = list_entry(e1, lnet_remotenet_t, lrn_list);
+                       rnet = list_entry(e1, struct lnet_remotenet, lrn_list);
 
                        list_for_each(e2, &rnet->lrn_routes) {
-                               route = list_entry(e2, lnet_route_t,
+                               route = list_entry(e2, struct lnet_route,
                                                   lr_list);
 
                                if (idx-- == 0) {
@@ -671,11 +672,11 @@ lnet_swap_pinginfo(struct lnet_ping_info *info)
  * networks on that router.
  */
 static void
-lnet_parse_rc_info(lnet_rc_data_t *rcd)
+lnet_parse_rc_info(struct lnet_rc_data *rcd)
 {
        struct lnet_ping_info   *info = rcd->rcd_pinginfo;
        struct lnet_peer_ni     *gw   = rcd->rcd_gateway;
-       lnet_route_t            *rte;
+       struct lnet_route               *rte;
 
        if (!gw->lpni_alive)
                return;
@@ -772,15 +773,15 @@ lnet_parse_rc_info(lnet_rc_data_t *rcd)
 }
 
 static void
-lnet_router_checker_event(lnet_event_t *event)
+lnet_router_checker_event(struct lnet_event *event)
 {
-       lnet_rc_data_t *rcd = event->md.user_ptr;
+       struct lnet_rc_data *rcd = event->md.user_ptr;
        struct lnet_peer_ni *lp;
 
        LASSERT(rcd != NULL);
 
        if (event->unlinked) {
-               LNetInvalidateHandle(&rcd->rcd_mdh);
+               LNetInvalidateMDHandle(&rcd->rcd_mdh);
                return;
        }
 
@@ -864,7 +865,7 @@ lnet_wait_known_routerstate(void)
 void
 lnet_router_ni_update_locked(struct lnet_peer_ni *gw, __u32 net)
 {
-       lnet_route_t *rte;
+       struct lnet_route *rte;
 
        if ((gw->lpni_ping_feats & LNET_PING_FEAT_NI_STATUS) != 0) {
                list_for_each_entry(rte, &gw->lpni_routes, lr_gwlist) {
@@ -879,9 +880,9 @@ lnet_router_ni_update_locked(struct lnet_peer_ni *gw, __u32 net)
 static void
 lnet_update_ni_status_locked(void)
 {
-       lnet_ni_t       *ni = NULL;
-       time64_t        now;
-       int             timeout;
+       struct lnet_ni *ni = NULL;
+       time64_t now;
+       int timeout;
 
        LASSERT(the_lnet.ln_routing);
 
@@ -917,11 +918,11 @@ lnet_update_ni_status_locked(void)
 }
 
 static void
-lnet_destroy_rc_data(lnet_rc_data_t *rcd)
+lnet_destroy_rc_data(struct lnet_rc_data *rcd)
 {
        LASSERT(list_empty(&rcd->rcd_list));
        /* detached from network */
-       LASSERT(LNetHandleIsInvalid(rcd->rcd_mdh));
+       LASSERT(LNetMDHandleIsInvalid(rcd->rcd_mdh));
 
        if (rcd->rcd_gateway != NULL) {
                int cpt = rcd->rcd_gateway->lpni_cpt;
@@ -937,10 +938,10 @@ lnet_destroy_rc_data(lnet_rc_data_t *rcd)
        LIBCFS_FREE(rcd, sizeof(*rcd));
 }
 
-static lnet_rc_data_t *
+static struct lnet_rc_data *
 lnet_create_rc_data_locked(struct lnet_peer_ni *gateway)
 {
-       lnet_rc_data_t          *rcd = NULL;
+       struct lnet_rc_data             *rcd = NULL;
        struct lnet_ping_info   *pi;
        int                     rc;
        int                     i;
@@ -951,7 +952,7 @@ lnet_create_rc_data_locked(struct lnet_peer_ni *gateway)
        if (rcd == NULL)
                goto out;
 
-       LNetInvalidateHandle(&rcd->rcd_mdh);
+       LNetInvalidateMDHandle(&rcd->rcd_mdh);
        INIT_LIST_HEAD(&rcd->rcd_list);
 
        LIBCFS_ALLOC(pi, LNET_PINGINFO_SIZE);
@@ -964,8 +965,8 @@ lnet_create_rc_data_locked(struct lnet_peer_ni *gateway)
        }
        rcd->rcd_pinginfo = pi;
 
-       LASSERT(!LNetHandleIsInvalid(the_lnet.ln_rc_eqh));
-       rc = LNetMDBind((lnet_md_t){.start     = pi,
+       LASSERT(!LNetEQHandleIsInvalid(the_lnet.ln_rc_eqh));
+       rc = LNetMDBind((struct lnet_md){.start     = pi,
                                    .user_ptr  = rcd,
                                    .length    = LNET_PINGINFO_SIZE,
                                    .threshold = LNET_MD_THRESH_INF,
@@ -995,7 +996,7 @@ lnet_create_rc_data_locked(struct lnet_peer_ni *gateway)
 
 out:
        if (rcd != NULL) {
-               if (!LNetHandleIsInvalid(rcd->rcd_mdh)) {
+               if (!LNetMDHandleIsInvalid(rcd->rcd_mdh)) {
                        rc = LNetMDUnlink(rcd->rcd_mdh);
                        LASSERT(rc == 0);
                }
@@ -1007,7 +1008,7 @@ out:
 }
 
 static int
-lnet_router_check_interval (struct lnet_peer_ni *rtr)
+lnet_router_check_interval(struct lnet_peer_ni *rtr)
 {
        int secs;
 
@@ -1020,9 +1021,9 @@ lnet_router_check_interval (struct lnet_peer_ni *rtr)
 }
 
 static void
-lnet_ping_router_locked (struct lnet_peer_ni *rtr)
+lnet_ping_router_locked(struct lnet_peer_ni *rtr)
 {
-       lnet_rc_data_t *rcd = NULL;
+       struct lnet_rc_data *rcd = NULL;
        cfs_time_t      now = cfs_time_current();
        int             secs;
        struct lnet_ni  *ni;
@@ -1063,8 +1064,8 @@ lnet_ping_router_locked (struct lnet_peer_ni *rtr)
            cfs_time_after(now, cfs_time_add(rtr->lpni_ping_timestamp,
                                             cfs_time_seconds(secs)))) {
                int               rc;
-               lnet_process_id_t id;
-               lnet_handle_md_t  mdh;
+               struct lnet_process_id id;
+               struct lnet_handle_md mdh;
 
                id.nid = rtr->lpni_nid;
                id.pid = LNET_PID_LUSTRE;
@@ -1167,11 +1168,11 @@ lnet_router_checker_stop (void)
 static void
 lnet_prune_rc_data(int wait_unlink)
 {
-       lnet_rc_data_t          *rcd;
-       lnet_rc_data_t          *tmp;
-       struct lnet_peer_ni     *lp;
-       struct list_head         head;
-       int                      i = 2;
+       struct lnet_rc_data *rcd;
+       struct lnet_rc_data *tmp;
+       struct lnet_peer_ni *lp;
+       struct list_head head;
+       int i = 2;
 
        if (likely(the_lnet.ln_rc_state == LNET_RC_STATE_RUNNING &&
                   list_empty(&the_lnet.ln_rcd_deathrow) &&
@@ -1214,7 +1215,7 @@ lnet_prune_rc_data(int wait_unlink)
        while (!list_empty(&the_lnet.ln_rcd_zombie)) {
                list_for_each_entry_safe(rcd, tmp, &the_lnet.ln_rcd_zombie,
                                         rcd_list) {
-                       if (LNetHandleIsInvalid(rcd->rcd_mdh))
+                       if (LNetMDHandleIsInvalid(rcd->rcd_mdh))
                                list_move(&rcd->rcd_list, &head);
                }
 
@@ -1225,7 +1226,7 @@ lnet_prune_rc_data(int wait_unlink)
 
                while (!list_empty(&head)) {
                        rcd = list_entry(head.next,
-                                        lnet_rc_data_t, rcd_list);
+                                        struct lnet_rc_data, rcd_list);
                        list_del_init(&rcd->rcd_list);
                        lnet_destroy_rc_data(rcd);
                }
@@ -1341,9 +1342,9 @@ rescan:
 }
 
 void
-lnet_destroy_rtrbuf(lnet_rtrbuf_t *rb, int npages)
+lnet_destroy_rtrbuf(struct lnet_rtrbuf *rb, int npages)
 {
-       int sz = offsetof(lnet_rtrbuf_t, rb_kiov[npages]);
+       int sz = offsetof(struct lnet_rtrbuf, rb_kiov[npages]);
 
        while (--npages >= 0)
                __free_page(rb->rb_kiov[npages].kiov_page);
@@ -1351,13 +1352,13 @@ lnet_destroy_rtrbuf(lnet_rtrbuf_t *rb, int npages)
        LIBCFS_FREE(rb, sz);
 }
 
-static lnet_rtrbuf_t *
-lnet_new_rtrbuf(lnet_rtrbufpool_t *rbp, int cpt)
+static struct lnet_rtrbuf *
+lnet_new_rtrbuf(struct lnet_rtrbufpool *rbp, int cpt)
 {
        int            npages = rbp->rbp_npages;
-       int            sz = offsetof(lnet_rtrbuf_t, rb_kiov[npages]);
+       int            sz = offsetof(struct lnet_rtrbuf, rb_kiov[npages]);
        struct page   *page;
-       lnet_rtrbuf_t *rb;
+       struct lnet_rtrbuf *rb;
        int            i;
 
        LIBCFS_CPT_ALLOC(rb, lnet_cpt_table(), cpt, sz);
@@ -1386,10 +1387,10 @@ lnet_new_rtrbuf(lnet_rtrbufpool_t *rbp, int cpt)
 }
 
 static void
-lnet_rtrpool_free_bufs(lnet_rtrbufpool_t *rbp, int cpt)
+lnet_rtrpool_free_bufs(struct lnet_rtrbufpool *rbp, int cpt)
 {
-       int              npages = rbp->rbp_npages;
-       lnet_rtrbuf_t    *rb;
+       int npages = rbp->rbp_npages;
+       struct lnet_rtrbuf *rb;
        struct list_head tmp;
 
        if (rbp->rbp_nbuffers == 0) /* not initialized or already freed */
@@ -1408,17 +1409,17 @@ lnet_rtrpool_free_bufs(lnet_rtrbufpool_t *rbp, int cpt)
 
        /* Free buffers on the free list. */
        while (!list_empty(&tmp)) {
-               rb = list_entry(tmp.next, lnet_rtrbuf_t, rb_list);
+               rb = list_entry(tmp.next, struct lnet_rtrbuf, rb_list);
                list_del(&rb->rb_list);
                lnet_destroy_rtrbuf(rb, npages);
        }
 }
 
 static int
-lnet_rtrpool_adjust_bufs(lnet_rtrbufpool_t *rbp, int nbufs, int cpt)
+lnet_rtrpool_adjust_bufs(struct lnet_rtrbufpool *rbp, int nbufs, int cpt)
 {
        struct list_head rb_list;
-       lnet_rtrbuf_t   *rb;
+       struct lnet_rtrbuf *rb;
        int             num_rb;
        int             num_buffers = 0;
        int             old_req_nbufs;
@@ -1485,7 +1486,7 @@ lnet_rtrpool_adjust_bufs(lnet_rtrbufpool_t *rbp, int nbufs, int cpt)
 
 failed:
        while (!list_empty(&rb_list)) {
-               rb = list_entry(rb_list.next, lnet_rtrbuf_t, rb_list);
+               rb = list_entry(rb_list.next, struct lnet_rtrbuf, rb_list);
                list_del(&rb->rb_list);
                lnet_destroy_rtrbuf(rb, npages);
        }
@@ -1494,7 +1495,7 @@ failed:
 }
 
 static void
-lnet_rtrpool_init(lnet_rtrbufpool_t *rbp, int npages)
+lnet_rtrpool_init(struct lnet_rtrbufpool *rbp, int npages)
 {
        INIT_LIST_HEAD(&rbp->rbp_msgs);
        INIT_LIST_HEAD(&rbp->rbp_bufs);
@@ -1507,7 +1508,7 @@ lnet_rtrpool_init(lnet_rtrbufpool_t *rbp, int npages)
 void
 lnet_rtrpools_free(int keep_pools)
 {
-       lnet_rtrbufpool_t *rtrp;
+       struct lnet_rtrbufpool *rtrp;
        int               i;
 
        if (the_lnet.ln_rtrpools == NULL) /* uninitialized or freed */
@@ -1585,7 +1586,7 @@ lnet_nrb_large_calculate(void)
 int
 lnet_rtrpools_alloc(int im_a_router)
 {
-       lnet_rtrbufpool_t *rtrp;
+       struct lnet_rtrbufpool *rtrp;
        int     nrb_tiny;
        int     nrb_small;
        int     nrb_large;
@@ -1621,7 +1622,7 @@ lnet_rtrpools_alloc(int im_a_router)
 
        the_lnet.ln_rtrpools = cfs_percpt_alloc(lnet_cpt_table(),
                                                LNET_NRBPOOLS *
-                                               sizeof(lnet_rtrbufpool_t));
+                                               sizeof(struct lnet_rtrbufpool));
        if (the_lnet.ln_rtrpools == NULL) {
                LCONSOLE_ERROR_MSG(0x10c,
                                   "Failed to initialize router buffe pool\n");
@@ -1666,7 +1667,7 @@ lnet_rtrpools_adjust_helper(int tiny, int small, int large)
        int nrb = 0;
        int rc = 0;
        int i;
-       lnet_rtrbufpool_t *rtrp;
+       struct lnet_rtrbufpool *rtrp;
 
        /* If the provided values for each buffer pool are different than the
         * configured values, we need to take action. */
@@ -1764,7 +1765,7 @@ lnet_rtrpools_disable(void)
 }
 
 int
-lnet_notify(lnet_ni_t *ni, lnet_nid_t nid, int alive, cfs_time_t when)
+lnet_notify(struct lnet_ni *ni, lnet_nid_t nid, int alive, cfs_time_t when)
 {
        struct lnet_peer_ni *lp = NULL;
        cfs_time_t now = cfs_time_current();
index 8b25f0f..953130f 100644 (file)
@@ -80,7 +80,7 @@ static int __proc_lnet_stats(void *data, int write,
                             loff_t pos, void __user *buffer, int nob)
 {
        int              rc;
-       lnet_counters_t *ctrs;
+       struct lnet_counters *ctrs;
        int              len;
        char            *tmpstr;
        const int        tmpsiz = 256; /* 7 %u and 4 __u64 */
@@ -177,8 +177,8 @@ proc_lnet_routes(struct ctl_table *table, int write, void __user *buffer,
        } else {
                struct list_head        *n;
                struct list_head        *r;
-               lnet_route_t            *route = NULL;
-               lnet_remotenet_t        *rnet  = NULL;
+               struct lnet_route               *route = NULL;
+               struct lnet_remotenet   *rnet  = NULL;
                int                     skip  = off - 1;
                struct list_head        *rn_list;
                int                     i;
@@ -198,14 +198,14 @@ proc_lnet_routes(struct ctl_table *table, int write, void __user *buffer,
                        n = rn_list->next;
 
                        while (n != rn_list && route == NULL) {
-                               rnet = list_entry(n, lnet_remotenet_t,
+                               rnet = list_entry(n, struct lnet_remotenet,
                                                  lrn_list);
 
                                r = rnet->lrn_routes.next;
 
                                while (r != &rnet->lrn_routes) {
-                                       lnet_route_t *re =
-                                               list_entry(r, lnet_route_t,
+                                       struct lnet_route *re =
+                                               list_entry(r, struct lnet_route,
                                                           lr_list);
                                        if (skip == 0) {
                                                route = re;
@@ -340,7 +340,7 @@ proc_lnet_routers(struct ctl_table *table, int write, void __user *buffer,
                        int last_ping = cfs_duration_sec(cfs_time_sub(now,
                                                     peer->lpni_ping_timestamp));
                        int down_ni   = 0;
-                       lnet_route_t *rtr;
+                       struct lnet_route *rtr;
 
                        if ((peer->lpni_ping_feats &
                             LNET_PING_FEAT_NI_STATUS) != 0) {
@@ -599,7 +599,7 @@ static int __proc_lnet_buffers(void *data, int write,
                goto out; /* I'm not a router */
 
        for (idx = 0; idx < LNET_NRBPOOLS; idx++) {
-               lnet_rtrbufpool_t *rbp;
+               struct lnet_rtrbufpool *rbp;
 
                lnet_net_lock(LNET_LOCK_EX);
                cfs_percpt_for_each(rbp, i, the_lnet.ln_rtrpools) {
@@ -663,8 +663,8 @@ proc_lnet_nis(struct ctl_table *table, int write, void __user *buffer,
                              "rtr", "max", "tx", "min");
                LASSERT (tmpstr + tmpsiz - s > 0);
        } else {
-               lnet_ni_t         *ni   = NULL;
-               int                skip = *ppos - 1;
+               struct lnet_ni *ni   = NULL;
+               int skip = *ppos - 1;
 
                lnet_net_lock(0);
 
index 51e3254..512dbb5 100644 (file)
@@ -269,7 +269,7 @@ brw_check_bulk(srpc_bulk_t *bk, int pattern, __u64 magic)
 
 static int
 brw_client_prep_rpc(sfw_test_unit_t *tsu,
-                   lnet_process_id_t dest, srpc_client_rpc_t **rpcpp)
+                   struct lnet_process_id dest, srpc_client_rpc_t **rpcpp)
 {
        srpc_bulk_t         *bulk = tsu->tsu_private;
        sfw_test_instance_t *tsi = tsu->tsu_instance;
index 1d09d40..b445183 100644 (file)
@@ -506,7 +506,7 @@ lstcon_rpc_trans_interpreter(lstcon_rpc_trans_t *trans,
                 cfs_duration_usec(dur, &tv);
 
                if (copy_to_user(&ent->rpe_peer,
-                                &nd->nd_id, sizeof(lnet_process_id_t)) ||
+                                &nd->nd_id, sizeof(struct lnet_process_id)) ||
                    copy_to_user(&ent->rpe_stamp, &tv, sizeof(tv)) ||
                    copy_to_user(&ent->rpe_state,
                                 &nd->nd_state, sizeof(nd->nd_state)) ||
index e7f04c7..f2cf0a4 100644 (file)
@@ -66,7 +66,7 @@ lstcon_node_get(lstcon_node_t *nd)
 }
 
 static int
-lstcon_node_find(lnet_process_id_t id, lstcon_node_t **ndpp, int create)
+lstcon_node_find(struct lnet_process_id id, lstcon_node_t **ndpp, int create)
 {
        lstcon_ndlink_t *ndl;
        unsigned int     idx = LNET_NIDADDR(id.nid) % LST_GLOBAL_HASHSIZE;
@@ -134,8 +134,8 @@ lstcon_node_put(lstcon_node_t *nd)
 }
 
 static int
-lstcon_ndlink_find(struct list_head *hash,
-                   lnet_process_id_t id, lstcon_ndlink_t **ndlpp, int create)
+lstcon_ndlink_find(struct list_head *hash, struct lnet_process_id id,
+                  lstcon_ndlink_t **ndlpp, int create)
 {
        unsigned int     idx = LNET_NIDADDR(id.nid) % LST_NODE_HASHSIZE;
        lstcon_ndlink_t *ndl;
@@ -281,7 +281,7 @@ lstcon_group_find(const char *name, lstcon_group_t **grpp)
 }
 
 static int
-lstcon_group_ndlink_find(lstcon_group_t *grp, lnet_process_id_t id,
+lstcon_group_ndlink_find(lstcon_group_t *grp, struct lnet_process_id id,
                          lstcon_ndlink_t **ndlpp, int create)
 {
        int rc;
@@ -397,13 +397,13 @@ lstcon_sesrpc_readent(int transop, srpc_msg_t *msg,
 
 static int
 lstcon_group_nodes_add(lstcon_group_t *grp,
-                      int count, lnet_process_id_t __user *ids_up,
+                      int count, struct lnet_process_id __user *ids_up,
                       unsigned *featp, struct list_head __user *result_up)
 {
         lstcon_rpc_trans_t      *trans;
         lstcon_ndlink_t         *ndl;
         lstcon_group_t          *tmp;
-        lnet_process_id_t        id;
+       struct lnet_process_id        id;
         int                      i;
         int                      rc;
 
@@ -464,13 +464,13 @@ lstcon_group_nodes_add(lstcon_group_t *grp,
 
 static int
 lstcon_group_nodes_remove(lstcon_group_t *grp,
-                         int count, lnet_process_id_t __user *ids_up,
+                         int count, struct lnet_process_id __user *ids_up,
                          struct list_head __user *result_up)
 {
         lstcon_rpc_trans_t     *trans;
         lstcon_ndlink_t        *ndl;
         lstcon_group_t         *tmp;
-        lnet_process_id_t       id;
+       struct lnet_process_id       id;
         int                     rc;
         int                     i;
 
@@ -542,7 +542,7 @@ lstcon_group_add(char *name)
 }
 
 int
-lstcon_nodes_add(char *name, int count, lnet_process_id_t __user *ids_up,
+lstcon_nodes_add(char *name, int count, struct lnet_process_id __user *ids_up,
                 unsigned *featp, struct list_head __user *result_up)
 {
         lstcon_group_t         *grp;
@@ -647,7 +647,7 @@ lstcon_group_clean(char *name, int args)
 
 int
 lstcon_nodes_remove(char *name, int count,
-                   lnet_process_id_t __user *ids_up,
+                   struct lnet_process_id __user *ids_up,
                    struct list_head __user *result_up)
 {
         lstcon_group_t *grp = NULL;
@@ -1468,7 +1468,7 @@ lstcon_statrpc_readent(int transop, srpc_msg_t *msg,
        srpc_stat_reply_t *rep = &msg->msg_body.stat_reply;
        struct sfw_counters __user  *sfwk_stat;
        struct srpc_counters __user *srpc_stat;
-       lnet_counters_t __user *lnet_stat;
+       struct lnet_counters __user *lnet_stat;
 
         if (rep->str_status != 0)
                 return 0;
@@ -1476,7 +1476,7 @@ lstcon_statrpc_readent(int transop, srpc_msg_t *msg,
        sfwk_stat = (struct sfw_counters __user *)&ent_up->rpe_payload[0];
        srpc_stat = (struct srpc_counters __user *)
                ((char __user *)sfwk_stat + sizeof(*sfwk_stat));
-       lnet_stat = (lnet_counters_t __user *)
+       lnet_stat = (struct lnet_counters __user *)
                ((char __user *)srpc_stat + sizeof(*srpc_stat));
 
        if (copy_to_user(sfwk_stat, &rep->str_fw, sizeof(*sfwk_stat)) ||
@@ -1534,12 +1534,12 @@ lstcon_group_stat(char *grp_name, int timeout,
 }
 
 int
-lstcon_nodes_stat(int count, lnet_process_id_t __user *ids_up,
+lstcon_nodes_stat(int count, struct lnet_process_id __user *ids_up,
                  int timeout, struct list_head __user *result_up)
 {
         lstcon_ndlink_t         *ndl;
         lstcon_group_t          *tmp;
-        lnet_process_id_t        id;
+       struct lnet_process_id        id;
         int                      i;
         int                      rc;
 
@@ -1646,10 +1646,10 @@ lstcon_group_debug(int timeout, char *name,
 
 int
 lstcon_nodes_debug(int timeout,
-                  int count, lnet_process_id_t __user *ids_up,
+                  int count, struct lnet_process_id __user *ids_up,
                   struct list_head __user *result_up)
 {
-        lnet_process_id_t  id;
+       struct lnet_process_id  id;
         lstcon_ndlink_t   *ndl;
         lstcon_group_t    *grp;
         int                i;
@@ -1698,7 +1698,7 @@ lstcon_session_match(struct lst_sid sid)
 static void
 lstcon_new_session_id(struct lst_sid *sid)
 {
-        lnet_process_id_t      id;
+       struct lnet_process_id id;
 
         LASSERT (console_session.ses_state == LST_SESSION_NONE);
 
index d178354..3145346 100644 (file)
@@ -48,7 +48,7 @@
 #include "conrpc.h"
 
 typedef struct lstcon_node {
-        lnet_process_id_t    nd_id;          /* id of the node */
+       struct lnet_process_id    nd_id;          /* id of the node */
         int                  nd_ref;         /* reference count */
         int                  nd_state;       /* state of the node */
         int                  nd_timeout;     /* session timeout */
@@ -186,7 +186,7 @@ lstcon_trans_stat(void)
 }
 
 static inline struct list_head *
-lstcon_id2hash(lnet_process_id_t id, struct list_head *hash)
+lstcon_id2hash(struct lnet_process_id id, struct list_head *hash)
 {
         unsigned int idx = LNET_NIDADDR(id.nid) % LST_NODE_HASHSIZE;
 
@@ -209,18 +209,18 @@ extern int lstcon_batch_debug(int timeout, char *name,
 extern int lstcon_group_debug(int timeout, char *name,
                              struct list_head __user *result_up);
 extern int lstcon_nodes_debug(int timeout, int nnd,
-                             lnet_process_id_t __user *nds_up,
+                             struct lnet_process_id __user *nds_up,
                              struct list_head __user *result_up);
 extern int lstcon_group_add(char *name);
 extern int lstcon_group_del(char *name);
 extern int lstcon_group_clean(char *name, int args);
 extern int lstcon_group_refresh(char *name, struct list_head __user *result_up);
 extern int lstcon_nodes_add(char *name, int nnd,
-                           lnet_process_id_t __user *nds_up,
+                           struct lnet_process_id __user *nds_up,
                            unsigned *featp,
                            struct list_head __user *result_up);
 extern int lstcon_nodes_remove(char *name, int nnd,
-                              lnet_process_id_t __user *nds_up,
+                              struct lnet_process_id __user *nds_up,
                               struct list_head __user *result_up);
 extern int lstcon_group_info(char *name, struct lstcon_ndlist_ent __user *gent_up,
                             int *index_p, int *ndent_p,
@@ -243,7 +243,7 @@ extern int lstcon_batch_info(char *name,
                             struct lstcon_node_ent __user *dents_up);
 extern int lstcon_group_stat(char *grp_name, int timeout,
                             struct list_head __user *result_up);
-extern int lstcon_nodes_stat(int count, lnet_process_id_t __user *ids_up,
+extern int lstcon_nodes_stat(int count, struct lnet_process_id __user *ids_up,
                             int timeout, struct list_head __user *result_up);
 extern int lstcon_test_add(char *batch_name, int type, int loop,
                           int concur, int dist, int span,
index d98f65e..da0c012 100644 (file)
@@ -913,7 +913,7 @@ sfw_test_rpc_done (srpc_client_rpc_t *rpc)
 }
 
 int
-sfw_create_test_rpc(sfw_test_unit_t *tsu, lnet_process_id_t peer,
+sfw_create_test_rpc(sfw_test_unit_t *tsu, struct lnet_process_id peer,
                    unsigned features, int nblk, int blklen,
                    srpc_client_rpc_t **rpcpp)
 {
@@ -1394,7 +1394,7 @@ sfw_bulk_ready(struct srpc_server_rpc *rpc, int status)
 }
 
 srpc_client_rpc_t *
-sfw_create_rpc(lnet_process_id_t peer, int service,
+sfw_create_rpc(struct lnet_process_id peer, int service,
               unsigned features, int nbulkiov, int bulklen,
               void (*done)(srpc_client_rpc_t *), void *priv)
 {
index 4d188ed..ea20761 100644 (file)
@@ -83,7 +83,7 @@ ping_client_fini (sfw_test_instance_t *tsi)
 
 static int
 ping_client_prep_rpc(sfw_test_unit_t *tsu,
-                    lnet_process_id_t dest, srpc_client_rpc_t **rpc)
+                    struct lnet_process_id dest, srpc_client_rpc_t **rpc)
 {
        srpc_ping_reqst_t   *req;
        sfw_test_instance_t *tsi = tsu->tsu_instance;
index 4079698..80b6df5 100644 (file)
@@ -53,7 +53,7 @@ typedef enum {
 static struct smoketest_rpc {
        spinlock_t       rpc_glock;     /* global lock */
        srpc_service_t  *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 */
        srpc_state_t     rpc_state;
        struct srpc_counters     rpc_counters;
        __u64            rpc_matchbits; /* matchbits counter */
@@ -184,7 +184,7 @@ srpc_init_server_rpc(struct srpc_server_rpc *rpc,
        rpc->srpc_reqstbuf = buffer;
        rpc->srpc_peer     = buffer->buf_peer;
        rpc->srpc_self     = buffer->buf_self;
-       LNetInvalidateHandle(&rpc->srpc_replymdh);
+       LNetInvalidateMDHandle(&rpc->srpc_replymdh);
 }
 
 static void
@@ -351,12 +351,12 @@ srpc_remove_service (srpc_service_t *sv)
 
 static int
 srpc_post_passive_rdma(int portal, int local, __u64 matchbits, void *buf,
-                      int len, int options, lnet_process_id_t peer,
-                      lnet_handle_md_t *mdh, srpc_event_t *ev)
+                      int len, int options, struct lnet_process_id peer,
+                      struct lnet_handle_md *mdh, srpc_event_t *ev)
 {
        int              rc;
-       lnet_md_t        md;
-       lnet_handle_me_t meh;
+       struct lnet_md   md;
+       struct lnet_handle_me meh;
 
        rc = LNetMEAttach(portal, peer, matchbits, 0, LNET_UNLINK,
                          local ? LNET_INS_LOCAL : LNET_INS_AFTER, &meh);
@@ -391,11 +391,11 @@ srpc_post_passive_rdma(int portal, int local, __u64 matchbits, void *buf,
 
 static int
 srpc_post_active_rdma(int portal, __u64 matchbits, void *buf, int len,
-                      int options, lnet_process_id_t peer, lnet_nid_t self,
-                      lnet_handle_md_t *mdh, srpc_event_t *ev)
+                     int options, struct lnet_process_id peer, lnet_nid_t self,
+                     struct lnet_handle_md *mdh, srpc_event_t *ev)
 {
-        int       rc;
-        lnet_md_t md;
+       int rc;
+       struct lnet_md md;
 
         md.user_ptr  = ev;
         md.start     = buf;
@@ -443,9 +443,9 @@ srpc_post_active_rdma(int portal, __u64 matchbits, void *buf, int len,
 
 static int
 srpc_post_passive_rqtbuf(int service, int local, void *buf, int len,
-                        lnet_handle_md_t *mdh, srpc_event_t *ev)
+                        struct lnet_handle_md *mdh, srpc_event_t *ev)
 {
-       lnet_process_id_t any = {0};
+       struct lnet_process_id any = {0};
 
        any.nid = LNET_NID_ANY;
        any.pid = LNET_PID_ANY;
@@ -463,7 +463,7 @@ __must_hold(&scd->scd_lock)
        struct srpc_msg         *msg = &buf->buf_msg;
        int                     rc;
 
-       LNetInvalidateHandle(&buf->buf_mdh);
+       LNetInvalidateMDHandle(&buf->buf_mdh);
        list_add(&buf->buf_list, &scd->scd_buf_posted);
        scd->scd_buf_nposted++;
        spin_unlock(&scd->scd_lock);
@@ -1287,10 +1287,10 @@ abort:
 }
 
 srpc_client_rpc_t *
-srpc_create_client_rpc (lnet_process_id_t peer, int service,
-                        int nbulkiov, int bulklen,
-                        void (*rpc_done)(srpc_client_rpc_t *),
-                        void (*rpc_fini)(srpc_client_rpc_t *), void *priv)
+srpc_create_client_rpc(struct lnet_process_id peer, int service,
+                      int nbulkiov, int bulklen,
+                      void (*rpc_done)(srpc_client_rpc_t *),
+                      void (*rpc_fini)(srpc_client_rpc_t *), void *priv)
 {
         srpc_client_rpc_t *rpc;
 
@@ -1387,7 +1387,7 @@ srpc_send_reply(struct srpc_server_rpc *rpc)
 
 /* 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;
        srpc_event_t      *rpcev = ev->md.user_ptr;
@@ -1599,7 +1599,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 != 0) {
                 CERROR("LNetEQAlloc() has failed: %d\n", rc);
index 849aaea..aab2629 100644 (file)
@@ -161,7 +161,7 @@ typedef struct {
        struct lst_sid          str_sid;
        struct sfw_counters     str_fw;
        struct srpc_counters    str_rpc;
-        lnet_counters_t         str_lnet;
+       struct lnet_counters    str_lnet;
 } WIRE_ATTR srpc_stat_reply_t;
 
 typedef struct {
index b8c1e04..44bb2f8 100644 (file)
@@ -143,7 +143,7 @@ typedef enum {
 /* RPC event */
 typedef struct {
         srpc_event_type_t ev_type;   /* what's up */
-        lnet_event_kind_t ev_lnet;   /* LNet event type */
+       enum lnet_event_kind ev_lnet;   /* LNet event type */
         int               ev_fired;  /* LNet event fired? */
         int               ev_status; /* LNet event status */
         void             *ev_data;   /* owning server/client RPC */
@@ -151,7 +151,7 @@ typedef struct {
 
 typedef struct {
         int              bk_len;  /* len of bulk data */
-        lnet_handle_md_t bk_mdh;
+       struct lnet_handle_md bk_mdh;
         int              bk_sink; /* sink/source */
         int              bk_niov; /* # iov in bk_iovs */
         lnet_kiov_t      bk_iovs[0];
@@ -161,9 +161,9 @@ typedef struct {
 typedef struct srpc_buffer {
        struct list_head        buf_list; /* chain on srpc_service::*_msgq */
        srpc_msg_t              buf_msg;
-       lnet_handle_md_t        buf_mdh;
+       struct lnet_handle_md   buf_mdh;
        lnet_nid_t              buf_self;
-       lnet_process_id_t       buf_peer;
+       struct lnet_process_id  buf_peer;
 } srpc_buffer_t;
 
 struct swi_workitem;
@@ -184,9 +184,9 @@ typedef struct srpc_server_rpc {
        swi_workitem_t          srpc_wi;
        srpc_event_t            srpc_ev;        /* bulk/reply event */
        lnet_nid_t              srpc_self;
-       lnet_process_id_t       srpc_peer;
+       struct lnet_process_id  srpc_peer;
        srpc_msg_t              srpc_replymsg;
-       lnet_handle_md_t        srpc_replymdh;
+       struct lnet_handle_md   srpc_replymdh;
        srpc_buffer_t           *srpc_reqstbuf;
        srpc_bulk_t             *srpc_bulk;
 
@@ -205,7 +205,7 @@ typedef struct srpc_client_rpc {
        int                     crpc_timeout;
        stt_timer_t             crpc_timer;
        swi_workitem_t          crpc_wi;
-       lnet_process_id_t       crpc_dest;
+       struct lnet_process_id  crpc_dest;
 
         void               (*crpc_done)(struct srpc_client_rpc *);
         void               (*crpc_fini)(struct srpc_client_rpc *);
@@ -224,8 +224,8 @@ typedef struct srpc_client_rpc {
         /* bulk, request(reqst), and reply exchanged on wire */
         srpc_msg_t           crpc_reqstmsg;
         srpc_msg_t           crpc_replymsg;
-        lnet_handle_md_t     crpc_reqstmdh;
-        lnet_handle_md_t     crpc_replymdh;
+       struct lnet_handle_md   crpc_reqstmdh;
+       struct lnet_handle_md   crpc_replymdh;
         srpc_bulk_t          crpc_bulk;
 } srpc_client_rpc_t;
 
@@ -351,7 +351,7 @@ typedef struct {
         int  (*tso_init)(struct sfw_test_instance *tsi); /* intialize test client */
         void (*tso_fini)(struct sfw_test_instance *tsi); /* finalize test client */
         int  (*tso_prep_rpc)(struct sfw_test_unit *tsu,
-                             lnet_process_id_t dest,
+                            struct lnet_process_id dest,
                              srpc_client_rpc_t **rpc);   /* prep a tests rpc */
         void (*tso_done_rpc)(struct sfw_test_unit *tsu,
                              srpc_client_rpc_t *rpc);    /* done a test rpc */
@@ -384,7 +384,7 @@ typedef struct sfw_test_instance {
        } tsi_u;
 } sfw_test_instance_t;
 
-/* XXX: trailing (PAGE_SIZE % sizeof(lnet_process_id_t)) bytes at
+/* XXX: trailing (PAGE_SIZE % sizeof(struct lnet_process_id)) bytes at
  * the end of pages are not used */
 #define SFW_MAX_CONCUR     LST_MAX_CONCUR
 #define SFW_ID_PER_PAGE    (PAGE_SIZE / sizeof(struct lnet_process_id_packed))
@@ -393,7 +393,7 @@ typedef struct sfw_test_instance {
 
 typedef struct sfw_test_unit {
        struct list_head        tsu_list;       /* chain on lst_test_instance */
-       lnet_process_id_t       tsu_dest;       /* id of dest node */
+       struct lnet_process_id  tsu_dest;       /* id of dest node */
        int                     tsu_loop;       /* loop count of the test */
        sfw_test_instance_t     *tsu_instance;  /* pointer to test instance */
        void                    *tsu_private;   /* private data */
@@ -407,11 +407,11 @@ typedef struct sfw_test_case {
 } sfw_test_case_t;
 
 srpc_client_rpc_t *
-sfw_create_rpc(lnet_process_id_t peer, int service,
+sfw_create_rpc(struct lnet_process_id peer, int service,
               unsigned features, int nbulkiov, int bulklen,
               void (*done) (srpc_client_rpc_t *), void *priv);
 int sfw_create_test_rpc(sfw_test_unit_t *tsu,
-                       lnet_process_id_t peer, unsigned features,
+                       struct lnet_process_id peer, unsigned int features,
                        int nblk, int blklen, srpc_client_rpc_t **rpc);
 void sfw_abort_rpc(srpc_client_rpc_t *rpc);
 void sfw_post_rpc(srpc_client_rpc_t *rpc);
@@ -424,7 +424,7 @@ int sfw_alloc_pages(srpc_server_rpc_t *rpc, int cpt, int npages, int len,
 int sfw_make_session (srpc_mksn_reqst_t *request, srpc_mksn_reply_t *reply);
 
 srpc_client_rpc_t *
-srpc_create_client_rpc(lnet_process_id_t peer, int service,
+srpc_create_client_rpc(struct lnet_process_id peer, int service,
                        int nbulkiov, int bulklen,
                        void (*rpc_done)(srpc_client_rpc_t *),
                        void (*rpc_fini)(srpc_client_rpc_t *), void *priv);
@@ -512,7 +512,7 @@ srpc_destroy_client_rpc (srpc_client_rpc_t *rpc)
 }
 
 static inline void
-srpc_init_client_rpc(srpc_client_rpc_t *rpc, lnet_process_id_t peer,
+srpc_init_client_rpc(srpc_client_rpc_t *rpc, struct lnet_process_id peer,
                     int service, int nbulkiov, int bulklen,
                     void (*rpc_done)(srpc_client_rpc_t *),
                     void (*rpc_fini)(srpc_client_rpc_t *), void *priv)
@@ -535,9 +535,9 @@ srpc_init_client_rpc(srpc_client_rpc_t *rpc, lnet_process_id_t peer,
         rpc->crpc_bulk.bk_niov = nbulkiov;
         rpc->crpc_done         = rpc_done;
         rpc->crpc_fini         = rpc_fini;
-        LNetInvalidateHandle(&rpc->crpc_reqstmdh);
-        LNetInvalidateHandle(&rpc->crpc_replymdh);
-        LNetInvalidateHandle(&rpc->crpc_bulk.bk_mdh);
+       LNetInvalidateMDHandle(&rpc->crpc_reqstmdh);
+       LNetInvalidateMDHandle(&rpc->crpc_replymdh);
+       LNetInvalidateMDHandle(&rpc->crpc_bulk.bk_mdh);
 
         /* no event is expected at this point */
         rpc->crpc_bulkev.ev_fired  =
index 6d77a61..4a71575 100644 (file)
@@ -252,7 +252,7 @@ expand_strs(char *str, lstr_t **head)
 }
 
 int
-lst_parse_nids(char *str, int *countp, lnet_process_id_t **idspp)
+lst_parse_nids(char *str, int *countp, struct lnet_process_id **idspp)
 {
         lstr_t  *head = NULL;
         lstr_t  *l;
@@ -270,7 +270,7 @@ lst_parse_nids(char *str, int *countp, lnet_process_id_t **idspp)
                 c++;
         }
 
-        *idspp = malloc(c * sizeof(lnet_process_id_t));
+       *idspp = malloc(c * sizeof(struct lnet_process_id));
         if (*idspp == NULL) {
                 fprintf(stderr, "Out of memory\n");
                 rc = -1;
@@ -715,7 +715,7 @@ jt_lst_end_session(int argc, char **argv)
 
 int
 lst_ping_ioctl(char *str, int type, int timeout,
-              int count, lnet_process_id_t *ids, struct list_head *head)
+              int count, struct lnet_process_id *ids, struct list_head *head)
 {
        struct lstio_debug_args args = { 0 };
 
@@ -733,7 +733,8 @@ lst_ping_ioctl(char *str, int type, int timeout,
 }
 
 int
-lst_get_node_count(int type, char *str, int *countp, lnet_process_id_t **idspp)
+lst_get_node_count(int type, char *str, int *countp,
+                  struct lnet_process_id **idspp)
 {
         char                    buf[LST_NAME_SIZE];
        struct lstcon_test_batch_ent ent;
@@ -778,7 +779,7 @@ int
 jt_lst_ping(int argc,  char **argv)
 {
        struct list_head   head;
-       lnet_process_id_t *ids = NULL;
+       struct lnet_process_id *ids = NULL;
        struct lstcon_rpc_ent  *ent = NULL;
        char              *str = NULL;
        int                optidx  = 0;
@@ -907,7 +908,7 @@ out:
 }
 
 int
-lst_add_nodes_ioctl(char *name, int count, lnet_process_id_t *ids,
+lst_add_nodes_ioctl(char *name, int count, struct lnet_process_id *ids,
                    unsigned *featp, struct list_head *resultp)
 {
        struct lstio_group_nodes_args args = { 0 };
@@ -987,7 +988,7 @@ int
 jt_lst_add_group(int argc, char **argv)
 {
        struct list_head   head;
-       lnet_process_id_t *ids;
+       struct lnet_process_id *ids;
        char              *name;
        unsigned           feats = session_features;
        int                count;
@@ -1138,7 +1139,7 @@ jt_lst_del_group(int argc, char **argv)
 
 int
 lst_update_group_ioctl(int opc, char *name, int clean, int count,
-                      lnet_process_id_t *ids, struct list_head *resultp)
+                      struct lnet_process_id *ids, struct list_head *resultp)
 {
        struct lstio_group_update_args args = { 0 };
 
@@ -1158,7 +1159,7 @@ int
 jt_lst_update_group(int argc, char **argv)
 {
        struct list_head   head;
-       lnet_process_id_t *ids = NULL;
+       struct lnet_process_id *ids = NULL;
        char              *str = NULL;
        char              *grp = NULL;
        int                optidx = 0;
@@ -1483,8 +1484,8 @@ jt_lst_list_group(int argc, char **argv)
 }
 
 int
-lst_stat_ioctl (char *name, int count, lnet_process_id_t *idsp,
-               int timeout, struct list_head *resultp)
+lst_stat_ioctl(char *name, int count, struct lnet_process_id *idsp,
+              int timeout, struct list_head *resultp)
 {
        struct lstio_stat_args args = { 0 };
 
@@ -1503,7 +1504,7 @@ typedef struct {
        struct list_head              srp_link;
         int                     srp_count;
         char                   *srp_name;
-        lnet_process_id_t      *srp_ids;
+       struct lnet_process_id      *srp_ids;
        struct list_head              srp_result[2];
 } lst_stat_req_param_t;
 
@@ -1559,7 +1560,7 @@ lst_stat_req_param_alloc(char *name, lst_stat_req_param_t **srpp, int save_old)
                 rc = lst_alloc_rpcent(&srp->srp_result[i], srp->srp_count,
                                      sizeof(struct sfw_counters)  +
                                      sizeof(struct srpc_counters) +
-                                      sizeof(lnet_counters_t));
+                                     sizeof(struct lnet_counters));
                 if (rc != 0) {
                         fprintf(stderr, "Out of memory\n");
                         break;
@@ -1644,8 +1645,8 @@ lst_timeval_diff(struct timeval *tv1,
 }
 
 static void
-lst_cal_lnet_stat(float delta, lnet_counters_t *lnet_new,
-                 lnet_counters_t *lnet_old, int mbs)
+lst_cal_lnet_stat(float delta, struct lnet_counters *lnet_new,
+                 struct lnet_counters *lnet_old, int mbs)
 {
        float perf;
        float rate;
@@ -1777,8 +1778,8 @@ lst_print_stat(char *name, struct list_head *resultp,
        struct sfw_counters   *sfwk_old;
        struct srpc_counters  *srpc_new;
        struct srpc_counters  *srpc_old;
-        lnet_counters_t  *lnet_new;
-        lnet_counters_t  *lnet_old;
+       struct lnet_counters  *lnet_new;
+       struct lnet_counters  *lnet_old;
         float             delta;
         int               errcount = 0;
 
@@ -1826,8 +1827,8 @@ lst_print_stat(char *name, struct list_head *resultp,
                srpc_new = (struct srpc_counters *)((char *)sfwk_new + sizeof(*sfwk_new));
                srpc_old = (struct srpc_counters *)((char *)sfwk_old + sizeof(*sfwk_old));
 
-                lnet_new = (lnet_counters_t *)((char *)srpc_new + sizeof(*srpc_new));
-                lnet_old = (lnet_counters_t *)((char *)srpc_old + sizeof(*srpc_old));
+               lnet_new = (struct lnet_counters *)((char *)srpc_new + sizeof(*srpc_new));
+               lnet_old = (struct lnet_counters *)((char *)srpc_old + sizeof(*srpc_old));
 
                /* Prior to version 2.3, the running_ms field was a counter for
                 * the number of running tests.  We are looking at this value
index c599740..808f90f 100644 (file)
@@ -218,7 +218,7 @@ lnet_parse_time (time_t *t, char *str)
 }
 
 int
-lnet_parse_nid(char *nid_str, lnet_process_id_t *id_ptr)
+lnet_parse_nid(char *nid_str, struct lnet_process_id *id_ptr)
 {
         id_ptr->pid = LNET_PID_ANY;
         id_ptr->nid = libcfs_str2nid(nid_str);
@@ -586,7 +586,7 @@ int
 jt_ptl_print_peers (int argc, char **argv)
 {
        struct libcfs_ioctl_data data;
-       lnet_process_id_t        id;
+       struct lnet_process_id        id;
        char                     buffer[2][HOST_NAME_MAX + 1];
        int                      index;
        int                      rc;
@@ -762,7 +762,7 @@ int
 jt_ptl_print_connections (int argc, char **argv)
 {
         struct libcfs_ioctl_data data;
-        lnet_process_id_t        id;
+       struct lnet_process_id        id;
        char                     buffer[2][HOST_NAME_MAX + 1];
         int                      index;
         int                      rc;
@@ -905,8 +905,8 @@ int jt_ptl_ping(int argc, char **argv)
 {
         int                      rc;
         int                      timeout;
-        lnet_process_id_t        id;
-        lnet_process_id_t        ids[16];
+       struct lnet_process_id id;
+       struct lnet_process_id ids[16];
         int                      maxids = sizeof(ids)/sizeof(ids[0]);
         struct libcfs_ioctl_data data;
         char                    *sep;
index 2d5d1b2..ad8c6b1 100644 (file)
@@ -103,54 +103,54 @@ check_lnet_handle_wire(void)
 void
 check_lnet_magicversion (void)
 {
-        CHECK_STRUCT (lnet_magicversion_t);
-        CHECK_MEMBER (lnet_magicversion_t, magic);
-        CHECK_MEMBER (lnet_magicversion_t, version_major);
-        CHECK_MEMBER (lnet_magicversion_t, version_minor);
+       CHECK_STRUCT(struct lnet_magicversion);
+       CHECK_MEMBER(struct lnet_magicversion, magic);
+       CHECK_MEMBER(struct lnet_magicversion, version_major);
+       CHECK_MEMBER(struct lnet_magicversion, version_minor);
 }
 
 void
 check_lnet_hdr (void)
 {
-        CHECK_STRUCT (lnet_hdr_t);
-        CHECK_MEMBER (lnet_hdr_t, dest_nid);
-        CHECK_MEMBER (lnet_hdr_t, src_nid);
-        CHECK_MEMBER (lnet_hdr_t, dest_pid);
-        CHECK_MEMBER (lnet_hdr_t, src_pid);
-        CHECK_MEMBER (lnet_hdr_t, type);
-        CHECK_MEMBER (lnet_hdr_t, payload_length);
-        CHECK_MEMBER (lnet_hdr_t, msg);
+       CHECK_STRUCT(struct lnet_hdr);
+       CHECK_MEMBER(struct lnet_hdr, dest_nid);
+       CHECK_MEMBER(struct lnet_hdr, src_nid);
+       CHECK_MEMBER(struct lnet_hdr, dest_pid);
+       CHECK_MEMBER(struct lnet_hdr, src_pid);
+       CHECK_MEMBER(struct lnet_hdr, type);
+       CHECK_MEMBER(struct lnet_hdr, payload_length);
+       CHECK_MEMBER(struct lnet_hdr, msg);
 
         BLANK_LINE ();
         COMMENT ("Ack");
-        CHECK_MEMBER (lnet_hdr_t, msg.ack.dst_wmd);
-        CHECK_MEMBER (lnet_hdr_t, msg.ack.match_bits);
-        CHECK_MEMBER (lnet_hdr_t, msg.ack.mlength);
+       CHECK_MEMBER(struct lnet_hdr, msg.ack.dst_wmd);
+       CHECK_MEMBER(struct lnet_hdr, msg.ack.match_bits);
+       CHECK_MEMBER(struct lnet_hdr, msg.ack.mlength);
 
         BLANK_LINE ();
         COMMENT ("Put");
-        CHECK_MEMBER (lnet_hdr_t, msg.put.ack_wmd);
-        CHECK_MEMBER (lnet_hdr_t, msg.put.match_bits);
-        CHECK_MEMBER (lnet_hdr_t, msg.put.hdr_data);
-        CHECK_MEMBER (lnet_hdr_t, msg.put.ptl_index);
-        CHECK_MEMBER (lnet_hdr_t, msg.put.offset);
+       CHECK_MEMBER(struct lnet_hdr, msg.put.ack_wmd);
+       CHECK_MEMBER(struct lnet_hdr, msg.put.match_bits);
+       CHECK_MEMBER(struct lnet_hdr, msg.put.hdr_data);
+       CHECK_MEMBER(struct lnet_hdr, msg.put.ptl_index);
+       CHECK_MEMBER(struct lnet_hdr, msg.put.offset);
 
         BLANK_LINE ();
         COMMENT ("Get");
-        CHECK_MEMBER (lnet_hdr_t, msg.get.return_wmd);
-        CHECK_MEMBER (lnet_hdr_t, msg.get.match_bits);
-        CHECK_MEMBER (lnet_hdr_t, msg.get.ptl_index);
-        CHECK_MEMBER (lnet_hdr_t, msg.get.src_offset);
-        CHECK_MEMBER (lnet_hdr_t, msg.get.sink_length);
+       CHECK_MEMBER(struct lnet_hdr, msg.get.return_wmd);
+       CHECK_MEMBER(struct lnet_hdr, msg.get.match_bits);
+       CHECK_MEMBER(struct lnet_hdr, msg.get.ptl_index);
+       CHECK_MEMBER(struct lnet_hdr, msg.get.src_offset);
+       CHECK_MEMBER(struct lnet_hdr, msg.get.sink_length);
 
         BLANK_LINE ();
         COMMENT ("Reply");
-        CHECK_MEMBER (lnet_hdr_t, msg.reply.dst_wmd);
+       CHECK_MEMBER(struct lnet_hdr, msg.reply.dst_wmd);
 
         BLANK_LINE ();
         COMMENT ("Hello");
-        CHECK_MEMBER (lnet_hdr_t, msg.hello.incarnation);
-        CHECK_MEMBER (lnet_hdr_t, msg.hello.type);
+       CHECK_MEMBER(struct lnet_hdr, msg.hello.incarnation);
+       CHECK_MEMBER(struct lnet_hdr, msg.hello.type);
 }
 
 void
index 3c1f595..ef5e7ba 100644 (file)
@@ -514,7 +514,7 @@ struct ptlrpc_connection {
        /** Our own lnet nid for this connection */
        lnet_nid_t              c_self;
        /** Remote side nid for this connection */
-       lnet_process_id_t       c_peer;
+       struct lnet_process_id       c_peer;
        /** UUID of the other side */
        struct obd_uuid         c_remote_uuid;
        /** reference counter for this connection */
@@ -627,8 +627,8 @@ struct ptlrpc_service;
  * ptlrpc callback & work item stuff
  */
 struct ptlrpc_cb_id {
-        void   (*cbid_fn)(lnet_event_t *ev);     /* specific callback fn */
-        void    *cbid_arg;                      /* additional arg */
+       void (*cbid_fn)(struct lnet_event *ev); /* specific callback fn */
+       void *cbid_arg;                         /* additional arg */
 };
 
 /** Maximum number of locks to fit into reply state */
@@ -683,7 +683,7 @@ struct ptlrpc_reply_state {
        struct obd_export     *rs_export;
        struct ptlrpc_service_part *rs_svcpt;
        /** Lnet metadata handle for the reply */
-       lnet_handle_md_t        rs_md_h;
+       struct lnet_handle_md   rs_md_h;
 
        /** Context for the sevice thread */
        struct ptlrpc_svc_ctx   *rs_svc_ctx;
@@ -815,11 +815,11 @@ struct ptlrpc_cli_req {
        /** Link back to the request set */
        struct ptlrpc_request_set       *cr_set;
        /** outgoing request MD handle */
-       lnet_handle_md_t                 cr_req_md_h;
+       struct lnet_handle_md            cr_req_md_h;
        /** request-out callback parameter */
        struct ptlrpc_cb_id              cr_req_cbid;
        /** incoming reply MD handle */
-       lnet_handle_md_t                 cr_reply_md_h;
+       struct lnet_handle_md            cr_reply_md_h;
        wait_queue_head_t                cr_reply_waitq;
        /** reply callback parameter */
        struct ptlrpc_cb_id              cr_reply_cbid;
@@ -1104,9 +1104,9 @@ struct ptlrpc_request {
        /** our LNet NID */
        lnet_nid_t                       rq_self;
        /** Peer description (the other side) */
-       lnet_process_id_t                rq_peer;
+       struct lnet_process_id           rq_peer;
        /** Descriptor for the NID from which the peer sent the request. */
-       lnet_process_id_t                rq_source;
+       struct lnet_process_id           rq_source;
        /**
         * service time estimate (secs)
         * If the request is not served by this time, it is marked as timed out.
@@ -1465,7 +1465,7 @@ struct ptlrpc_bulk_desc {
        int                     bd_md_count;    /* # valid entries in bd_mds */
        int                     bd_md_max_brw;  /* max entries in bd_mds */
        /** array of associated MDs */
-       lnet_handle_md_t        bd_mds[PTLRPC_BULK_OPS_COUNT];
+       struct lnet_handle_md   bd_mds[PTLRPC_BULK_OPS_COUNT];
 
        union {
                struct {
@@ -1612,7 +1612,7 @@ struct ptlrpc_request_buffer_desc {
        /** Back pointer to service for which this buffer is registered */
        struct ptlrpc_service_part      *rqbd_svcpt;
        /** LNet descriptor */
-       lnet_handle_md_t                rqbd_md_h;
+       struct lnet_handle_md           rqbd_md_h;
        int                             rqbd_refcount;
        /** The buffer itself */
        char                            *rqbd_buffer;
@@ -1981,26 +1981,26 @@ 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;
 extern int ptlrpc_uuid_to_peer(struct obd_uuid *uuid,
-                               lnet_process_id_t *peer, lnet_nid_t *self);
+                              struct lnet_process_id *peer, lnet_nid_t *self);
 /**
  * These callbacks are invoked by LNet when something happened to
  * underlying buffer
  * @{
  */
-extern void request_out_callback(lnet_event_t *ev);
-extern void reply_in_callback(lnet_event_t *ev);
-extern void client_bulk_callback(lnet_event_t *ev);
-extern void request_in_callback(lnet_event_t *ev);
-extern void reply_out_callback(lnet_event_t *ev);
+extern void request_out_callback(struct lnet_event *ev);
+extern void reply_in_callback(struct lnet_event *ev);
+extern void client_bulk_callback(struct lnet_event *ev);
+extern void request_in_callback(struct lnet_event *ev);
+extern void reply_out_callback(struct lnet_event *ev);
 #ifdef HAVE_SERVER_SUPPORT
-extern void server_bulk_callback(lnet_event_t *ev);
+extern void server_bulk_callback(struct lnet_event *ev);
 #endif
 /** @} */
 
 /* ptlrpc/connection.c */
-struct ptlrpc_connection *ptlrpc_connection_get(lnet_process_id_t peer,
+struct ptlrpc_connection *ptlrpc_connection_get(struct lnet_process_id peer,
                                                 lnet_nid_t self,
                                                 struct obd_uuid *uuid);
 int ptlrpc_connection_put(struct ptlrpc_connection *c);
index 8fd0d01..d5db5bf 100644 (file)
@@ -657,7 +657,7 @@ static int ldlm_handle_ast_error(struct ldlm_lock *lock,
                                 struct ptlrpc_request *req, int rc,
                                 const char *ast_type)
 {
-       lnet_process_id_t peer = req->rq_import->imp_connection->c_peer;
+       struct lnet_process_id peer = req->rq_import->imp_connection->c_peer;
 
        if (!req->rq_replied || (rc && rc != -EINVAL)) {
                if (lock->l_export && lock->l_export->exp_libclient) {
index f750a12..f1379d4 100644 (file)
@@ -2664,7 +2664,7 @@ void ll_compute_rootsquash_state(struct ll_sb_info *sbi)
        struct root_squash_info *squash = &sbi->ll_squash;
        int i;
        bool matched;
-       lnet_process_id_t id;
+       struct lnet_process_id id;
 
        /* Update norootsquash flag */
        down_write(&squash->rsi_sem);
index 3b9f748..0ce2675 100644 (file)
@@ -101,7 +101,7 @@ void lustre_register_client_process_config(int (*cpc)(struct lustre_cfg *lcfg));
 static int __init lustre_init(void)
 {
        struct proc_dir_entry *entry;
-       lnet_process_id_t lnet_id;
+       struct lnet_process_id lnet_id;
        struct timespec64 ts;
        int i, rc, seed[2];
 
index ab7b6ba..60acd41 100644 (file)
@@ -236,7 +236,8 @@ int lustre_start_mgc(struct super_block *sb)
                    (class_parse_nid(lsi->lsi_lmd->lmd_mgs, &nid, &ptr) == 0)) {
                        i++;
                } else if (IS_MGS(lsi)) {
-                        lnet_process_id_t id;
+                       struct lnet_process_id id;
+
                         while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
                                 if (LNET_NETTYP(LNET_NIDNET(id.nid)) == LOLND)
                                         continue;
@@ -342,7 +343,8 @@ int lustre_start_mgc(struct super_block *sb)
                CDEBUG(D_MOUNT, "mgs nids %s.\n", ptr);
                if (IS_MGS(lsi)) {
                        /* Use local nids (including LO) */
-                       lnet_process_id_t id;
+                       struct lnet_process_id id;
+
                        while ((rc = LNetGetId(i++, &id)) != -ENOENT) {
                                rc = do_lcfg(mgcname, id.nid, LCFG_ADD_UUID,
                                             niduuid, NULL, NULL, NULL);
index da64534..c1f50cb 100644 (file)
@@ -1094,7 +1094,7 @@ int server_mti_print(const char *title, struct mgs_target_info *mti)
 static int server_lsi2mti(struct lustre_sb_info *lsi,
                          struct mgs_target_info *mti)
 {
-       lnet_process_id_t id;
+       struct lnet_process_id id;
        int rc, i = 0;
        int cplen = 0;
        ENTRY;
index 3938d60..a92a135 100644 (file)
@@ -1311,10 +1311,11 @@ osc_brw_prep_request(int cmd, struct client_obd *cli, struct obdo *oa,
         RETURN(rc);
 }
 
-static int check_write_checksum(struct obdo *oa, const lnet_process_id_t *peer,
-                               __u32 client_cksum, __u32 server_cksum, int nob,
-                               size_t page_count, struct brw_page **pga,
-                               cksum_type_t client_cksum_type)
+static int
+check_write_checksum(struct obdo *oa, const struct lnet_process_id *peer,
+                    __u32 client_cksum, __u32 server_cksum, int nob,
+                    size_t page_count, struct brw_page **pga,
+                    cksum_type_t client_cksum_type)
 {
         __u32 new_cksum;
         char *msg;
@@ -1360,7 +1361,7 @@ static int check_write_checksum(struct obdo *oa, const lnet_process_id_t *peer,
 static int osc_brw_fini_request(struct ptlrpc_request *req, int rc)
 {
         struct osc_brw_async_args *aa = (void *)&req->rq_async_args;
-        const lnet_process_id_t *peer =
+       const struct lnet_process_id *peer =
                         &req->rq_import->imp_connection->c_peer;
         struct client_obd *cli = aa->aa_cli;
         struct ost_body *body;
index 27e4dca..8660a82 100644 (file)
@@ -84,7 +84,7 @@ struct ptlrpc_connection *ptlrpc_uuid_to_connection(struct obd_uuid *uuid,
 {
        struct ptlrpc_connection *c;
        lnet_nid_t                self;
-       lnet_process_id_t         peer;
+       struct lnet_process_id peer;
        int                       err;
 
        /* ptlrpc_uuid_to_peer() initializes its 2nd parameter
@@ -154,7 +154,7 @@ struct ptlrpc_bulk_desc *ptlrpc_new_bulk(unsigned nfrags, unsigned max_brw,
        /* PTLRPC_BULK_OPS_COUNT is the compile-time transfer limit for this
         * node. Negotiated ocd_brw_size will always be <= this number. */
        for (i = 0; i < PTLRPC_BULK_OPS_COUNT; i++)
-               LNetInvalidateHandle(&desc->bd_mds[i]);
+               LNetInvalidateMDHandle(&desc->bd_mds[i]);
 
        return desc;
 out:
index 8aaf5a4..369eace 100644 (file)
@@ -41,7 +41,7 @@ static struct cfs_hash *conn_hash;
 static struct cfs_hash_ops conn_hash_ops;
 
 struct ptlrpc_connection *
-ptlrpc_connection_get(lnet_process_id_t peer, lnet_nid_t self,
+ptlrpc_connection_get(struct lnet_process_id peer, lnet_nid_t self,
                      struct obd_uuid *uuid)
 {
        struct ptlrpc_connection *conn, *conn2;
@@ -163,17 +163,17 @@ void ptlrpc_connection_fini(void) {
 static unsigned
 conn_hashfn(struct cfs_hash *hs, const void *key, unsigned mask)
 {
-       return cfs_hash_djb2_hash(key, sizeof(lnet_process_id_t), mask);
+       return cfs_hash_djb2_hash(key, sizeof(struct lnet_process_id), mask);
 }
 
 static int
 conn_keycmp(const void *key, struct hlist_node *hnode)
 {
        struct ptlrpc_connection *conn;
-       const lnet_process_id_t *conn_key;
+       const struct lnet_process_id *conn_key;
 
        LASSERT(key != NULL);
-       conn_key = (lnet_process_id_t *)key;
+       conn_key = (struct lnet_process_id *)key;
        conn = hlist_entry(hnode, struct ptlrpc_connection, c_hash);
 
        return conn_key->nid == conn->c_peer.nid &&
index 2982837..f239908 100644 (file)
 #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
  */
-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;
@@ -84,7 +84,7 @@ void request_out_callback(lnet_event_t *ev)
 /*
  * 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;
@@ -174,7 +174,7 @@ out_wake:
 /*
  * 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;
@@ -284,7 +284,7 @@ static void ptlrpc_req_add_history(struct ptlrpc_serv