/*
 * Copyright (c) 2002-2005, Network Appliance, Inc. All rights reserved.
 *
 * This Software is licensed under one of the following licenses:
 *
 * 1) under the terms of the "Common Public License 1.0" a copy of which is
 *    in the file LICENSE.txt in the root directory. The license is also
 *    available from the Open Source Initiative, see
 *    http://www.opensource.org/licenses/cpl.php.
 *
 * 2) under the terms of the "The BSD License" a copy of which is in the file
 *    LICENSE2.txt in the root directory. The license is also available from
 *    the Open Source Initiative, see
 *    http://www.opensource.org/licenses/bsd-license.php.
 *
 * 3) under the terms of the "GNU General Public License (GPL) Version 2" a 
 *    copy of which is in the file LICENSE3.txt in the root directory. The 
 *    license is also available from the Open Source Initiative, see
 *    http://www.opensource.org/licenses/gpl-license.php.
 *
 * Licensee has the right to choose one of the above licenses.
 *
 * Redistributions of source code must retain the above copyright
 * notice and one of the license notices.
 *
 * Redistributions in binary form must reproduce both the above copyright
 * notice, one of the license notices in the documentation
 * and/or other materials provided with the distribution.
 */

#include "dapl_proto.h"

/* -----------------------------------------------------------
 * Post a recv buffer on each of this thread's EPs.
 */
bool
DT_handle_post_recv_buf(DT_Tdep_Print_Head * phead,
			Ep_Context_t * ep_context,
			unsigned int num_eps, int op_indx)
{
	unsigned int i, j;

	for (i = 0; i < num_eps; i++) {
		Transaction_Test_Op_t *op = &ep_context[i].op[op_indx];
		DAT_LMR_TRIPLET *iov = DT_Bpool_GetIOV(op->bp, 0);
		DAT_DTO_COOKIE cookie;
		DAT_RETURN ret;

		/* Prep the inputs */
		for (j = 0; j < op->num_segs; j++) {
			iov[j].virtual_address = (DAT_VADDR) (uintptr_t)
			    DT_Bpool_GetBuffer(op->bp, j);
			iov[j].segment_length = op->seg_size;
			iov[j].lmr_context = DT_Bpool_GetLMR(op->bp, j);
		}
		cookie.as_64 = ((((DAT_UINT64) i) << 32)
				| (((uintptr_t) DT_Bpool_GetBuffer(op->bp, 0)) &
				   0xffffffffUL));

		/* Post the recv */
		ret = dat_ep_post_recv(ep_context[i].ep_handle,
				       op->num_segs,
				       iov,
				       cookie, DAT_COMPLETION_DEFAULT_FLAG);

		if (ret != DAT_SUCCESS) {
			DT_Tdep_PT_Printf(phead,
					  "Test Error: dat_ep_post_recv failed: %s\n",
					  DT_RetToString(ret));
			DT_Test_Error();
			return false;
		}
	}

	return true;
}

/* -----------------------------------------------------------
 * Post a send buffer on each of this thread's EPs.
 */
