nal_data = (gmnal_data_t*)arg;
CDEBUG(D_TRACE, "nal_data is [%p]\n", arg);
+ sprintf(current->comm, "gmnal_ct");
+
daemonize();
nal_data->ctthread_flag = GMNAL_CTTHREAD_STARTED;
gmnal_data_t *nal_data;
void *buffer;
gmnal_rxtwe_t *we = NULL;
+ int rank;
if (!arg) {
CDEBUG(D_TRACE, "NO nal_data. Exiting\n");
nal_data = (gmnal_data_t*)arg;
CDEBUG(D_TRACE, "nal_data is [%p]\n", arg);
+ for (rank=0; rank<num_rx_threads; rank++)
+ if (nal_data->rxthread_pid[rank] == current->pid)
+ break;
+
+ sprintf(current->comm, "gmnal_rx_%d", rank);
+
daemonize();
/*
* set 1 bit for each thread started
unsigned int snode, sport, type, length;
gmnal_msghdr_t *gmnal_msghdr;
ptl_hdr_t *portals_hdr;
+ int rc;
CDEBUG(D_INFO, "nal_data [%p], we[%p] type [%d]\n",
nal_data, we, gmnal_type);
gmnal_msghdr = (gmnal_msghdr_t*)buffer;
portals_hdr = (ptl_hdr_t*)(buffer+GMNAL_MSGHDR_SIZE);
- CDEBUG(D_INFO, "rx_event:: Sender node [%d], Sender Port [%d],
- type [%d], length [%d], buffer [%p]\n",
+ CDEBUG(D_INFO, "rx_event:: Sender node [%d], Sender Port [%d], "
+ "type [%d], length [%d], buffer [%p]\n",
snode, sport, type, length, buffer);
- CDEBUG(D_INFO, "gmnal_msghdr:: Sender node [%u], magic [%d],
- gmnal_type [%d]\n", gmnal_msghdr->sender_node_id,
+ CDEBUG(D_INFO, "gmnal_msghdr:: Sender node [%u], magic [%d], "
+ "gmnal_type [%d]\n", gmnal_msghdr->sender_node_id,
gmnal_msghdr->magic, gmnal_msghdr->type);
- CDEBUG(D_INFO, "portals_hdr:: Sender node ["LPD64"],
- dest_node ["LPD64"]\n", portals_hdr->src_nid,
+ CDEBUG(D_INFO, "portals_hdr:: Sender node ["LPD64"], "
+ "dest_node ["LPD64"]\n", portals_hdr->src_nid,
portals_hdr->dest_nid);
*/
srxd = gmnal_rxbuffer_to_srxd(nal_data, buffer);
CDEBUG(D_INFO, "Back from gmnal_rxbuffer_to_srxd\n");
- srxd->nal_data = nal_data;
if (!srxd) {
CDEBUG(D_ERROR, "Failed to get receive descriptor\n");
- lib_parse(nal_data->nal_cb, portals_hdr, srxd);
+ /* I think passing a NULL srxd to lib_parse will crash
+ * gmnal_recv() */
+ LBUG();
+ lib_parse(nal_data->libnal, portals_hdr, srxd);
return(GMNAL_STATUS_FAIL);
}
return(GMNAL_STATUS_OK);
}
+ srxd->nal_data = nal_data;
srxd->type = gmnal_type;
srxd->nsiov = gmnal_msghdr->niov;
srxd->gm_source_node = gmnal_msghdr->sender_node_id;
* cb_recv is responsible for returning the buffer
* for future receive
*/
- lib_parse(nal_data->nal_cb, portals_hdr, srxd);
+ rc = lib_parse(nal_data->libnal, portals_hdr, srxd);
+
+ if (rc != PTL_OK) {
+ /* I just received garbage; take appropriate action... */
+ LBUG();
+ }
return(GMNAL_STATUS_OK);
}
* Hang out the receive buffer again for another receive
* Call lib_finalize
*/
-int
-gmnal_small_rx(nal_cb_t *nal_cb, void *private, lib_msg_t *cookie,
- unsigned int niov, struct iovec *iov, size_t mlen, size_t rlen)
+ptl_err_t
+gmnal_small_rx(lib_nal_t *libnal, void *private, lib_msg_t *cookie)
{
gmnal_srxd_t *srxd = NULL;
- void *buffer = NULL;
- gmnal_data_t *nal_data = (gmnal_data_t*)nal_cb->nal_data;
-
+ gmnal_data_t *nal_data = (gmnal_data_t*)libnal->libnal_data;
- CDEBUG(D_TRACE, "niov [%d] mlen["LPSZ"]\n", niov, mlen);
if (!private) {
CDEBUG(D_ERROR, "gmnal_small_rx no context\n");
- lib_finalize(nal_cb, private, cookie);
+ lib_finalize(libnal, private, cookie, PTL_FAIL);
return(PTL_FAIL);
}
srxd = (gmnal_srxd_t*)private;
- buffer = srxd->buffer;
- buffer += sizeof(gmnal_msghdr_t);
- buffer += sizeof(ptl_hdr_t);
-
- while(niov--) {
- CDEBUG(D_INFO, "processing [%p] len ["LPSZ"]\n", iov,
- iov->iov_len);
- gm_bcopy(buffer, iov->iov_base, iov->iov_len);
- buffer += iov->iov_len;
- iov++;
- }
-
/*
- * let portals library know receive is complete
+ * let portals library know receive is complete
*/
CDEBUG(D_PORTALS, "calling lib_finalize\n");
- if (lib_finalize(nal_cb, private, cookie) != PTL_OK) {
- /* TO DO what to do with failed lib_finalise? */
- CDEBUG(D_INFO, "lib_finalize failed\n");
- }
+ lib_finalize(libnal, private, cookie, PTL_OK);
/*
* return buffer so it can be used again
*/
CDEBUG(D_NET, "calling gm_provide_receive_buffer\n");
GMNAL_GM_LOCK(nal_data);
- gm_provide_receive_buffer_with_tag(nal_data->gm_port, srxd->buffer,
- srxd->gmsize, GM_LOW_PRIORITY, 0);
+ gm_provide_receive_buffer_with_tag(nal_data->gm_port, srxd->buffer,
+ srxd->gmsize, GM_LOW_PRIORITY, 0);
GMNAL_GM_UNLOCK(nal_data);
return(PTL_OK);
/*
* Start a small transmit.
- * Get a send token (and wired transmit buffer).
- * Copy data from senders buffer to wired buffer and
- * initiate gm_send from the wired buffer.
+ * Use the given send token (and wired transmit buffer).
+ * Copy headers to wired buffer and initiate gm_send from the wired buffer.
* The callback function informs when the send is complete.
*/
-int
-gmnal_small_tx(nal_cb_t *nal_cb, void *private, lib_msg_t *cookie,
- ptl_hdr_t *hdr, int type, ptl_nid_t global_nid, ptl_pid_t pid,
- unsigned int niov, struct iovec *iov, int size)
+ptl_err_t
+gmnal_small_tx(lib_nal_t *libnal, void *private, lib_msg_t *cookie,
+ ptl_hdr_t *hdr, int type, ptl_nid_t global_nid, ptl_pid_t pid,
+ gmnal_stxd_t *stxd, int size)
{
- gmnal_data_t *nal_data = (gmnal_data_t*)nal_cb->nal_data;
- gmnal_stxd_t *stxd = NULL;
+ gmnal_data_t *nal_data = (gmnal_data_t*)libnal->libnal_data;
void *buffer = NULL;
gmnal_msghdr_t *msghdr = NULL;
int tot_size = 0;
unsigned int local_nid;
gm_status_t gm_status = GM_SUCCESS;
- CDEBUG(D_TRACE, "gmnal_small_tx nal_cb [%p] private [%p] cookie [%p]
- hdr [%p] type [%d] global_nid ["LPU64"] pid [%d] niov [%d]
- iov [%p] size [%d]\n", nal_cb, private, cookie, hdr, type,
- global_nid, pid, niov, iov, size);
+ CDEBUG(D_TRACE, "gmnal_small_tx libnal [%p] private [%p] cookie [%p] "
+ "hdr [%p] type [%d] global_nid ["LPU64"] pid [%d] stxd [%p] "
+ "size [%d]\n", libnal, private, cookie, hdr, type,
+ global_nid, pid, stxd, size);
CDEBUG(D_INFO, "portals_hdr:: dest_nid ["LPU64"], src_nid ["LPU64"]\n",
hdr->dest_nid, hdr->src_nid);
if (!nal_data) {
CDEBUG(D_ERROR, "no nal_data\n");
- return(GMNAL_STATUS_FAIL);
+ return(PTL_FAIL);
} else {
CDEBUG(D_INFO, "nal_data [%p]\n", nal_data);
}
GMNAL_GM_UNLOCK(nal_data);
if (gm_status != GM_SUCCESS) {
CDEBUG(D_ERROR, "Failed to obtain local id\n");
- return(GMNAL_STATUS_FAIL);
+ return(PTL_FAIL);
}
CDEBUG(D_INFO, "Local Node_id is [%u][%x]\n", local_nid, local_nid);
- stxd = gmnal_get_stxd(nal_data, 1);
- CDEBUG(D_INFO, "stxd [%p]\n", stxd);
-
stxd->type = GMNAL_SMALL_MESSAGE;
stxd->cookie = cookie;
/*
* Copy gmnal_msg_hdr and portals header to the transmit buffer
- * Then copy the data in
+ * Then send the message, as the data has previously been copied in
+ * (HP SFS 1380).
*/
buffer = stxd->buffer;
msghdr = (gmnal_msghdr_t*)buffer;
buffer += sizeof(ptl_hdr_t);
- while(niov--) {
- CDEBUG(D_INFO, "processing iov [%p] len ["LPSZ"] to [%p]\n",
- iov, iov->iov_len, buffer);
- gm_bcopy(iov->iov_base, buffer, iov->iov_len);
- buffer+= iov->iov_len;
- iov++;
- }
-
CDEBUG(D_INFO, "sending\n");
tot_size = size+sizeof(ptl_hdr_t)+sizeof(gmnal_msghdr_t);
stxd->msg_size = tot_size;
- CDEBUG(D_NET, "Calling gm_send_to_peer port [%p] buffer [%p]
- gmsize [%lu] msize [%d] global_nid ["LPU64"] local_nid[%d]
- stxd [%p]\n", nal_data->gm_port, stxd->buffer, stxd->gm_size,
+ CDEBUG(D_NET, "Calling gm_send_to_peer port [%p] buffer [%p] "
+ "gmsize [%lu] msize [%d] global_nid ["LPU64"] local_nid[%d] "
+ "stxd [%p]\n", nal_data->gm_port, stxd->buffer, stxd->gm_size,
stxd->msg_size, global_nid, local_nid, stxd);
GMNAL_GM_LOCK(nal_data);
gmnal_stxd_t *stxd = (gmnal_stxd_t*)context;
lib_msg_t *cookie = stxd->cookie;
gmnal_data_t *nal_data = (gmnal_data_t*)stxd->nal_data;
- nal_cb_t *nal_cb = nal_data->nal_cb;
+ lib_nal_t *libnal = nal_data->libnal;
+ unsigned gnid = 0;
+ gm_status_t gm_status = 0;
if (!stxd) {
CDEBUG(D_TRACE, "send completion event for unknown stxd\n");
return;
}
if (status != GM_SUCCESS) {
- CDEBUG(D_ERROR, "Result of send stxd [%p] is [%s]\n",
- stxd, gmnal_gm_error(status));
+ GMNAL_GM_LOCK(nal_data);
+ gm_status = gm_node_id_to_global_id(nal_data->gm_port,
+ stxd->gm_target_node,&gnid);
+ GMNAL_GM_UNLOCK(nal_data);
+ if (gm_status != GM_SUCCESS) {
+ CDEBUG(D_INFO, "gm_node_id_to_global_id failed[%d]\n",
+ gm_status);
+ gnid = 0;
+ }
+ CDEBUG(D_ERROR, "Result of send stxd [%p] is [%s] to [%u]\n",
+ stxd, gmnal_gm_error(status), gnid);
}
switch(status) {
- case(GM_SUCCESS):
+ case(GM_SUCCESS):
break;
- case(GM_SEND_DROPPED):
+ case(GM_SEND_DROPPED):
/*
* do a resend on the dropped ones
*/
- CDEBUG(D_ERROR, "send stxd [%p] was dropped
- resending\n", context);
+ CDEBUG(D_ERROR, "send stxd [%p] was dropped "
+ "resending\n", context);
GMNAL_GM_LOCK(nal_data);
gm_send_to_peer_with_callback(nal_data->gm_port,
stxd->buffer,
CDEBUG(D_INFO, "calling gm_drop_sends\n");
GMNAL_GM_LOCK(nal_data);
gm_drop_sends(nal_data->gm_port, stxd->gm_priority,
- stxd->gm_target_node, GMNAL_GM_PORT,
+ stxd->gm_target_node, GMNAL_GM_PORT_ID,
gmnal_drop_sends_callback, context);
GMNAL_GM_UNLOCK(nal_data);
case(GM_FIRMWARE_NOT_RUNNING):
case(GM_YP_NO_MATCH):
default:
- CDEBUG(D_ERROR, "Unknown send error\n");
+ gm_resume_sending(nal_data->gm_port, stxd->gm_priority,
+ stxd->gm_target_node, GMNAL_GM_PORT_ID,
+ gmnal_resume_sending_callback, context);
+ return;
+
}
/*
return;
}
gmnal_return_stxd(nal_data, stxd);
- if (lib_finalize(nal_cb, stxd, cookie) != PTL_OK) {
- CDEBUG(D_INFO, "Call to lib_finalize failed for stxd [%p]\n",
- stxd);
- }
+ lib_finalize(libnal, stxd, cookie, PTL_OK);
return;
}
+/*
+ * After an error on the port
+ * call this to allow future sends to complete
+ */
+void gmnal_resume_sending_callback(struct gm_port *gm_port, void *context,
+ gm_status_t status)
+{
+ gmnal_data_t *nal_data;
+ gmnal_stxd_t *stxd = (gmnal_stxd_t*)context;
+ CDEBUG(D_TRACE, "status is [%d] context is [%p]\n", status, context);
+ gmnal_return_stxd(stxd->nal_data, stxd);
+ return;
+}
void gmnal_drop_sends_callback(struct gm_port *gm_port, void *context,
stxd->gm_target_node,
gmnal_small_tx_callback,
context);
- GMNAL_GM_LOCK(nal_data);
+ GMNAL_GM_UNLOCK(nal_data);
} else {
- CDEBUG(D_ERROR, "send_to_peer status for stxd [%p] is
- [%d][%s]\n", stxd, status, gmnal_gm_error(status));
+ CDEBUG(D_ERROR, "send_to_peer status for stxd [%p] is "
+ "[%d][%s]\n", stxd, status, gmnal_gm_error(status));
}
* this ack, deregister the memory. Only 1 send token is required here.
*/
int
-gmnal_large_tx(nal_cb_t *nal_cb, void *private, lib_msg_t *cookie,
+gmnal_large_tx(lib_nal_t *libnal, void *private, lib_msg_t *cookie,
ptl_hdr_t *hdr, int type, ptl_nid_t global_nid, ptl_pid_t pid,
- unsigned int niov, struct iovec *iov, int size)
+ unsigned int niov, struct iovec *iov, size_t offset, int size)
{
gmnal_data_t *nal_data;
int niov_dup;
- CDEBUG(D_TRACE, "gmnal_large_tx nal_cb [%p] private [%p], cookie [%p]
- hdr [%p], type [%d] global_nid ["LPU64"], pid [%d], niov [%d],
- iov [%p], size [%d]\n", nal_cb, private, cookie, hdr, type,
+ CDEBUG(D_TRACE, "gmnal_large_tx libnal [%p] private [%p], cookie [%p] "
+ "hdr [%p], type [%d] global_nid ["LPU64"], pid [%d], niov [%d], "
+ "iov [%p], size [%d]\n", libnal, private, cookie, hdr, type,
global_nid, pid, niov, iov, size);
- if (nal_cb)
- nal_data = (gmnal_data_t*)nal_cb->nal_data;
+ if (libnal)
+ nal_data = (gmnal_data_t*)libnal->libnal_data;
else {
- CDEBUG(D_ERROR, "no nal_cb.\n");
+ CDEBUG(D_ERROR, "no libnal.\n");
return(GMNAL_STATUS_FAIL);
}
msghdr->magic = GMNAL_MAGIC;
msghdr->type = GMNAL_LARGE_MESSAGE_INIT;
msghdr->sender_node_id = nal_data->gm_global_nid;
- msghdr->stxd = stxd;
+ msghdr->stxd_remote_ptr = (gm_remote_ptr_t)stxd;
msghdr->niov = niov ;
buffer += sizeof(gmnal_msghdr_t);
mlen = sizeof(gmnal_msghdr_t);
mlen += sizeof(ptl_hdr_t);
CDEBUG(D_INFO, "mlen is [%d]\n", mlen);
+ while (offset >= iov->iov_len) {
+ offset -= iov->iov_len;
+ niov--;
+ iov++;
+ }
+
+ LASSERT(offset >= 0);
+ /*
+ * Store the iovs in the stxd for we can get
+ * them later if we need them
+ */
+ stxd->iov[0].iov_base = iov->iov_base + offset;
+ stxd->iov[0].iov_len = iov->iov_len - offset;
+ CDEBUG(D_NET, "Copying iov [%p] to [%p], niov=%d\n", iov, stxd->iov, niov);
+ if (niov > 1)
+ gm_bcopy(&iov[1], &stxd->iov[1], (niov-1)*sizeof(struct iovec));
+ stxd->niov = niov;
+
/*
* copy the iov to the buffer so target knows
* where to get the data from
*/
CDEBUG(D_INFO, "processing iov to [%p]\n", buffer);
- gm_bcopy(iov, buffer, niov*sizeof(struct iovec));
- mlen += niov*(sizeof(struct iovec));
+ gm_bcopy(stxd->iov, buffer, stxd->niov*sizeof(struct iovec));
+ mlen += stxd->niov*(sizeof(struct iovec));
CDEBUG(D_INFO, "mlen is [%d]\n", mlen);
-
-
- /*
- * Store the iovs in the stxd for we can get
- * them later if we need them
- */
- CDEBUG(D_NET, "Copying iov [%p] to [%p]\n", iov, stxd->iov);
- gm_bcopy(iov, stxd->iov, niov*sizeof(struct iovec));
- stxd->niov = niov;
-
/*
* register the memory so the NIC can get hold of the data
* This is a slow process. it'd be good to overlap it
* with something else.
*/
+ iov = stxd->iov;
iov_dup = iov;
niov_dup = niov;
while(niov--) {
iov->iov_base, iov->iov_len);
if (gm_status != GM_SUCCESS) {
GMNAL_GM_UNLOCK(nal_data);
- CDEBUG(D_ERROR, "gm_register_memory returns [%d][%s]
- for memory [%p] len ["LPSZ"]\n",
+ CDEBUG(D_ERROR, "gm_register_memory returns [%d][%s] "
+ "for memory [%p] len ["LPSZ"]\n",
gm_status, gmnal_gm_error(gm_status),
iov->iov_base, iov->iov_len);
GMNAL_GM_LOCK(nal_data);
* data from the sender.
*/
int
-gmnal_large_rx(nal_cb_t *nal_cb, void *private, lib_msg_t *cookie,
- unsigned int nriov, struct iovec *riov, size_t mlen,
- size_t rlen)
+gmnal_large_rx(lib_nal_t *libnal, void *private, lib_msg_t *cookie,
+ unsigned int nriov, struct iovec *riov, size_t offset,
+ size_t mlen, size_t rlen)
{
- gmnal_data_t *nal_data = nal_cb->nal_data;
+ gmnal_data_t *nal_data = libnal->libnal_data;
gmnal_srxd_t *srxd = (gmnal_srxd_t*)private;
void *buffer = NULL;
struct iovec *riov_dup;
gmnal_msghdr_t *msghdr = NULL;
gm_status_t gm_status;
- CDEBUG(D_TRACE, "gmnal_large_rx :: nal_cb[%p], private[%p],
- cookie[%p], niov[%d], iov[%p], mlen["LPSZ"], rlen["LPSZ"]\n",
- nal_cb, private, cookie, nriov, riov, mlen, rlen);
+ CDEBUG(D_TRACE, "gmnal_large_rx :: libnal[%p], private[%p], "
+ "cookie[%p], niov[%d], iov[%p], mlen["LPSZ"], rlen["LPSZ"]\n",
+ libnal, private, cookie, nriov, riov, mlen, rlen);
if (!srxd) {
CDEBUG(D_ERROR, "gmnal_large_rx no context\n");
- lib_finalize(nal_cb, private, cookie);
+ lib_finalize(libnal, private, cookie, PTL_FAIL);
return(PTL_FAIL);
}
* The gmnal_large_message_ack needs it to notify the sender
* the pull of data is complete
*/
- srxd->source_stxd = msghdr->stxd;
+ srxd->source_stxd = (gmnal_stxd_t*)msghdr->stxd_remote_ptr;
/*
* Register the receivers memory
* If the iovecs match, could interleave
* gm_registers and gm_gets for each element
*/
+ while (offset >= riov->iov_len) {
+ offset -= riov->iov_len;
+ riov++;
+ nriov--;
+ }
+ LASSERT (nriov >= 0);
+ LASSERT (offset >= 0);
+ /*
+ * do this so the final gm_get callback can deregister the memory
+ */
+ PORTAL_ALLOC(srxd->riov, nriov*(sizeof(struct iovec)));
+
+ srxd->riov[0].iov_base = riov->iov_base + offset;
+ srxd->riov[0].iov_len = riov->iov_len - offset;
+ if (nriov > 1)
+ gm_bcopy(&riov[1], &srxd->riov[1], (nriov-1)*(sizeof(struct iovec)));
+ srxd->nriov = nriov;
+
+ riov = srxd->riov;
nriov_dup = nriov;
riov_dup = riov;
while(nriov--) {
riov->iov_base, riov->iov_len);
if (gm_status != GM_SUCCESS) {
GMNAL_GM_UNLOCK(nal_data);
- CDEBUG(D_ERROR, "gm_register_memory returns [%d][%s]
- for memory [%p] len ["LPSZ"]\n",
+ CDEBUG(D_ERROR, "gm_register_memory returns [%d][%s] "
+ "for memory [%p] len ["LPSZ"]\n",
gm_status, gmnal_gm_error(gm_status),
riov->iov_base, riov->iov_len);
GMNAL_GM_LOCK(nal_data);
/*
* give back srxd and buffer. Send NACK to sender
*/
+ PORTAL_FREE(srxd->riov, nriov_dup*(sizeof(struct iovec)));
return(PTL_FAIL);
}
GMNAL_GM_UNLOCK(nal_data);
riov++;
}
- /*
- * do this so the final gm_get callback can deregister the memory
- */
- PORTAL_ALLOC(srxd->riov, nriov_dup*(sizeof(struct iovec)));
- gm_bcopy(riov_dup, srxd->riov, nriov_dup*(sizeof(struct iovec)));
- srxd->nriov = nriov_dup;
/*
* now do gm_get to get the data
int ncalls = 0;
- CDEBUG(D_TRACE, "gmnal_remote_get srxd[%p], nriov[%d], riov[%p],
- nsiov[%d], siov[%p]\n", srxd, nriov, riov, nsiov, siov);
+ CDEBUG(D_TRACE, "gmnal_remote_get srxd[%p], nriov[%d], riov[%p], "
+ "nsiov[%d], siov[%p]\n", srxd, nriov, riov, nsiov, siov);
ncalls = gmnal_copyiov(0, srxd, nsiov, siov, nriov, riov);
/*
* pull data from source node (source iovec) to a local iovec.
* The iovecs may not match which adds the complications below.
- * Count the number of gm_gets that will be required to the callbacks
+ * Count the number of gm_gets that will be required so the callbacks
* can determine who is the last one.
*/
int
srxd->gm_source_node,
&source_node) != GM_SUCCESS) {
- CDEBUG(D_ERROR, "cannot resolve global_id [%u]
- to local node_id\n", srxd->gm_source_node);
+ CDEBUG(D_ERROR, "cannot resolve global_id [%u] "
+ "to local node_id\n", srxd->gm_source_node);
GMNAL_GM_UNLOCK(nal_data);
return(GMNAL_STATUS_FAIL);
}
*/
sbuf_long = (unsigned long) sbuf;
remote_ptr = (gm_remote_ptr_t)sbuf_long;
- gm_get(nal_data->gm_port, remote_ptr, rbuf,
- rlen, GM_LOW_PRIORITY, source_node,
- GMNAL_GM_PORT,
+ gm_get(nal_data->gm_port, remote_ptr, rbuf,
+ rlen, GM_LOW_PRIORITY, source_node,
+ GMNAL_GM_PORT_ID,
gmnal_remote_get_callback, ltxd);
GMNAL_GM_UNLOCK(nal_data);
}
/*
* at the end of 1 iov element
- */
+ */
sbuf+=rlen;
slen-=rlen;
riov++;
GMNAL_GM_LOCK(nal_data);
sbuf_long = (unsigned long) sbuf;
remote_ptr = (gm_remote_ptr_t)sbuf_long;
- gm_get(nal_data->gm_port, remote_ptr, rbuf,
- slen, GM_LOW_PRIORITY, source_node,
- GMNAL_GM_PORT,
+ gm_get(nal_data->gm_port, remote_ptr, rbuf,
+ slen, GM_LOW_PRIORITY, source_node,
+ GMNAL_GM_PORT_ID,
gmnal_remote_get_callback, ltxd);
GMNAL_GM_UNLOCK(nal_data);
}
GMNAL_GM_LOCK(nal_data);
sbuf_long = (unsigned long) sbuf;
remote_ptr = (gm_remote_ptr_t)sbuf_long;
- gm_get(nal_data->gm_port, remote_ptr, rbuf,
- rlen, GM_LOW_PRIORITY, source_node,
- GMNAL_GM_PORT,
+ gm_get(nal_data->gm_port, remote_ptr, rbuf,
+ rlen, GM_LOW_PRIORITY, source_node,
+ GMNAL_GM_PORT_ID,
gmnal_remote_get_callback, ltxd);
GMNAL_GM_UNLOCK(nal_data);
}
gmnal_ltxd_t *ltxd = (gmnal_ltxd_t*)context;
gmnal_srxd_t *srxd = ltxd->srxd;
- nal_cb_t *nal_cb = srxd->nal_data->nal_cb;
+ lib_nal_t *libnal = srxd->nal_data->libnal;
int lastone;
struct iovec *riov;
int nriov;
* Let our client application proceed
*/
CDEBUG(D_ERROR, "final callback context[%p]\n", srxd);
- if (lib_finalize(nal_cb, srxd, srxd->cookie) != PTL_OK) {
- CDEBUG(D_INFO, "Call to lib_finalize failed for srxd [%p]\n",
- srxd);
- }
+ lib_finalize(libnal, srxd, srxd->cookie, PTL_OK);
/*
* send an ack to the sender to let him know we got the data
msghdr->magic = GMNAL_MAGIC;
msghdr->type = GMNAL_LARGE_MESSAGE_ACK;
msghdr->sender_node_id = nal_data->gm_global_nid;
- msghdr->stxd = srxd->source_stxd;
+ msghdr->stxd_remote_ptr = (gm_remote_ptr_t)srxd->source_stxd;
CDEBUG(D_INFO, "processing msghdr at [%p]\n", buffer);
CDEBUG(D_INFO, "sending\n");
stxd->msg_size= sizeof(gmnal_msghdr_t);
- CDEBUG(D_NET, "Calling gm_send_to_peer port [%p] buffer [%p]
- gmsize [%lu] msize [%d] global_nid [%u] local_nid[%d]
- stxd [%p]\n", nal_data->gm_port, stxd->buffer, stxd->gm_size,
+ CDEBUG(D_NET, "Calling gm_send_to_peer port [%p] buffer [%p] "
+ "gmsize [%lu] msize [%d] global_nid [%u] local_nid[%d] "
+ "stxd [%p]\n", nal_data->gm_port, stxd->buffer, stxd->gm_size,
stxd->msg_size, srxd->gm_source_node, local_nid, stxd);
GMNAL_GM_LOCK(nal_data);
stxd->gm_priority = GM_LOW_PRIORITY;
void
gmnal_large_tx_ack_received(gmnal_data_t *nal_data, gmnal_srxd_t *srxd)
{
- nal_cb_t *nal_cb = nal_data->nal_cb;
+ lib_nal_t *libnal = nal_data->libnal;
gmnal_stxd_t *stxd = NULL;
gmnal_msghdr_t *msghdr = NULL;
void *buffer = NULL;
buffer = srxd->buffer;
msghdr = (gmnal_msghdr_t*)buffer;
- stxd = msghdr->stxd;
+ stxd = (gmnal_stxd_t*)msghdr->stxd_remote_ptr;
CDEBUG(D_INFO, "gmnal_large_tx_ack_received stxd [%p]\n", stxd);
- if (lib_finalize(nal_cb, stxd, stxd->cookie) != PTL_OK) {
- CDEBUG(D_INFO, "Call to lib_finalize failed for stxd [%p]\n",
- stxd);
- }
+ lib_finalize(libnal, stxd, stxd->cookie, PTL_OK);
/*
* extract the iovec from the stxd, deregister the memory.