#include <portals/types.h>
-ptl_err_t PtlInit(int *);
+ptl_err_t LNetInit(int *);
-void PtlFini(void);
+void LNetFini(void);
-ptl_err_t PtlNIInit(ptl_interface_t interface,
+ptl_err_t LNetNIInit(ptl_interface_t interface,
ptl_pid_t requested_pid,
ptl_ni_limits_t *desired_limits,
ptl_ni_limits_t *actual_limits,
ptl_handle_ni_t *interface_out);
-ptl_err_t PtlNIInitialized(ptl_interface_t);
+ptl_err_t LNetNIInitialized(ptl_interface_t);
-ptl_err_t PtlNIFini(ptl_handle_ni_t interface_in);
+ptl_err_t LNetNIFini(ptl_handle_ni_t interface_in);
-ptl_err_t PtlGetId(ptl_handle_ni_t ni_handle,
+ptl_err_t LNetGetId(ptl_handle_ni_t ni_handle,
ptl_process_id_t *id);
-ptl_err_t PtlGetUid(ptl_handle_ni_t ni_handle,
+ptl_err_t LNetGetUid(ptl_handle_ni_t ni_handle,
ptl_uid_t *uid);
/*
* Network interfaces
*/
-ptl_err_t PtlNIStatus(ptl_handle_ni_t interface_in,
+ptl_err_t LNetNIStatus(ptl_handle_ni_t interface_in,
ptl_sr_index_t register_in,
ptl_sr_value_t *status_out);
-ptl_err_t PtlNIDist(ptl_handle_ni_t interface_in,
+ptl_err_t LNetNIDist(ptl_handle_ni_t interface_in,
ptl_process_id_t process_in,
unsigned long *distance_out);
-ptl_err_t PtlNIHandle(ptl_handle_any_t handle_in,
+ptl_err_t LNetNIHandle(ptl_handle_any_t handle_in,
ptl_handle_ni_t *interface_out);
/*
- * PtlFailNid
+ * LNetFailNid
*
* Not an official Portals 3 API call. It provides a way of calling
* network-specific functions
*/
-int PtlNICtl(ptl_handle_ni_t interface, unsigned int cmd, void *arg);
+int LNetNICtl(ptl_handle_ni_t interface, unsigned int cmd, void *arg);
/*
- * PtlSnprintHandle:
+ * LNetSnprintHandle:
*
* This is not an official Portals 3 API call. It is provided
* so that an application can print an opaque handle.
*/
-void PtlSnprintHandle (char *str, int str_len, ptl_handle_any_t handle);
+void LNetSnprintHandle (char *str, int str_len, ptl_handle_any_t handle);
/*
* Match entries
*/
-ptl_err_t PtlMEAttach(ptl_handle_ni_t interface_in,
+ptl_err_t LNetMEAttach(ptl_handle_ni_t interface_in,
ptl_pt_index_t index_in,
ptl_process_id_t match_id_in,
ptl_match_bits_t match_bits_in,
ptl_ins_pos_t pos_in,
ptl_handle_me_t *handle_out);
-ptl_err_t PtlMEInsert(ptl_handle_me_t current_in,
+ptl_err_t LNetMEInsert(ptl_handle_me_t current_in,
ptl_process_id_t match_id_in,
ptl_match_bits_t match_bits_in,
ptl_match_bits_t ignore_bits_in,
ptl_ins_pos_t position_in,
ptl_handle_me_t *handle_out);
-ptl_err_t PtlMEUnlink(ptl_handle_me_t current_in);
+ptl_err_t LNetMEUnlink(ptl_handle_me_t current_in);
/*
* Memory descriptors
*/
-ptl_err_t PtlMDAttach(ptl_handle_me_t current_in,
+ptl_err_t LNetMDAttach(ptl_handle_me_t current_in,
ptl_md_t md_in,
ptl_unlink_t unlink_in,
ptl_handle_md_t *handle_out);
-ptl_err_t PtlMDBind(ptl_handle_ni_t ni_in,
+ptl_err_t LNetMDBind(ptl_handle_ni_t ni_in,
ptl_md_t md_in,
ptl_unlink_t unlink_in,
ptl_handle_md_t *handle_out);
-ptl_err_t PtlMDUnlink(ptl_handle_md_t md_in);
-
-ptl_err_t PtlMDUpdate(ptl_handle_md_t md_in,
- ptl_md_t *old_inout,
- ptl_md_t *new_inout,
- ptl_handle_eq_t testq_in);
+ptl_err_t LNetMDUnlink(ptl_handle_md_t md_in);
/*
* Event queues
*/
-ptl_err_t PtlEQAlloc(ptl_handle_ni_t ni_in,
+ptl_err_t LNetEQAlloc(ptl_handle_ni_t ni_in,
ptl_size_t count_in,
ptl_eq_handler_t handler,
ptl_handle_eq_t *handle_out);
-ptl_err_t PtlEQFree(ptl_handle_eq_t eventq_in);
+ptl_err_t LNetEQFree(ptl_handle_eq_t eventq_in);
-ptl_err_t PtlEQGet(ptl_handle_eq_t eventq_in,
+ptl_err_t LNetEQGet(ptl_handle_eq_t eventq_in,
ptl_event_t *event_out);
-ptl_err_t PtlEQWait(ptl_handle_eq_t eventq_in,
+ptl_err_t LNetEQWait(ptl_handle_eq_t eventq_in,
ptl_event_t *event_out);
-ptl_err_t PtlEQPoll(ptl_handle_eq_t *eventqs_in,
+ptl_err_t LNetEQPoll(ptl_handle_eq_t *eventqs_in,
int neq_in,
int timeout_ms,
ptl_event_t *event_out,
/*
* Access Control Table
*/
-ptl_err_t PtlACEntry(ptl_handle_ni_t ni_in,
+ptl_err_t LNetACEntry(ptl_handle_ni_t ni_in,
ptl_ac_index_t index_in,
ptl_process_id_t match_id_in,
ptl_pt_index_t portal_in);
/*
* Data movement
*/
-ptl_err_t PtlPut(ptl_handle_md_t md_in,
+ptl_err_t LNetPut(ptl_handle_md_t md_in,
ptl_ack_req_t ack_req_in,
ptl_process_id_t target_in,
ptl_pt_index_t portal_in,
ptl_size_t offset_in,
ptl_hdr_data_t hdr_data_in);
-ptl_err_t PtlGet(ptl_handle_md_t md_in,
+ptl_err_t LNetGet(ptl_handle_md_t md_in,
ptl_process_id_t target_in,
ptl_pt_index_t portal_in,
ptl_ac_index_t cookie_in,
typedef struct
{
- /* Stuff initialised at PtlInit() */
- int apini_init; /* PtlInit() called? */
- int apini_refcount; /* PtlNIInit/PtlNIFini counter */
- int apini_niinit_self; /* Have I called PtlNIInit myself? */
+ /* Stuff initialised at LNetInit() */
+ int apini_init; /* LNetInit() called? */
+ int apini_refcount; /* LNetNIInit/LNetNIFini counter */
+ int apini_niinit_self; /* Have I called LNetNIInit myself? */
struct list_head apini_nals; /* registered NALs */
pthread_mutex_t apini_nal_mutex;
#endif
- /* Stuff initialised at PtlNIInit() */
+ /* Stuff initialised at LNetNIInit() */
int apini_nportals; /* # portals */
struct list_head *apini_portals; /* the vector of portals */
((const ptl_handle_any_t){.cookie = -1})
#define PTL_EQ_NONE PTL_INVALID_HANDLE
-static inline int PtlHandleIsEqual (ptl_handle_any_t h1, ptl_handle_any_t h2)
+static inline int LNetHandleIsEqual (ptl_handle_any_t h1, ptl_handle_any_t h2)
{
return (h1.cookie == h2.cookie);
}
ptl_apini.apini_actual_limits.max_md_iovecs = PTL_MD_MAX_IOV;
ptl_apini.apini_actual_limits.max_me_list = INT_MAX;
- /* We don't support PtlGetPut! */
+ /* We don't support LNetGetPut! */
ptl_apini.apini_actual_limits.max_getput_md = 0;
if (actual_limits != NULL)
#endif
ptl_err_t
-PtlInit(int *max_interfaces)
+LNetInit(int *max_interfaces)
{
LASSERT(!strcmp(ptl_err_str[PTL_MAX_ERRNO], "PTL_MAX_ERRNO"));
ptl_assert_wire_constants ();
}
void
-PtlFini(void)
+LNetFini(void)
{
LASSERT (ptl_apini.apini_init);
LASSERT (ptl_apini.apini_refcount == 0);
}
ptl_err_t
-PtlNIInit(ptl_interface_t interface, ptl_pid_t requested_pid,
+LNetNIInit(ptl_interface_t interface, ptl_pid_t requested_pid,
ptl_ni_limits_t *requested_limits, ptl_ni_limits_t *actual_limits,
ptl_handle_ni_t *handle)
{
ptl_apini.apini_refcount = 1;
memset (handle, 0, sizeof(*handle));
- LASSERT (!PtlHandleIsEqual(*handle, PTL_INVALID_HANDLE));
+ LASSERT (!LNetHandleIsEqual(*handle, PTL_INVALID_HANDLE));
/* Handle can be anything; PTL_INVALID_HANDLE isn't wise though :) */
out:
}
ptl_err_t
-PtlNIFini(ptl_handle_ni_t ni)
+LNetNIFini(ptl_handle_ni_t ni)
{
PTL_MUTEX_DOWN(&ptl_apini.apini_api_mutex);
}
int
-PtlNICtl(ptl_handle_ni_t nih, unsigned int cmd, void *arg)
+LNetNICtl(ptl_handle_ni_t nih, unsigned int cmd, void *arg)
{
struct portal_ioctl_data *data = arg;
struct list_head *tmp;
}
ptl_err_t
-PtlGetId(ptl_handle_ni_t ni_handle, ptl_process_id_t *id)
+LNetGetId(ptl_handle_ni_t ni_handle, ptl_process_id_t *id)
{
ptl_ni_t *ni;
unsigned long flags;
}
ptl_err_t
-PtlNIHandle(ptl_handle_any_t handle_in, ptl_handle_ni_t *ni_out)
+LNetNIHandle(ptl_handle_any_t handle_in, ptl_handle_ni_t *ni_out)
{
LASSERT (ptl_apini.apini_init);
LASSERT (ptl_apini.apini_refcount > 0);
}
void
-PtlSnprintHandle(char *str, int len, ptl_handle_any_t h)
+LNetSnprintHandle(char *str, int len, ptl_handle_any_t h)
{
snprintf(str, len, LPX64, h.cookie);
}
ptl_err_t
-PtlGetUid(ptl_handle_ni_t ni_handle, ptl_uid_t *uid)
+LNetGetUid(ptl_handle_ni_t ni_handle, ptl_uid_t *uid)
{
LASSERT (ptl_apini.apini_init);
LASSERT (ptl_apini.apini_refcount > 0);
}
ptl_err_t
-PtlNIDist(ptl_handle_ni_t interface_in, ptl_process_id_t process_in,
+LNetNIDist(ptl_handle_ni_t interface_in, ptl_process_id_t process_in,
unsigned long *distance_out)
{
LASSERT (ptl_apini.apini_init);
}
ptl_err_t
-PtlNIStatus(ptl_handle_ni_t interface_in, ptl_sr_index_t register_in,
+LNetNIStatus(ptl_handle_ni_t interface_in, ptl_sr_index_t register_in,
ptl_sr_value_t *status_out)
{
LASSERT (ptl_apini.apini_init);
}
ptl_err_t
-PtlACEntry(ptl_handle_ni_t ni_in, ptl_ac_index_t index_in,
+LNetACEntry(ptl_handle_ni_t ni_in, ptl_ac_index_t index_in,
ptl_process_id_t match_id_in, ptl_pt_index_t portal_in)
{
LASSERT (ptl_apini.apini_init);
#include <portals/lib-p30.h>
ptl_err_t
-PtlEQAlloc(ptl_handle_ni_t interface, ptl_size_t count,
+LNetEQAlloc(ptl_handle_ni_t interface, ptl_size_t count,
ptl_eq_handler_t callback, ptl_handle_eq_t *handle)
{
ptl_eq_t *eq;
}
ptl_err_t
-PtlEQFree(ptl_handle_eq_t eqh)
+LNetEQFree(ptl_handle_eq_t eqh)
{
ptl_eq_t *eq;
int size;
ptl_err_t
-PtlEQGet (ptl_handle_eq_t eventq, ptl_event_t *event)
+LNetEQGet (ptl_handle_eq_t eventq, ptl_event_t *event)
{
int which;
- return PtlEQPoll(&eventq, 1, 0,
+ return LNetEQPoll(&eventq, 1, 0,
event, &which);
}
ptl_err_t
-PtlEQWait (ptl_handle_eq_t eventq, ptl_event_t *event)
+LNetEQWait (ptl_handle_eq_t eventq, ptl_event_t *event)
{
int which;
- return PtlEQPoll(&eventq, 1, PTL_TIME_FOREVER,
+ return LNetEQPoll(&eventq, 1, PTL_TIME_FOREVER,
event, &which);
}
ptl_err_t
-PtlEQPoll (ptl_handle_eq_t *eventqs, int neq, int timeout_ms,
+LNetEQPoll (ptl_handle_eq_t *eventqs, int neq, int timeout_ms,
ptl_event_t *event, int *which)
{
unsigned long flags;
* otherwise caller may only ptl_md_free() it.
*/
- if (!PtlHandleIsEqual (umd->eq_handle, PTL_EQ_NONE)) {
+ if (!LNetHandleIsEqual (umd->eq_handle, PTL_EQ_NONE)) {
eq = ptl_handle2eq(&umd->eq_handle);
if (eq == NULL)
return PTL_EQ_INVALID;
}
ptl_err_t
-PtlMDAttach(ptl_handle_me_t meh, ptl_md_t umd,
+LNetMDAttach(ptl_handle_me_t meh, ptl_md_t umd,
ptl_unlink_t unlink, ptl_handle_md_t *handle)
{
ptl_me_t *me;
}
ptl_err_t
-PtlMDBind(ptl_handle_ni_t nih, ptl_md_t umd,
+LNetMDBind(ptl_handle_ni_t nih, ptl_md_t umd,
ptl_unlink_t unlink, ptl_handle_md_t *handle)
{
ptl_libmd_t *md;
}
ptl_err_t
-PtlMDUnlink (ptl_handle_md_t mdh)
+LNetMDUnlink (ptl_handle_md_t mdh)
{
ptl_event_t ev;
ptl_libmd_t *md;
return PTL_OK;
}
-ptl_err_t
-PtlMDUpdate(ptl_handle_md_t mdh,
- ptl_md_t *oldumd, ptl_md_t *newumd,
- ptl_handle_eq_t testqh)
-{
- ptl_libmd_t *md;
- ptl_eq_t *test_eq = NULL;
- unsigned long flags;
- int rc;
-
- LASSERT (ptl_apini.apini_init);
- LASSERT (ptl_apini.apini_refcount > 0);
-
- PTL_LOCK(flags);
-
- md = ptl_handle2md(&mdh);
- if (md == NULL) {
- rc = PTL_MD_INVALID;
- goto out;
- }
-
- if (oldumd != NULL)
- ptl_md_deconstruct(md, oldumd);
-
- if (newumd == NULL) {
- rc = PTL_OK;
- goto out;
- }
-
- /* XXX fttb, the new MD must be the same "shape" wrt fragmentation,
- * since we simply overwrite the old lib-md */
- if ((((newumd->options ^ md->md_options) &
- (PTL_MD_IOVEC | PTL_MD_KIOV)) != 0) ||
- ((newumd->options & (PTL_MD_IOVEC | PTL_MD_KIOV)) != 0 &&
- newumd->length != md->md_niov)) {
- rc = PTL_IOV_INVALID;
- goto out;
- }
-
- if (!PtlHandleIsEqual (testqh, PTL_EQ_NONE)) {
- test_eq = ptl_handle2eq(&testqh);
- if (test_eq == NULL) {
- rc = PTL_EQ_INVALID;
- goto out;
- }
- }
-
- if (md->md_pending != 0) {
- rc = PTL_MD_NO_UPDATE;
- goto out;
- }
-
- if (test_eq == NULL ||
- test_eq->eq_deq_seq == test_eq->eq_enq_seq) {
- ptl_me_t *me = md->md_me;
- int unlink = (md->md_flags & PTL_MD_FLAG_AUTO_UNLINK) ?
- PTL_UNLINK : PTL_RETAIN;
-
- // #warning this does not track eq refcounts properly
- LBUG();
- rc = lib_md_build(md, newumd, unlink);
-
- md->md_me = me;
- } else {
- rc = PTL_MD_NO_UPDATE;
- }
-
- out:
- PTL_UNLOCK(flags);
-
- return rc;
-}
#include <portals/lib-p30.h>
ptl_err_t
-PtlMEAttach(ptl_handle_ni_t interface,
+LNetMEAttach(ptl_handle_ni_t interface,
ptl_pt_index_t portal,
ptl_process_id_t match_id,
ptl_match_bits_t match_bits,
}
ptl_err_t
-PtlMEInsert(ptl_handle_me_t current_meh,
+LNetMEInsert(ptl_handle_me_t current_meh,
ptl_process_id_t match_id,
ptl_match_bits_t match_bits,
ptl_match_bits_t ignore_bits,
}
ptl_err_t
-PtlMEUnlink(ptl_handle_me_t meh)
+LNetMEUnlink(ptl_handle_me_t meh)
{
unsigned long flags;
ptl_me_t *me;
}
ptl_err_t
-PtlPut(ptl_handle_md_t mdh, ptl_ack_req_t ack,
+LNetPut(ptl_handle_md_t mdh, ptl_ack_req_t ack,
ptl_process_id_t target, ptl_pt_index_t portal,
ptl_ac_index_t ac, ptl_match_bits_t match_bits,
ptl_size_t offset, ptl_hdr_data_t hdr_data)
return PTL_MD_INVALID;
}
- CDEBUG(D_NET, "PtlPut -> %s\n", libcfs_id2str(target));
+ CDEBUG(D_NET, "LNetPut -> %s\n", libcfs_id2str(target));
memset (&hdr, 0, sizeof (hdr));
}
ptl_err_t
-PtlGet(ptl_handle_md_t mdh, ptl_process_id_t target,
+LNetGet(ptl_handle_md_t mdh, ptl_process_id_t target,
ptl_pt_index_t portal, ptl_ac_index_t ac,
ptl_match_bits_t match_bits, ptl_size_t offset)
{
return PTL_MD_INVALID;
}
- CDEBUG(D_NET, "PtlGet -> %s\n", libcfs_id2str(target));
+ CDEBUG(D_NET, "LNetGet -> %s\n", libcfs_id2str(target));
memset (&hdr, 0, sizeof (hdr));
if (initrc) {
rc--;
- PtlNIFini((ptl_handle_ni_t){0});
+ LNetNIFini((ptl_handle_ni_t){0});
}
return rc == 0 ? 0 : -EBUSY;
}
- initrc = PtlNIInit(PTL_IFACE_DEFAULT, LUSTRE_SRV_PTL_PID,
+ initrc = LNetNIInit(PTL_IFACE_DEFAULT, LUSTRE_SRV_PTL_PID,
NULL, NULL, &nih);
if (!(initrc == PTL_OK || initrc == PTL_IFACE_DUP))
RETURN (-ENETDOWN);
- rc = PtlNICtl(nih, cmd, data);
+ rc = LNetNICtl(nih, cmd, data);
if (initrc == PTL_OK) {
PTL_MUTEX_DOWN(&ptl_apini.apini_api_mutex);
ptl_apini.apini_niinit_self = 1;
PTL_MUTEX_UP(&ptl_apini.apini_api_mutex);
} else {
- PtlNIFini(nih);
+ LNetNIFini(nih);
}
return rc;
int rc;
ENTRY;
- rc = PtlInit(NULL);
+ rc = LNetInit(NULL);
if (rc != PTL_OK) {
- CERROR("PtlInit: error %d\n", rc);
+ CERROR("LNetInit: error %d\n", rc);
RETURN(rc);
}
ptl_apini.apini_niinit_self = 1;
PTL_MUTEX_UP(&ptl_apini.apini_api_mutex);
- rc = PtlNIInit(PTL_IFACE_DEFAULT, LUSTRE_SRV_PTL_PID,
+ rc = LNetNIInit(PTL_IFACE_DEFAULT, LUSTRE_SRV_PTL_PID,
NULL, NULL, &nih);
if (rc != PTL_OK) {
- /* Can't PtlFini or fail now if I loaded NALs */
+ /* Can't LNetFini or fail now if I loaded NALs */
PTL_MUTEX_DOWN(&ptl_apini.apini_api_mutex);
ptl_apini.apini_niinit_self = 0;
PTL_MUTEX_UP(&ptl_apini.apini_api_mutex);
rc = libcfs_deregister_ioctl(&kportal_ioctl_handler);
LASSERT (rc == 0);
- PtlFini();
+ LNetFini();
}
EXPORT_SYMBOL(ptl_register_nal);
EXPORT_SYMBOL(ptl_unregister_nal);
EXPORT_SYMBOL(ptl_err_str);
-EXPORT_SYMBOL(PtlMEAttach);
-EXPORT_SYMBOL(PtlMEInsert);
-EXPORT_SYMBOL(PtlMEUnlink);
-EXPORT_SYMBOL(PtlEQAlloc);
-EXPORT_SYMBOL(PtlMDAttach);
-EXPORT_SYMBOL(PtlMDUnlink);
-EXPORT_SYMBOL(PtlNIInit);
-EXPORT_SYMBOL(PtlNIFini);
-EXPORT_SYMBOL(PtlInit);
-EXPORT_SYMBOL(PtlFini);
-EXPORT_SYMBOL(PtlSnprintHandle);
-EXPORT_SYMBOL(PtlPut);
-EXPORT_SYMBOL(PtlGet);
-EXPORT_SYMBOL(PtlEQWait);
-EXPORT_SYMBOL(PtlEQFree);
-EXPORT_SYMBOL(PtlEQGet);
-EXPORT_SYMBOL(PtlGetId);
-EXPORT_SYMBOL(PtlMDBind);
+EXPORT_SYMBOL(LNetMEAttach);
+EXPORT_SYMBOL(LNetMEInsert);
+EXPORT_SYMBOL(LNetMEUnlink);
+EXPORT_SYMBOL(LNetEQAlloc);
+EXPORT_SYMBOL(LNetMDAttach);
+EXPORT_SYMBOL(LNetMDUnlink);
+EXPORT_SYMBOL(LNetNIInit);
+EXPORT_SYMBOL(LNetNIFini);
+EXPORT_SYMBOL(LNetInit);
+EXPORT_SYMBOL(LNetFini);
+EXPORT_SYMBOL(LNetSnprintHandle);
+EXPORT_SYMBOL(LNetPut);
+EXPORT_SYMBOL(LNetGet);
+EXPORT_SYMBOL(LNetEQWait);
+EXPORT_SYMBOL(LNetEQFree);
+EXPORT_SYMBOL(LNetEQGet);
+EXPORT_SYMBOL(LNetGetId);
+EXPORT_SYMBOL(LNetMDBind);
EXPORT_SYMBOL(ptl_apini);
EXPORT_SYMBOL(ptl_iov_nob);
EXPORT_SYMBOL(ptl_copy_iov2buf);
switch (err) {
case 1:
/* Unlink any memory descriptors we may have used */
- if ((rc = PtlMDUnlink (client->md_out_head_h)))
- PDEBUG ("PtlMDUnlink", rc);
+ if ((rc = LNetMDUnlink (client->md_out_head_h)))
+ PDEBUG ("LNetMDUnlink", rc);
case 2:
- if ((rc = PtlMDUnlink (client->md_in_head_h)))
- PDEBUG ("PtlMDUnlink", rc);
+ if ((rc = LNetMDUnlink (client->md_in_head_h)))
+ PDEBUG ("LNetMDUnlink", rc);
/* Free the event queue */
- if ((rc = PtlEQFree (client->eq)))
- PDEBUG ("PtlEQFree", rc);
+ if ((rc = LNetEQFree (client->eq)))
+ PDEBUG ("LNetEQFree", rc);
- if ((rc = PtlMEUnlink (client->me)))
- PDEBUG ("PtlMEUnlink", rc);
+ if ((rc = LNetMEUnlink (client->me)))
+ PDEBUG ("LNetMEUnlink", rc);
case 3:
- PtlNIFini(nih);
+ LNetNIFini(nih);
case 4:
/* Free our buffers */
return;
}
- rc = PtlNIInit(PTL_IFACE_DEFAULT, 0, NULL, NULL, &nih);
+ rc = LNetNIInit(PTL_IFACE_DEFAULT, 0, NULL, NULL, &nih);
if (rc != PTL_OK && rc != PTL_IFACE_DUP)
{
- CERROR ("PtlNIInit: error %d\n", rc);
+ CERROR ("LNetNIInit: error %d\n", rc);
pingcli_shutdown (nih, 4);
return;
}
/* Based on the initialization aquire our unique portal ID. */
- if ((rc = PtlGetId (nih, &client->myid)))
+ if ((rc = LNetGetId (nih, &client->myid)))
{
- CERROR ("PtlGetId error %d\n", rc);
+ CERROR ("LNetGetId error %d\n", rc);
pingcli_shutdown (nih, 2);
return;
}
client->id_remote.nid = client->nid;
client->id_remote.pid = 0;
- if ((rc = PtlMEAttach (nih, PTL_PING_CLIENT,
+ if ((rc = LNetMEAttach (nih, PTL_PING_CLIENT,
client->id_local, 0, ~0, PTL_RETAIN,
PTL_INS_AFTER, &client->me)))
{
- CERROR ("PtlMEAttach error %d\n", rc);
+ CERROR ("LNetMEAttach error %d\n", rc);
pingcli_shutdown (nih, 2);
return;
}
/* Allocate the event queue for this network interface */
- if ((rc = PtlEQAlloc (nih, 64, pingcli_callback, &client->eq)))
+ if ((rc = LNetEQAlloc (nih, 64, pingcli_callback, &client->eq)))
{
- CERROR ("PtlEQAlloc error %d\n", rc);
+ CERROR ("LNetEQAlloc error %d\n", rc);
pingcli_shutdown (nih, 2);
return;
}
memset (client->inbuf, 0, (client->size + STDSIZE) * count);
/* Attach the incoming buffer */
- if ((rc = PtlMDAttach (client->me, client->md_in_head,
+ if ((rc = LNetMDAttach (client->me, client->md_in_head,
PTL_UNLINK, &client->md_in_head_h))) {
- CERROR ("PtlMDAttach error %d\n", rc);
+ CERROR ("LNetMDAttach error %d\n", rc);
pingcli_shutdown (nih, 1);
return;
}
count = 0;
/* Bind the outgoing ping header */
- if ((rc=PtlMDBind (nih, client->md_out_head,
+ if ((rc=LNetMDBind (nih, client->md_out_head,
PTL_UNLINK, &client->md_out_head_h))) {
- CERROR ("PtlMDBind error %d\n", rc);
+ CERROR ("LNetMDBind error %d\n", rc);
pingcli_shutdown (nih, 1);
return;
}
memcpy(client->outbuf+sizeof(unsigned)+sizeof(unsigned),&tv1,
sizeof(struct timeval));
- if((rc = PtlPut (client->md_out_head_h, PTL_NOACK_REQ,
+ if((rc = LNetPut (client->md_out_head_h, PTL_NOACK_REQ,
client->id_remote, PTL_PING_SERVER, 0, 0, 0, 0))) {
- PDEBUG ("PtlPut (header)", rc);
+ PDEBUG ("LNetPut (header)", rc);
pingcli_shutdown (nih, 1);
return;
}
switch (err) {
case 1:
/* Unlink any memory descriptors we may have used */
- if ((rc = PtlMDUnlink (server->mdin_h)))
- PDEBUG ("PtlMDUnlink (out head buffer)", rc);
+ if ((rc = LNetMDUnlink (server->mdin_h)))
+ PDEBUG ("LNetMDUnlink (out head buffer)", rc);
case 2:
/* Free the event queue */
- if ((rc = PtlEQFree (server->eq)))
- PDEBUG ("PtlEQFree", rc);
+ if ((rc = LNetEQFree (server->eq)))
+ PDEBUG ("LNetEQFree", rc);
/* Unlink the client portal from the ME list */
- if ((rc = PtlMEUnlink (server->me)))
- PDEBUG ("PtlMEUnlink", rc);
+ if ((rc = LNetMEUnlink (server->me)))
+ PDEBUG ("LNetMEUnlink", rc);
case 3:
- PtlNIFini (server->ni);
+ LNetNIFini (server->ni);
case 4:
server->mdout.eq_handle = PTL_EQ_NONE;
/* Bind the outgoing buffer */
- if ((rc = PtlMDBind (server->ni, server->mdout,
+ if ((rc = LNetMDBind (server->ni, server->mdout,
PTL_UNLINK, &server->mdout_h))) {
- PDEBUG ("PtlMDBind", rc);
+ PDEBUG ("LNetMDBind", rc);
pingsrv_shutdown (1);
return 1;
}
server->mdin.user_ptr = NULL;
server->mdin.eq_handle = server->eq;
- if ((rc = PtlMDAttach (server->me, server->mdin,
+ if ((rc = LNetMDAttach (server->me, server->mdin,
PTL_UNLINK, &server->mdin_h))) {
- PDEBUG ("PtlMDAttach (bulk)", rc);
+ PDEBUG ("LNetMDAttach (bulk)", rc);
CDEBUG (D_OTHER, "ping server resources allocated\n");
}
- if ((rc = PtlPut (server->mdout_h, PTL_NOACK_REQ,
+ if ((rc = LNetPut (server->mdout_h, PTL_NOACK_REQ,
server->evnt.initiator, PTL_PING_CLIENT, 0, 0, 0, 0)))
- PDEBUG ("PtlPut", rc);
+ PDEBUG ("LNetPut", rc);
atomic_dec (&pkt);
server->ni = PTL_INVALID_HANDLE;
/* Aquire and initialize the proper nal for portals. */
- rc = PtlNIInit(PTL_IFACE_DEFAULT, 0, NULL, NULL, &server->ni);
+ rc = LNetNIInit(PTL_IFACE_DEFAULT, 0, NULL, NULL, &server->ni);
if (!(rc == PTL_OK || rc == PTL_IFACE_DUP)) {
- CDEBUG (D_OTHER, "PtlNIInit: error %d\n", rc);
+ CDEBUG (D_OTHER, "LNetNIInit: error %d\n", rc);
return pingsrv_shutdown (4);
}
/* Based on the initialization aquire our unique portal ID. */
- if ((rc = PtlGetId (server->ni, &server->my_id))) {
- PDEBUG ("PtlGetId", rc);
+ if ((rc = LNetGetId (server->ni, &server->my_id))) {
+ PDEBUG ("LNetGetId", rc);
return pingsrv_shutdown (2);
}
server->id_local.pid = PTL_PID_ANY;
/* Attach a match entries for header packets */
- if ((rc = PtlMEAttach (server->ni, PTL_PING_SERVER,
+ if ((rc = LNetMEAttach (server->ni, PTL_PING_SERVER,
server->id_local,0, ~0,
PTL_RETAIN, PTL_INS_AFTER, &server->me))) {
- PDEBUG ("PtlMEAttach", rc);
+ PDEBUG ("LNetMEAttach", rc);
return pingsrv_shutdown (2);
}
- if ((rc = PtlEQAlloc (server->ni, 1024, &pingsrv_callback,
+ if ((rc = LNetEQAlloc (server->ni, 1024, &pingsrv_callback,
&server->eq))) {
- PDEBUG ("PtlEQAlloc (callback)", rc);
+ PDEBUG ("LNetEQAlloc (callback)", rc);
return pingsrv_shutdown (2);
}
server->mdin.eq_handle = server->eq;
memset (server->in_buf, 0, STDSIZE);
- if ((rc = PtlMDAttach (server->me, server->mdin,
+ if ((rc = LNetMDAttach (server->me, server->mdin,
PTL_UNLINK, &server->mdin_h))) {
- PDEBUG ("PtlMDAttach (bulk)", rc);
+ PDEBUG ("LNetMDAttach (bulk)", rc);
CDEBUG (D_OTHER, "ping server resources allocated\n");
}
switch (err) {
case 1:
/* Unlink any memory descriptors we may have used */
- if ((rc = PtlMDUnlink (client->md_out_head_h)))
- PDEBUG ("PtlMDUnlink", rc);
+ if ((rc = LNetMDUnlink (client->md_out_head_h)))
+ PDEBUG ("LNetMDUnlink", rc);
case 2:
/* Free the event queue */
- if ((rc = PtlEQFree (client->eq)))
- PDEBUG ("PtlEQFree", rc);
+ if ((rc = LNetEQFree (client->eq)))
+ PDEBUG ("LNetEQFree", rc);
- if ((rc = PtlMEUnlink (client->me)))
- PDEBUG ("PtlMEUnlink", rc);
+ if ((rc = LNetMEUnlink (client->me)))
+ PDEBUG ("LNetMEUnlink", rc);
case 3:
- PtlNIFini (nih);
+ LNetNIFini (nih);
case 4:
/* Free our buffers */
}
/* Aquire and initialize the proper nal for portals. */
- rc = PtlNIInit(PTL_IFACE_DEFAULT, 0, NULL, NULL, &nih);
+ rc = LNetNIInit(PTL_IFACE_DEFAULT, 0, NULL, NULL, &nih);
if (rc != PTL_OK && rc != PTL_IFACE_DUP)
{
- CERROR ("PtlNIInit: error %d\n", rc);
+ CERROR ("LNetNIInit: error %d\n", rc);
pingcli_shutdown (nih, 4);
return;
}
/* Based on the initialization aquire our unique portal ID. */
- if ((rc = PtlGetId (nih, &client->myid)))
+ if ((rc = LNetGetId (nih, &client->myid)))
{
- CERROR ("PtlGetId error %d\n", rc);
+ CERROR ("LNetGetId error %d\n", rc);
pingcli_shutdown (nih, 2);
return;
}
client->id_remote.nid = client->nid;
client->id_remote.pid = 0;
- if ((rc = PtlMEAttach (nih, PTL_PING_CLIENT,
+ if ((rc = LNetMEAttach (nih, PTL_PING_CLIENT,
client->id_local, 0, ~0, PTL_RETAIN,
PTL_INS_AFTER, &client->me)))
{
- CERROR ("PtlMEAttach error %d\n", rc);
+ CERROR ("LNetMEAttach error %d\n", rc);
pingcli_shutdown (nih, 2);
return;
}
/* Allocate the event queue for this network interface */
- if ((rc = PtlEQAlloc (nih, 64, pingcli_callback, &client->eq)))
+ if ((rc = LNetEQAlloc (nih, 64, pingcli_callback, &client->eq)))
{
- CERROR ("PtlEQAlloc error %d\n", rc);
+ CERROR ("LNetEQAlloc error %d\n", rc);
pingcli_shutdown (nih, 2);
return;
}
memset (client->inbuf, 0, STDSIZE);
/* Attach the incoming buffer */
- if ((rc = PtlMDAttach (client->me, client->md_in_head,
+ if ((rc = LNetMDAttach (client->me, client->md_in_head,
PTL_UNLINK, &client->md_in_head_h))) {
- CERROR ("PtlMDAttach error %d\n", rc);
+ CERROR ("LNetMDAttach error %d\n", rc);
pingcli_shutdown (nih, 1);
return;
}
memcpy (client->outbuf, &ping_head_magic, sizeof(ping_head_magic));
/* Bind the outgoing ping header */
- if ((rc=PtlMDBind (nih, client->md_out_head,
+ if ((rc=LNetMDBind (nih, client->md_out_head,
PTL_UNLINK, &client->md_out_head_h))) {
- CERROR ("PtlMDBind error %d\n", rc);
+ CERROR ("LNetMDBind error %d\n", rc);
pingcli_shutdown (nih, 1);
return;
}
/* Put the ping packet */
- if((rc = PtlPut (client->md_out_head_h, PTL_NOACK_REQ,
+ if((rc = LNetPut (client->md_out_head_h, PTL_NOACK_REQ,
client->id_remote, PTL_PING_SERVER, 0, 0, 0, 0))) {
- PDEBUG ("PtlPut (header)", rc);
+ PDEBUG ("LNetPut (header)", rc);
pingcli_shutdown (nih, 1);
return;
}
switch (err) {
case 1:
/* Unlink any memory descriptors we may have used */
- if ((rc = PtlMDUnlink (server->mdin_h)))
- PDEBUG ("PtlMDUnlink (out head buffer)", rc);
+ if ((rc = LNetMDUnlink (server->mdin_h)))
+ PDEBUG ("LNetMDUnlink (out head buffer)", rc);
case 2:
/* Free the event queue */
- if ((rc = PtlEQFree (server->eq)))
- PDEBUG ("PtlEQFree", rc);
+ if ((rc = LNetEQFree (server->eq)))
+ PDEBUG ("LNetEQFree", rc);
/* Unlink the client portal from the ME list */
- if ((rc = PtlMEUnlink (server->me)))
- PDEBUG ("PtlMEUnlink", rc);
+ if ((rc = LNetMEUnlink (server->me)))
+ PDEBUG ("LNetMEUnlink", rc);
case 3:
- PtlNIFini(server->ni);
+ LNetNIFini(server->ni);
case 4:
server->mdout.eq_handle = PTL_EQ_NONE;
/* Bind the outgoing buffer */
- if ((rc = PtlMDBind (server->ni, server->mdout,
+ if ((rc = LNetMDBind (server->ni, server->mdout,
PTL_UNLINK, &server->mdout_h))) {
- PDEBUG ("PtlMDBind", rc);
+ PDEBUG ("LNetMDBind", rc);
pingsrv_shutdown (1);
return 1;
}
server->mdin.user_ptr = NULL;
server->mdin.eq_handle = server->eq;
- if ((rc = PtlMDAttach (server->me, server->mdin,
+ if ((rc = LNetMDAttach (server->me, server->mdin,
PTL_UNLINK, &server->mdin_h))) {
- PDEBUG ("PtlMDAttach (bulk)", rc);
+ PDEBUG ("LNetMDAttach (bulk)", rc);
CDEBUG (D_OTHER, "ping server resources allocated\n");
}
- if ((rc = PtlPut (server->mdout_h, PTL_NOACK_REQ,
+ if ((rc = LNetPut (server->mdout_h, PTL_NOACK_REQ,
server->evnt.initiator, PTL_PING_CLIENT, 0, 0, 0, 0)))
- PDEBUG ("PtlPut", rc);
+ PDEBUG ("LNetPut", rc);
atomic_dec (&pkt);
server->ni = PTL_INVALID_HANDLE;
- rc = PtlNIInit(PTL_IFACE_DEFAULT, 0, NULL, NULL, &server->ni);
+ rc = LNetNIInit(PTL_IFACE_DEFAULT, 0, NULL, NULL, &server->ni);
if (rc != PTL_OK && rc != PTL_IFACE_DUP) {
- CDEBUG (D_OTHER, "PtlNIInit: error %d\n", rc);
+ CDEBUG (D_OTHER, "LNetNIInit: error %d\n", rc);
return pingsrv_shutdown (4);
}
/* Based on the initialization aquire our unique portal ID. */
- if ((rc = PtlGetId (server->ni, &server->my_id))) {
- PDEBUG ("PtlGetId", rc);
+ if ((rc = LNetGetId (server->ni, &server->my_id))) {
+ PDEBUG ("LNetGetId", rc);
return pingsrv_shutdown (2);
}
server->id_local.pid = PTL_PID_ANY;
/* Attach a match entries for header packets */
- if ((rc = PtlMEAttach (server->ni, PTL_PING_SERVER,
+ if ((rc = LNetMEAttach (server->ni, PTL_PING_SERVER,
server->id_local,0, ~0,
PTL_RETAIN, PTL_INS_AFTER, &server->me))) {
- PDEBUG ("PtlMEAttach", rc);
+ PDEBUG ("LNetMEAttach", rc);
return pingsrv_shutdown (2);
}
- if ((rc = PtlEQAlloc (server->ni, 64, pingsrv_callback,
+ if ((rc = LNetEQAlloc (server->ni, 64, pingsrv_callback,
&server->eq))) {
- PDEBUG ("PtlEQAlloc (callback)", rc);
+ PDEBUG ("LNetEQAlloc (callback)", rc);
return pingsrv_shutdown (2);
}
server->mdin.eq_handle = server->eq;
memset (server->in_buf, 0, STDSIZE);
- if ((rc = PtlMDAttach (server->me, server->mdin,
+ if ((rc = LNetMDAttach (server->me, server->mdin,
PTL_UNLINK, &server->mdin_h))) {
- PDEBUG ("PtlMDAttach (bulk)", rc);
+ PDEBUG ("LNetMDAttach (bulk)", rc);
CDEBUG (D_OTHER, "ping server resources allocated\n");
}
git://git.whamcloud.com / fs / lustre-release.git / commitdiff