bool
DT_handle_send_op(DT_Tdep_Print_Head * phead,
		  Ep_Context_t * ep_context,
		  unsigned int num_eps, int op_indx, bool poll)
{
	unsigned int i, j;
	unsigned char *completion_reaped;

	completion_reaped = DT_Mdep_Malloc(num_eps * sizeof(unsigned char));

	if (!completion_reaped) {
		return false;
	}

	for (i = 0; i < num_eps; i++) {
		Transaction_Test_Op_t *op = &ep_context[i].op[op_indx];
		DAT_LMR_TRIPLET *iov = DT_Bpool_GetIOV(op->bp, 0);
		DAT_DTO_COOKIE cookie;
		DAT_RETURN ret;

		/* Prep the inputs */
		for (j = 0; j < op->num_segs; j++) {
			iov[j].virtual_address = (DAT_VADDR) (uintptr_t)
			    DT_Bpool_GetBuffer(op->bp, j);
			iov[j].segment_length = op->seg_size;
			iov[j].lmr_context = DT_Bpool_GetLMR(op->bp, j);
		}
		cookie.as_64 = ((((DAT_UINT64) i) << 32)
				| (((uintptr_t) DT_Bpool_GetBuffer(op->bp, 0)) &
				   0xffffffffUL));

		/* Post the send */
		ret = dat_ep_post_send(ep_context[i].ep_handle,
				       op->num_segs,
				       iov,
				       cookie, DAT_COMPLETION_DEFAULT_FLAG);

		if (ret != DAT_SUCCESS) {
			DT_Tdep_PT_Printf(phead,
					  "Test Error: dat_ep_post_send failed: %s\n",
					  DT_RetToString(ret));
			DT_Test_Error();
			DT_Mdep_Free(completion_reaped);
			return false;
		}
	}

	for (i = 0; i < num_eps; i++) {
		Transaction_Test_Op_t *op = &ep_context[i].op[op_indx];

		if (op->reap_send_on_recv && !op->server_initiated) {
			/* we will reap the send on the recv (Client SR) */
			DT_Mdep_Free(completion_reaped);
			return true;
		}
	}

	bzero((void *)completion_reaped, sizeof(unsigned char) * num_eps);

	/* reap the send completion */
	for (i = 0; i < num_eps; i++) {
		Transaction_Test_Op_t *op;
		DAT_DTO_COMPLETION_EVENT_DATA dto_stat;
		DAT_DTO_COOKIE dto_cookie;
		unsigned int epnum;

		if (!DT_dto_event_reap
		    (phead, ep_context[i].reqt_evd_hdl, poll, &dto_stat)) {
			DT_Mdep_Free(completion_reaped);
			return false;
		}

		epnum = dto_stat.user_cookie.as_64 >> 32;
		if (epnum > num_eps) {
			DT_Tdep_PT_Printf(phead,
					  "Test Error: Send: Invalid endpoint completion reaped.\n"
					  "\tEndpoint: 0x%p, Cookie: 0x" F64x
					  ", Length: " F64u "\n",
					  dto_stat.ep_handle,
					  dto_stat.user_cookie.as_64,
					  dto_stat.transfered_length);
			DT_Test_Error();
			DT_Mdep_Free(completion_reaped);
			return false;
		}

		op = &ep_context[epnum].op[op_indx];

		dto_cookie.as_64 = ((((DAT_UINT64) epnum) << 32)
				    |
				    (((uintptr_t) DT_Bpool_GetBuffer(op->bp, 0))
				     & 0xffffffffUL));

		if (!DT_dto_check(phead,
				  &dto_stat,
				  ep_context[epnum].ep_handle,
				  op->num_segs * op->seg_size,
				  dto_cookie, "Send")) {
			DT_Mdep_Free(completion_reaped);
			return false;
		}

		if (completion_reaped[epnum]) {
			DT_Tdep_PT_Printf(phead,
					  "Test Error: Send: Secondary completion seen for endpoint 0x%p (%d)\n",
					  ep_context[epnum].ep_handle, epnum);
			DT_Test_Error();
			DT_Mdep_Free(completion_reaped);
			return (false);
		}
		completion_reaped[epnum] = 1;
	}

	for (i = 0; i < num_eps; i++) {
		if (completion_reaped[i] == 0) {
			DT_Tdep_PT_Printf(phead,
					  "Test Error: Send: No completion seen for endpoint 0x%p (#%d)\n",
					  ep_context[i].ep_handle, i);
			DT_Test_Error();
			DT_Mdep_Free(completion_reaped);
			return (false);
		}
	}

	DT_Mdep_Free(completion_reaped);
	return true;
}

/* -----------------------------------------------------------
 * Reap a recv op on each of this thread's EPs,
 * then if requested reap the corresponding send ops,
 * and re-post all of the recv buffers.
 */
bool
DT_handle_recv_op(DT_Tdep_Print_Head * phead,
		  Ep_Context_t * ep_context,
		  unsigned int num_eps,
		  int op_indx, bool poll, bool repost_recv)
{
	unsigned int i;
	unsigned char *recv_completion_reaped;
	unsigned char *send_completion_reaped;

	recv_completion_reaped = DT_Mdep_Malloc(num_eps);
	if (recv_completion_reaped == NULL) {
		return false;
	}

	send_completion_reaped = DT_Mdep_Malloc(num_eps);
	if (send_completion_reaped == NULL) {
		DT_Mdep_Free(recv_completion_reaped);
		return false;
	}

	/* Foreach EP, reap */
	bzero((void *)recv_completion_reaped, sizeof(unsigned char) * num_eps);
	bzero((void *)send_completion_reaped, sizeof(unsigned char) * num_eps);
	for (i = 0; i < num_eps; i++) {
		Transaction_Test_Op_t *op;
		DAT_DTO_COMPLETION_EVENT_DATA dto_stat;
		DAT_DTO_COOKIE dto_cookie;
		unsigned int epnum;

		/* First reap the recv DTO event */
		if (!DT_dto_event_reap
		    (phead, ep_context[i].recv_evd_hdl, poll, &dto_stat)) {
			DT_Mdep_Free(recv_completion_reaped);
			DT_Mdep_Free(send_completion_reaped);
			return false;
		}

		epnum = dto_stat.user_cookie.as_64 >> 32;
		if (epnum > num_eps) {
			DT_Tdep_PT_Printf(phead,
					  "Test Error: Receive: Invalid endpoint completion reaped.\n"
					  "\tEndpoint: 0x%p, Cookie: 0x" F64x
					  ", Length: " F64u "\n",
					  dto_stat.ep_handle,
					  dto_stat.user_cookie.as_64,
					  dto_stat.transfered_length);
			DT_Test_Error();
			DT_Mdep_Free(recv_completion_reaped);
			DT_Mdep_Free(send_completion_reaped);
			return false;
		}

		op = &ep_context[epnum].op[op_indx];
		dto_cookie.as_64 = ((((DAT_UINT64) epnum) << 32)
				    |
				    (((uintptr_t) DT_Bpool_GetBuffer(op->bp, 0))
				     & 0xffffffffUL));

		if (!DT_dto_check(phead,
				  &dto_stat,
				  ep_context[epnum].ep_handle,
				  op->num_segs * op->seg_size,
				  dto_cookie, "Recv")) {
			DT_Tdep_PT_Printf(phead,
					  "Test Error: recv DTO problem\n");
			DT_Test_Error();
			DT_Mdep_Free(recv_completion_reaped);
			DT_Mdep_Free(send_completion_reaped);
			return false;
		}

		if (recv_completion_reaped[epnum]) {
			DT_Tdep_PT_Printf(phead,
					  "Test Error: Receive: Secondary completion seen for endpoint 0x%p (%d)\n",
					  ep_context[epnum].ep_handle, epnum);
			DT_Test_Error();
			DT_Mdep_Free(recv_completion_reaped);
			DT_Mdep_Free(send_completion_reaped);
			return (false);
		}
		recv_completion_reaped[epnum] = 1;

		/*
		 * Check the current op to see whether we are supposed
		 * to reap the previous send op now.
		 */
		if (op->reap_send_on_recv && op->server_initiated) {
			if (op_indx <= 0)
				/* shouldn't happen, but let's be certain */
			{
				DT_Tdep_PT_Printf(phead,
						  "Internal Error: reap_send_on_recv"
						  " but current op == #%d\n",
						  op_indx);
				DT_Mdep_Free(recv_completion_reaped);
				DT_Mdep_Free(send_completion_reaped);
				return false;
			}

			if (!DT_dto_event_reap
			    (phead, ep_context[i].reqt_evd_hdl, poll,
			     &dto_stat)) {
				DT_Mdep_Free(recv_completion_reaped);
				DT_Mdep_Free(send_completion_reaped);
				return false;
			}

			epnum = dto_stat.user_cookie.as_64 >> 32;
			if (epnum > num_eps) {
				DT_Tdep_PT_Printf(phead,
						  "Test Error: Send (ror): Invalid endpoint completion reaped.\n"
						  "\tEndpoint: 0x%p, Cookie: 0x"
						  F64x ", Length: " F64u "\n",
						  dto_stat.ep_handle,
						  dto_stat.user_cookie.as_64,
						  dto_stat.transfered_length);
				DT_Test_Error();
				DT_Mdep_Free(recv_completion_reaped);
				DT_Mdep_Free(send_completion_reaped);
				return false;
			}

			/*
			 * We're reaping the last transaction, a
			 * send completion that we skipped when it was sent.
			 */
			op = &ep_context[epnum].op[op_indx - 1];

			dto_cookie.as_64 = ((((DAT_UINT64) epnum) << 32)
					    |
					    (((uintptr_t)
					      DT_Bpool_GetBuffer(op->bp, 0))
					     & 0xffffffffUL));

			/*
			 * If we have multiple EPs we can't guarantee the order of
			 * completions, so disable ep_handle check
			 */
			if (!DT_dto_check(phead,
					  &dto_stat,
					  num_eps ==
					  1 ? ep_context[i].ep_handle : NULL,
					  op->num_segs * op->seg_size,
					  dto_cookie, "Send-reaped-on-recv")) {
				DT_Tdep_PT_Printf(phead,
						  "Test Error: send DTO problem\n");
				DT_Test_Error();
				DT_Mdep_Free(recv_completion_reaped);
				DT_Mdep_Free(send_completion_reaped);
				return false;
			}

			if (send_completion_reaped[epnum]) {
				DT_Tdep_PT_Printf(phead,
						  "Test Error: Send (ror): Secondary completion seen for endpoint 0x%p (%d)\n",
						  ep_context[epnum].ep_handle,
						  epnum);
				DT_Test_Error();
				DT_Mdep_Free(recv_completion_reaped);
				DT_Mdep_Free(send_completion_reaped);
				return (false);
			}
			send_completion_reaped[epnum] = 1;
		}
	}

	for (i = 0; i < num_eps; i++) {
		if (recv_completion_reaped[i] == 0) {
			DT_Tdep_PT_Printf(phead,
					  "Test Error: Receive: No completion seen for endpoint 0x%p (#%d)\n",
					  ep_context[i].ep_handle, i);
			DT_Test_Error();
			DT_Mdep_Free(recv_completion_reaped);
			DT_Mdep_Free(send_completion_reaped);
			return (false);
		}
	}

	if (ep_context[0].op[op_indx].reap_send_on_recv
	    && ep_context[0].op[op_indx].server_initiated) {
		for (i = 0; i < num_eps; i++) {
			if (send_completion_reaped[i] == 0) {
				DT_Tdep_PT_Printf(phead,
						  "Test Error: Send (ror): No completion seen for endpoint 0x%p (#%d)\n",
						  ep_context[i].ep_handle, i);
				DT_Test_Error();
				DT_Mdep_Free(recv_completion_reaped);
				DT_Mdep_Free(send_completion_reaped);
				return (false);
			}
		}
	}

	if (repost_recv) {
		/* repost the receive buffer */
		if (!DT_handle_post_recv_buf
		    (phead, ep_context, num_eps, op_indx)) {
			DT_Tdep_PT_Printf(phead,
					  "Test Error: recv re-post problem\n");
			DT_Test_Error();
			DT_Mdep_Free(recv_completion_reaped);
			DT_Mdep_Free(send_completion_reaped);
			return false;
		}
	}

	DT_Mdep_Free(recv_completion_reaped);
	DT_Mdep_Free(send_completion_reaped);
	return true;
}

/* -----------------------------------------------------------
 * Initiate an RDMA op (synchronous) on each of this thread's EPs.
 */
bool
DT_handle_rdma_op(DT_Tdep_Print_Head * phead,
		  Ep_Context_t * ep_context,
		  unsigned int num_eps,
		  DT_Transfer_Type opcode, int op_indx, bool poll)
{
	unsigned int i, j;
	DAT_RETURN ret;
	unsigned char *completion_reaped;

	completion_reaped = DT_Mdep_Malloc(num_eps * sizeof(unsigned char));

	if (!completion_reaped) {
		return false;
	}

	/* Initiate the operation */
	for (i = 0; i < num_eps; i++) {
		Transaction_Test_Op_t *op = &ep_context[i].op[op_indx];
		DAT_LMR_TRIPLET *iov = DT_Bpool_GetIOV(op->bp, 0);
		DAT_DTO_COOKIE cookie;
		DAT_RMR_TRIPLET rmr_triplet;

		/* Prep the inputs */
		for (j = 0; j < op->num_segs; j++) {
			iov[j].virtual_address = (DAT_VADDR) (uintptr_t)
			    DT_Bpool_GetBuffer(op->bp, j);
			iov[j].segment_length = op->seg_size;
			iov[j].lmr_context = DT_Bpool_GetLMR(op->bp, j);
		}
		cookie.as_64 = ((((DAT_UINT64) i) << 32)
				| (((uintptr_t) DT_Bpool_GetBuffer(op->bp, 0)) &
				   0xffffffffUL));

		rmr_triplet.virtual_address =
		    (DAT_VADDR) (uintptr_t) op->Rdma_Address;
		rmr_triplet.segment_length = op->seg_size * op->num_segs;
		rmr_triplet.rmr_context = op->Rdma_Context;

		DT_Tdep_PT_Debug(3, (phead,
				     "Call dat_ep_post_rdma_%s [" F64x ", sz="
				     F64x ", ctxt=%x]\n",
				     (opcode == RDMA_WRITE ? "write" : "read"),
				     rmr_triplet.virtual_address,
				     rmr_triplet.segment_length,
				     rmr_triplet.rmr_context));

		/* Post the operation */
		if (opcode == RDMA_WRITE) {

			ret = dat_ep_post_rdma_write(ep_context[i].ep_handle,
						     op->num_segs,
						     iov,
						     cookie,
						     &rmr_triplet,
						     DAT_COMPLETION_DEFAULT_FLAG);

		} else {	/* opcode == RDMA_READ */

			ret = dat_ep_post_rdma_read(ep_context[i].ep_handle,
						    op->num_segs,
						    iov,
						    cookie,
						    &rmr_triplet,
						    DAT_COMPLETION_DEFAULT_FLAG);

		}
		if (ret != DAT_SUCCESS) {
			DT_Tdep_PT_Printf(phead,
					  "Test Error: dat_ep_post_rdma_%s failed: %s\n",
					  (opcode ==
					   RDMA_WRITE ? "write" : "read"),
					  DT_RetToString(ret));
			DT_Test_Error();
			DT_Mdep_Free(completion_reaped);
			return (false);
		} else {
			DT_Tdep_PT_Debug(3, (phead,
					     "Done dat_ep_post_rdma_%s %s\n",
					     (opcode ==
					      RDMA_WRITE ? "write" : "read"),
					     " ()  Waiting ..."));
		}
	}

	bzero((void *)completion_reaped, sizeof(unsigned char) * num_eps);
	/* Wait for it to happen */
	for (i = 0; i < num_eps; i++) {
		Transaction_Test_Op_t *op;
		DAT_DTO_COMPLETION_EVENT_DATA dto_stat;
		DAT_DTO_COOKIE dto_cookie;
		unsigned int epnum;

		if (!DT_dto_event_reap
		    (phead, ep_context[i].reqt_evd_hdl, poll, &dto_stat)) {
			DT_Mdep_Free(completion_reaped);
			return (false);
		}

		epnum = dto_stat.user_cookie.as_64 >> 32;
		if (epnum > num_eps) {
			DT_Tdep_PT_Printf(phead,
					  "Test Error: %s: Invalid endpoint completion reaped.\n"
					  "\tEndpoint: 0x%p, Cookie: 0x" F64x
					  ", Length: " F64u "\n",
					  opcode ==
					  RDMA_WRITE ? "RDMA/WR" : "RDMA/RD",
					  dto_stat.ep_handle,
					  dto_stat.user_cookie.as_64,
					  dto_stat.transfered_length);
			DT_Test_Error();
			DT_Mdep_Free(completion_reaped);
			return false;
		}
		op = &ep_context[epnum].op[op_indx];

		dto_cookie.as_64 = ((((DAT_UINT64) epnum) << 32)
				    |
				    (((uintptr_t) DT_Bpool_GetBuffer(op->bp, 0))
				     & 0xffffffffUL));

		if (!DT_dto_check(phead,
				  &dto_stat,
				  ep_context[epnum].ep_handle,
				  op->num_segs * op->seg_size,
				  dto_cookie,
				  (opcode ==
				   RDMA_WRITE ? "RDMA/WR" : "RDMA/RD"))) {
			DT_Mdep_Free(completion_reaped);
			return (false);
		}

		if (completion_reaped[epnum]) {
			DT_Tdep_PT_Printf(phead,
					  "Test Error: %s: Secondary completion seen for endpoint 0x%p (%d)\n",
					  opcode ==
					  RDMA_WRITE ? "RDMA/WR" : "RDMA/RD",
					  ep_context[epnum].ep_handle, epnum);
			DT_Test_Error();
			DT_Mdep_Free(completion_reaped);
			return (false);
		}
		completion_reaped[epnum] = 1;

		DT_Tdep_PT_Debug(3, (phead,
				     "dat_ep_post_rdma_%s OK\n",
				     (opcode ==
				      RDMA_WRITE ? "RDMA/WR" : "RDMA/RD")));
	}

	for (i = 0; i < num_eps; i++) {
		if (completion_reaped[i] == 0) {
			DT_Tdep_PT_Printf(phead,
					  "Test Error: %s: No completion seen for endpoint 0x%p (#%d)\n",
					  opcode ==
					  RDMA_WRITE ? "RDMA/WR" : "RDMA/RD",
					  ep_context[i].ep_handle, i);
			DT_Test_Error();
			DT_Mdep_Free(completion_reaped);
			return (false);
		}
	}

	DT_Mdep_Free(completion_reaped);

	return (true);
}

/* -----------------------------------------------------------
 * Verify whether we (the client side) can support
 * the requested 'T' test.
 */
bool DT_check_params(Per_Test_Data_t * pt_ptr, char *module)
{
	Transaction_Cmd_t *cmd = &pt_ptr->Params.u.Transaction_Cmd;
	unsigned long num_recvs = 0U;
	unsigned long num_sends = 0U;
	unsigned long num_rdma_rd = 0U;
	unsigned long num_rdma_wr = 0U;
	unsigned long max_size = 0U;
	unsigned long max_segs = 0U;
	bool rval = true;
	unsigned int i;
	DT_Tdep_Print_Head *phead;

	phead = pt_ptr->Params.phead;

	/* Count up what's requested (including -V appended sync points) */
	for (i = 0; i < cmd->num_ops; i++) {
		unsigned int xfer_size;

		xfer_size = cmd->op[i].num_segs * cmd->op[i].seg_size;
		if (xfer_size > max_size) {
			max_size = xfer_size;
		}
		if (cmd->op[i].num_segs > max_segs) {
			max_segs = cmd->op[i].num_segs;
		}

		switch (cmd->op[i].transfer_type) {
		case SEND_RECV:
			{
				if (cmd->op[i].server_initiated) {
					num_recvs++;
				} else {
					num_sends++;
				}
				break;
			}

		case RDMA_READ:
			{
				num_rdma_rd++;
				break;
			}

		case RDMA_WRITE:
			{
				num_rdma_wr++;
				break;
			}
		}
	}

	/*
	 * Now check the IA and EP attributes, and check for some of the
	 * more obvious resource problems.  This is hardly exhaustive,
	 * and some things will inevitably fall through to run-time.
	 *
	 * We don't compare
	 *      num_rdma_rd > pt_ptr->ia_attr.max_rdma_read_per_ep
	 *      num_rdma_wr > pt_ptr->ia_attr.max_dto_per_ep
	 * because each thread has its own EPs, and transfers are issued
	 * synchronously (across a thread's EPs, and ignoring -f, which allows
	 * a per-EP pipeline depth of at most 2 and applies only to SR ops),
	 * so dapltest actually attempts almost no pipelining on a single EP.
	 * But we do check that pre-posted recv buffers will all fit.
	 */
	if (num_recvs > pt_ptr->ia_attr.max_dto_per_ep ||
	    num_sends > pt_ptr->ia_attr.max_dto_per_ep) {
		DT_Tdep_PT_Printf(phead,
				  "%s: S/R: cannot supply %ld SR ops (maximum: %d)\n",
				  module,
				  num_recvs > num_sends ? num_recvs : num_sends,
				  pt_ptr->ia_attr.max_dto_per_ep);
		rval = false;
	}
	if (max_size > pt_ptr->ia_attr.max_lmr_block_size) {
		DT_Tdep_PT_Printf(phead,
				  "%s: buffer too large: 0x%lx (maximum: " F64x
				  " bytes)\n", module, max_size,
				  pt_ptr->ia_attr.max_lmr_block_size);
		rval = false;
	}
	if (max_segs > pt_ptr->ep_attr.max_recv_iov ||
	    max_segs > pt_ptr->ep_attr.max_request_iov) {
		/*
		 * In an ideal world, we'd just ask for more segments
		 * when creating the EPs for the test, rather than
		 * checking against default EP attributes.
		 */
		DT_Tdep_PT_Printf(phead,
				  "%s: cannot use %ld segments (maxima: S %d, R %d)\n",
				  module,
				  max_segs,
				  pt_ptr->ep_attr.max_request_iov,
				  pt_ptr->ep_attr.max_recv_iov);
		rval = false;
	}

	return (rval);
}

/* Empty function in which to set breakpoints.  */
void DT_Test_Error(void)
{
	;
}

void
DT_Transaction_Cmd_PT_Print(DT_Tdep_Print_Head * phead, Transaction_Cmd_t * cmd)
{
	unsigned int i;
	DT_Tdep_PT_Printf(phead, "-------------------------------------\n");
	DT_Tdep_PT_Printf(phead, "TransCmd.server_name              : %s\n",
			  cmd->server_name);
	DT_Tdep_PT_Printf(phead, "TransCmd.num_iterations           : %d\n",
			  cmd->num_iterations);
	DT_Tdep_PT_Printf(phead, "TransCmd.num_threads              : %d\n",
			  cmd->num_threads);
	DT_Tdep_PT_Printf(phead, "TransCmd.eps_per_thread           : %d\n",
			  cmd->eps_per_thread);
	DT_Tdep_PT_Printf(phead, "TransCmd.validate                 : %d\n",
			  cmd->validate);
	DT_Tdep_PT_Printf(phead, "TransCmd.dapl_name                : %s\n",
			  cmd->dapl_name);
	DT_Tdep_PT_Printf(phead, "TransCmd.num_ops                  : %d\n",
			  cmd->num_ops);

	for (i = 0; i < cmd->num_ops; i++) {
		DT_Tdep_PT_Printf(phead,
				  "TransCmd.op[%d].transfer_type      : %s %s\n",
				  i,
				  cmd->op[i].transfer_type ==
				  0 ? "RDMA_READ" : cmd->op[i].transfer_type ==
				  1 ? "RDMA_WRITE" : "SEND_RECV",
				  cmd->op[i].
				  server_initiated ? " (server)" : " (client)");
		DT_Tdep_PT_Printf(phead,
				  "TransCmd.op[%d].seg_size           : %d\n",
				  i, cmd->op[i].seg_size);
		DT_Tdep_PT_Printf(phead,
				  "TransCmd.op[%d].num_segs           : %d\n",
				  i, cmd->op[i].num_segs);
		DT_Tdep_PT_Printf(phead,
				  "TransCmd.op[%d].reap_send_on_recv  : %d\n",
				  i, cmd->op[i].reap_send_on_recv);
	}
}
