[openib-general] [PATCHv4] kdapl: remove use of HANDLE's (vs. r2572)

Tom Duffy tduffy at sun.com
Wed Jun 8 11:05:07 PDT 2005


On Wed, 2005-06-08 at 12:35 -0400, James Lentini wrote:
> Committed in revision 2572.

Updated patch against 2572.

Signed-off-by: Tom Duffy <tduffy at sun.com>

Index: linux-kernel/test/dapltest/test/dapl_performance_util.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_performance_util.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_performance_util.c	(working copy)
@@ -33,7 +33,7 @@
 boolean_t
 DT_Performance_Test_Create (
     Per_Test_Data_t 		*pt_ptr,
-    DAT_IA_HANDLE 		ia_handle,
+    struct dat_ia		*ia,
     struct sockaddr *		remote_ia_addr,
     boolean_t 		is_server,
     boolean_t			is_remote_little_endian,
@@ -61,10 +61,10 @@ DT_Performance_Test_Create (
     test_ptr->remote_ia_addr = remote_ia_addr;
     test_ptr->is_remote_little_endian = is_remote_little_endian;
     test_ptr->base_port = (DAT_CONN_QUAL) pt_ptr->Server_Info.first_port_number;
-    test_ptr->ia_handle = ia_handle;
+    test_ptr->ia = ia;
     test_ptr->cmd = &pt_ptr->Params.u.Performance_Cmd;
 
-    ret = dat_ia_query (test_ptr->ia_handle,
+    ret = dat_ia_query (test_ptr->ia,
 			NULL,
 			&test_ptr->ia_attr,
 			NULL);
@@ -95,17 +95,17 @@ DT_Performance_Test_Create (
     test_ptr->creq_evd_length = DT_PERF_DFLT_EVD_LENGTH;
 
     /* create a protection zone */
-    ret = dat_pz_create (test_ptr->ia_handle, &test_ptr->pz_handle);
+    ret = dat_pz_create (test_ptr->ia, &test_ptr->pz);
     if ( DAT_SUCCESS != ret)
     {
 	DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_pz_create error: %s\n",
 		       test_ptr->base_port, DT_RetToString (ret));
-	test_ptr->pz_handle = DAT_HANDLE_NULL;
+	test_ptr->pz = NULL;
 	return FALSE;
     }
 
     /* create 4 EVDs - recv, request+RMR, conn-request, connect */
-    ret = DT_Tdep_evd_create (test_ptr->ia_handle,
+    ret = DT_Tdep_evd_create (test_ptr->ia,
 			  test_ptr->recv_evd_length,
 			  test_ptr->cno_handle,
 			  DAT_EVD_DTO_FLAG,
@@ -114,11 +114,11 @@ DT_Performance_Test_Create (
     {
 	DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_evd_create (recv) error: %s\n",
 		       test_ptr->base_port, DT_RetToString (ret));
-	test_ptr->recv_evd_hdl = DAT_HANDLE_NULL;
+	test_ptr->recv_evd_hdl = NULL;
 	return FALSE;
     }
 
-    ret = DT_Tdep_evd_create (test_ptr->ia_handle,
+    ret = DT_Tdep_evd_create (test_ptr->ia,
 			  test_ptr->reqt_evd_length,
 			  test_ptr->cno_handle,
 			  DAT_EVD_DTO_FLAG | DAT_EVD_RMR_BIND_FLAG,
@@ -127,7 +127,7 @@ DT_Performance_Test_Create (
     {
 	DT_Tdep_PT_Printf (phead, "Test[" F64x "]: 0x%x dat_evd_create (request) error: %s\n",
 		       test_ptr->reqt_evd_length,test_ptr->base_port, DT_RetToString (ret));
-	test_ptr->reqt_evd_hdl = DAT_HANDLE_NULL;
+	test_ptr->reqt_evd_hdl = NULL;
 	return FALSE;
     }
 
@@ -135,30 +135,30 @@ DT_Performance_Test_Create (
     if ( is_server )
     {
 	/* Client-side doesn't need CR events */
-	ret = DT_Tdep_evd_create (test_ptr->ia_handle,
+	ret = DT_Tdep_evd_create (test_ptr->ia,
 			      test_ptr->creq_evd_length,
-			      DAT_HANDLE_NULL,
+			      NULL,
 			      DAT_EVD_CR_FLAG,
 			      &test_ptr->creq_evd_hdl);	 /* cr */
 	if ( DAT_SUCCESS != ret)
 	{
 	    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_evd_create (cr) error: %s\n",
 			   test_ptr->base_port, DT_RetToString (ret));
-	    test_ptr->creq_evd_hdl = DAT_HANDLE_NULL;
+	    test_ptr->creq_evd_hdl = NULL;
 	    return FALSE;
 	}
     }
 
-    ret = DT_Tdep_evd_create (test_ptr->ia_handle,
+    ret = DT_Tdep_evd_create (test_ptr->ia,
 			  test_ptr->conn_evd_length,
-			  DAT_HANDLE_NULL,
+			  NULL,
 			  DAT_EVD_CONNECTION_FLAG,
 			  &test_ptr->conn_evd_hdl);  /* conn */
     if ( DAT_SUCCESS != ret)
     {
 	DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_evd_create (conn) error: %s\n",
 		       test_ptr->base_port, DT_RetToString (ret));
-	test_ptr->conn_evd_hdl = DAT_HANDLE_NULL;
+	test_ptr->conn_evd_hdl = NULL;
 	return FALSE;
     }
 
@@ -176,18 +176,18 @@ DT_Performance_Test_Create (
     test_ptr->ep_context.ep_attr.max_request_dtos = pipeline_len;
 
     /* Create EP */
-    ret = dat_ep_create (test_ptr->ia_handle,	 /* IA       */
-			 test_ptr->pz_handle,	 /* PZ       */
+    ret = dat_ep_create (test_ptr->ia,	 /* IA       */
+			 test_ptr->pz,	 /* PZ       */
 			 test_ptr->recv_evd_hdl, /* recv     */
 			 test_ptr->reqt_evd_hdl, /* request  */
 			 test_ptr->conn_evd_hdl, /* connect  */
 			 &test_ptr->ep_context.ep_attr, /* EP attrs */
-			 &test_ptr->ep_context.ep_handle);
+			 &test_ptr->ep_context.ep);
     if ( DAT_SUCCESS != ret)
     {
 	DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_ep_create error: %s\n",
 		       test_ptr->base_port, DT_RetToString (ret));
-	test_ptr->ep_context.ep_handle = DAT_HANDLE_NULL;
+	test_ptr->ep_context.ep = NULL;
 	return FALSE;
     }
 
@@ -197,10 +197,10 @@ DT_Performance_Test_Create (
      */
     test_ptr->ep_context.bp = DT_BpoolAlloc (test_ptr->pt_ptr,
 	    				    phead,
-					    test_ptr->ia_handle,
-					    test_ptr->pz_handle,
-					    test_ptr->ep_context.ep_handle,
-					    DAT_HANDLE_NULL, /* rmr */
+					    test_ptr->ia,
+					    test_ptr->pz,
+					    test_ptr->ep_context.ep,
+					    NULL, /* rmr */
 					    DT_PERF_SYNC_BUFF_SIZE,
 					    2, /* 2 RMIs */
 					    255, /* FIXME should query for this */
@@ -226,7 +226,7 @@ DT_Performance_Test_Create (
      * Post recv and sync buffers
      */
     if ( !DT_post_recv_buffer (phead,
-			      test_ptr->ep_context.ep_handle,
+			      test_ptr->ep_context.ep,
 			      test_ptr->ep_context.bp,
 			      DT_PERF_SYNC_RECV_BUFFER_ID,
 			      DT_PERF_SYNC_BUFF_SIZE) )
@@ -269,13 +269,13 @@ DT_Performance_Test_Destroy (
     boolean_t 		is_server)
 {
     u32 			ret;
-    DAT_EP_HANDLE               ep_handle;
+    struct dat_ep *              ep;
     DT_Tdep_Print_Head		*phead;
     int 			status = 0;
 
     phead = pt_ptr->Params.phead;
 
-    ep_handle = DAT_HANDLE_NULL;
+    ep = NULL;
 
     /* Free the per-op buffers */
     if (test_ptr->ep_context.op.bp)
@@ -310,9 +310,9 @@ DT_Performance_Test_Destroy (
      *		     bailed out mid-setup, or ran to completion
      *		     normally, so we use abrupt closure.
      */
-    if (test_ptr->ep_context.ep_handle)
+    if (test_ptr->ep_context.ep)
     {
-	ret = dat_ep_disconnect (test_ptr->ep_context.ep_handle,
+	ret = dat_ep_disconnect (test_ptr->ep_context.ep,
 				DAT_CLOSE_ABRUPT_FLAG);
 	if (ret != DAT_SUCCESS)
 	{
@@ -323,7 +323,7 @@ DT_Performance_Test_Destroy (
             status = 1;
 	}
 	else if (!DT_disco_event_wait ( phead, test_ptr->conn_evd_hdl,
-				       &ep_handle))
+				       &ep))
 	{
 	    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: bad disconnect event\n",
 			    test_ptr->base_port);
@@ -331,10 +331,10 @@ DT_Performance_Test_Destroy (
 	}
     }
 
-    if ( DAT_HANDLE_NULL != ep_handle)
+    if ( NULL != ep)
     {
 	/* Destroy the EP */
-	ret = dat_ep_free (ep_handle);
+	ret = dat_ep_free (ep);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_ep_free error: %s\n",
@@ -394,9 +394,9 @@ DT_Performance_Test_Destroy (
     }
 
     /* clean up the PZ */
-    if (test_ptr->pz_handle)
+    if (test_ptr->pz)
     {
-	ret = dat_pz_free (test_ptr->pz_handle);
+	ret = dat_pz_free (test_ptr->pz);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_pz_free error: %s\n",
@@ -417,7 +417,7 @@ DT_Performance_Test_Destroy (
 boolean_t
 DT_performance_post_rdma_op (
     Performance_Ep_Context_t 	*ep_context,
-    DAT_EVD_HANDLE 		reqt_evd_hdl,
+    struct dat_evd *		reqt_evd_hdl,
     Performance_Stats_t 	*stats)
 {
     unsigned int 		j;
@@ -456,7 +456,7 @@ DT_performance_post_rdma_op (
 	pre_ctxt_num = DT_Mdep_GetContextSwitchNum ();
 	pre_ts = DT_Mdep_GetTimeStamp ();
 
-	ret = dat_ep_post_rdma_write (ep_context->ep_handle,
+	ret = dat_ep_post_rdma_write (ep_context->ep,
 				     op->num_segs,
 				     iov,
 				     cookie,
@@ -473,7 +473,7 @@ DT_performance_post_rdma_op (
 	pre_ctxt_num = DT_Mdep_GetContextSwitchNum ();
 	pre_ts = DT_Mdep_GetTimeStamp ();
 
-	ret = dat_ep_post_rdma_read (ep_context->ep_handle,
+	ret = dat_ep_post_rdma_read (ep_context->ep,
 				    op->num_segs,
 				    iov,
 				    cookie,
@@ -502,17 +502,17 @@ DT_performance_post_rdma_op (
 unsigned int
 DT_performance_reap (
     DT_Tdep_Print_Head			*phead,
-    DAT_EVD_HANDLE 			evd_handle,
+    struct dat_evd *			evd,
     Performance_Mode_Type		mode,
     Performance_Stats_t 		*stats)
 {
     if ( BLOCKING_MODE == mode )
     {
-	return DT_performance_wait (phead, evd_handle, stats);
+	return DT_performance_wait (phead, evd, stats);
     }
     else
     {
-	return DT_performance_poll (phead, evd_handle, stats);
+	return DT_performance_poll (phead, evd, stats);
     }
 }
 
@@ -520,7 +520,7 @@ DT_performance_reap (
 unsigned int
 DT_performance_wait (
     DT_Tdep_Print_Head			*phead,
-    DAT_EVD_HANDLE 			evd_handle,
+    struct dat_evd *			evd,
     Performance_Stats_t 		*stats)
 {
     int			i;
@@ -537,7 +537,7 @@ DT_performance_wait (
     pre_ctxt_num = DT_Mdep_GetContextSwitchNum ();
     pre_ts = DT_Mdep_GetTimeStamp ();
 
-    ret = DT_Tdep_evd_wait ( evd_handle,
+    ret = DT_Tdep_evd_wait ( evd,
 			DAT_TIMEOUT_MAX,
 			&event);
 
@@ -571,7 +571,7 @@ DT_performance_wait (
 	pre_ctxt_num = DT_Mdep_GetContextSwitchNum ();
 	pre_ts = DT_Mdep_GetTimeStamp ();
 
-	ret = DT_Tdep_evd_dequeue ( evd_handle,
+	ret = DT_Tdep_evd_dequeue ( evd,
 			       &event);
 
 	post_ts = DT_Mdep_GetTimeStamp ();
@@ -611,7 +611,7 @@ DT_performance_wait (
 unsigned int
 DT_performance_poll (
     DT_Tdep_Print_Head			*phead,
-    DAT_EVD_HANDLE 			evd_handle,
+    struct dat_evd *			evd,
     Performance_Stats_t 		*stats)
 {
     u32      		ret;
@@ -626,7 +626,7 @@ DT_performance_poll (
 	pre_ctxt_num = DT_Mdep_GetContextSwitchNum ();
 	pre_ts = DT_Mdep_GetTimeStamp ();
 
-	ret = DT_Tdep_evd_dequeue ( evd_handle,
+	ret = DT_Tdep_evd_dequeue ( evd,
 			       &event);
 
 	post_ts = DT_Mdep_GetTimeStamp ();
Index: linux-kernel/test/dapltest/test/dapl_performance_client.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_performance_client.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_performance_client.c	(working copy)
@@ -34,7 +34,7 @@ int
 DT_Performance_Test_Client (
     Params_t		*params_ptr,
     Per_Test_Data_t 	*pt_ptr,
-    DAT_IA_HANDLE  	ia_handle,
+    struct dat_ia	*ia,
     struct sockaddr *	remote_ia_addr)
 {
     Performance_Test_t 		*test_ptr = NULL;
@@ -47,7 +47,7 @@ DT_Performance_Test_Client (
     DT_Tdep_PT_Debug (1,(phead,"Client: Starting performance test\n"));
 
     if ( !DT_Performance_Test_Create (pt_ptr,
-				     ia_handle,
+				     ia,
 				     remote_ia_addr,
 				     FALSE,
 				     pt_ptr->Server_Info.is_little_endian,
@@ -102,7 +102,7 @@ DT_Performance_Test_Client_Connect (
 		   test_ptr->base_port, test_ptr->ep_context.port));
 
 retry:
-    ret = dat_ep_connect (test_ptr->ep_context.ep_handle,
+    ret = dat_ep_connect (test_ptr->ep_context.ep,
 			 test_ptr->remote_ia_addr,
 			 test_ptr->ep_context.port,
 			 DAT_TIMEOUT_MAX,
@@ -119,7 +119,7 @@ retry:
 
     /* wait for DAT_CONNECTION_EVENT_ESTABLISHED */
     if (!DT_conn_event_wait (phead, 
-			     test_ptr->ep_context.ep_handle,
+			     test_ptr->ep_context.ep,
 			     test_ptr->conn_evd_hdl,
 			     &event_num))
     {
@@ -296,7 +296,7 @@ DT_Performance_Test_Client_Phase2 (
 	{
 	    pre_ts = DT_Mdep_GetTimeStamp ();
 
-	    ret = dat_ep_post_rdma_write (ep_context->ep_handle,
+	    ret = dat_ep_post_rdma_write (ep_context->ep,
 					  op->num_segs,
 					  iov,
 					  cookie,
@@ -307,7 +307,7 @@ DT_Performance_Test_Client_Phase2 (
 	{
 	    pre_ts = DT_Mdep_GetTimeStamp ();
 
-	    ret = dat_ep_post_rdma_read (ep_context->ep_handle,
+	    ret = dat_ep_post_rdma_read (ep_context->ep,
 					 op->num_segs,
 					 iov,
 					 cookie,
@@ -374,9 +374,9 @@ DT_Performance_Test_Client_Exchange (
     test_ptr->ep_context.op.bp =
 	DT_BpoolAlloc (test_ptr->pt_ptr,
 		      phead,
-		      test_ptr->ia_handle,
-		      test_ptr->pz_handle,
-		      test_ptr->ep_context.ep_handle,
+		      test_ptr->ia,
+		      test_ptr->pz,
+		      test_ptr->ep_context.ep,
 		      test_ptr->reqt_evd_hdl,
 		      test_ptr->ep_context.op.seg_size,
 		      test_ptr->ep_context.op.num_segs,
@@ -405,7 +405,7 @@ DT_Performance_Test_Client_Exchange (
     if ( !DT_dto_event_wait (phead, test_ptr->recv_evd_hdl, &dto_stat) ||
 	 !DT_dto_check ( phead,
 	     		&dto_stat,
-			test_ptr->ep_context.ep_handle,
+			test_ptr->ep_context.ep,
 			DT_PERF_SYNC_BUFF_SIZE,
 			dto_cookie,
 			"Recieve Sync_Msg") )
@@ -460,7 +460,7 @@ DT_Performance_Test_Client_Exchange (
     DT_Tdep_PT_Debug (1,(phead,"Test[" F64x "]: Sending Sync Msg\n", test_ptr->base_port));
 
     if (!DT_post_send_buffer (phead,
-			     test_ptr->ep_context.ep_handle,
+			     test_ptr->ep_context.ep,
 			     test_ptr->ep_context.bp,
 			     DT_PERF_SYNC_SEND_BUFFER_ID,
 			     DT_PERF_SYNC_BUFF_SIZE))
@@ -477,7 +477,7 @@ DT_Performance_Test_Client_Exchange (
     if (!DT_dto_event_wait (phead, test_ptr->reqt_evd_hdl, &dto_stat) ||
 	!DT_dto_check ( phead,
 	    		&dto_stat,
-		       test_ptr->ep_context.ep_handle,
+		       test_ptr->ep_context.ep,
 		       DT_PERF_SYNC_BUFF_SIZE,
 		       dto_cookie,
 		       "Client_Sync_Send"))
Index: linux-kernel/test/dapltest/test/dapl_cnxn.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_cnxn.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_cnxn.c	(working copy)
@@ -29,7 +29,7 @@
 
 /****************************************************************************/
 int
-get_ep_connection_state (DT_Tdep_Print_Head *phead, DAT_EP_HANDLE ep_handle)
+get_ep_connection_state (DT_Tdep_Print_Head *phead, struct dat_ep *ep)
 {
     enum dat_ep_state    ep_state;
     boolean_t     in_dto_idle;
@@ -39,7 +39,7 @@ get_ep_connection_state (DT_Tdep_Print_H
     char           *req_status = "Idle";
 
 
-    ret = dat_ep_get_status (ep_handle, &ep_state, &in_dto_idle,
+    ret = dat_ep_get_status (ep, &ep_state, &in_dto_idle,
 				&out_dto_idle);
     if (ret != 0)
     {
Index: linux-kernel/test/dapltest/test/dapl_server.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_server.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_server.c	(working copy)
@@ -103,7 +103,7 @@ DT_cs_Server (Params_t * params_ptr)
     ret = dat_ia_open (Server_Cmd->dapl_name,
 		      DFLT_QLEN,
 		      &ps_ptr->async_evd_hdl,
-		      &ps_ptr->ia_handle);
+		      &ps_ptr->ia);
     if (ret != DAT_SUCCESS)
     {
 	DT_Tdep_PT_Printf (phead, 
@@ -111,28 +111,28 @@ DT_cs_Server (Params_t * params_ptr)
 		    module,
 		    Server_Cmd->dapl_name,
 		    DT_RetToString (ret));
-	ps_ptr->ia_handle = DAT_HANDLE_NULL;
+	ps_ptr->ia = NULL;
         status = 1;
 	goto server_exit;
     }
     DT_Tdep_PT_Debug (1,(phead,"%s: IA %s opened\n", module, Server_Cmd->dapl_name));
 
     /* Create a PZ */
-    ret = dat_pz_create (ps_ptr->ia_handle, &ps_ptr->pz_handle);
+    ret = dat_pz_create (ps_ptr->ia, &ps_ptr->pz);
     if (ret != DAT_SUCCESS)
     {
 	DT_Tdep_PT_Printf (phead, 
 		    "%s: dat_pz_create error: %s\n",
 		    module,
 		    DT_RetToString (ret));
-	ps_ptr->pz_handle = DAT_HANDLE_NULL;
+	ps_ptr->pz = NULL;
         status = 1;
 	goto server_exit;
     }
     DT_Tdep_PT_Debug (1,(phead,"%s: PZ created\n", module));
 
     /* Create 4 events - recv, request, connection-request, connect */
-    ret = DT_Tdep_evd_create (ps_ptr->ia_handle,
+    ret = DT_Tdep_evd_create (ps_ptr->ia,
 			 DFLT_QLEN,
 			 NULL,
 			 DAT_EVD_DTO_FLAG,
@@ -142,11 +142,11 @@ DT_cs_Server (Params_t * params_ptr)
 	DT_Tdep_PT_Printf (phead, 
 		    "%s: dat_evd_create (recv) failed %s\n",
 		    module, DT_RetToString (ret));
-	ps_ptr->recv_evd_hdl = DAT_HANDLE_NULL;
+	ps_ptr->recv_evd_hdl = NULL;
         status = 1;
 	goto server_exit;
     }
-    ret = DT_Tdep_evd_create (ps_ptr->ia_handle,
+    ret = DT_Tdep_evd_create (ps_ptr->ia,
 			 DFLT_QLEN,
 			 NULL,
 			 DAT_EVD_DTO_FLAG | DAT_EVD_RMR_BIND_FLAG,
@@ -156,11 +156,11 @@ DT_cs_Server (Params_t * params_ptr)
 	DT_Tdep_PT_Printf (phead, 
 		    "%s: dat_evd_create (send) failed %s\n",
 		    module, DT_RetToString (ret));
-	ps_ptr->reqt_evd_hdl = DAT_HANDLE_NULL;
+	ps_ptr->reqt_evd_hdl = NULL;
         status = 1;
 	goto server_exit;
     }
-    ret = DT_Tdep_evd_create (ps_ptr->ia_handle,
+    ret = DT_Tdep_evd_create (ps_ptr->ia,
 			 DFLT_QLEN,
 			 NULL,
 			 DAT_EVD_CR_FLAG,
@@ -170,11 +170,11 @@ DT_cs_Server (Params_t * params_ptr)
 	DT_Tdep_PT_Printf (phead, 
 		    "%s: dat_evd_create (cr) failed %s\n",
 		    module, DT_RetToString (ret));
-	ps_ptr->creq_evd_hdl = DAT_HANDLE_NULL;
+	ps_ptr->creq_evd_hdl = NULL;
         status = 1;
 	goto server_exit;
     }
-    ret = DT_Tdep_evd_create (ps_ptr->ia_handle,
+    ret = DT_Tdep_evd_create (ps_ptr->ia,
 			 DFLT_QLEN,
 			 NULL,
 			 DAT_EVD_CONNECTION_FLAG,
@@ -184,44 +184,44 @@ DT_cs_Server (Params_t * params_ptr)
 	DT_Tdep_PT_Printf (phead, 
 		    "%s: dat_evd_create (conn) failed %s\n",
 		    module, DT_RetToString (ret));
-	ps_ptr->conn_evd_hdl = DAT_HANDLE_NULL;
+	ps_ptr->conn_evd_hdl = NULL;
         status = 1;
 	goto server_exit;
     }
 
     /* Create the EP */
-    ret = dat_ep_create (ps_ptr->ia_handle,	 /* IA       */
-			 ps_ptr->pz_handle,	 /* PZ       */
+    ret = dat_ep_create (ps_ptr->ia,	 /* IA       */
+			 ps_ptr->pz,	 /* PZ       */
 			 ps_ptr->recv_evd_hdl,	 /* recv     */
 			 ps_ptr->reqt_evd_hdl,	 /* request  */
 			 ps_ptr->conn_evd_hdl,	 /* connect  */
 			 (struct dat_ep_attr *) NULL,
-			 &ps_ptr->ep_handle);
+			 &ps_ptr->ep);
     if (ret != DAT_SUCCESS)
     {
 	DT_Tdep_PT_Printf (phead, 
 		    "%s: dat_ep_create error: %s\n",
 		    module,
 		    DT_RetToString (ret));
-	ps_ptr->ep_handle = DAT_HANDLE_NULL;
+	ps_ptr->ep = NULL;
         status = 1;
 	goto server_exit;
     }
     DT_Tdep_PT_Debug (1,(phead,"%s: EP created\n", module));
 
     /* Create PSP */
-    ret = dat_psp_create (ps_ptr->ia_handle,
+    ret = dat_psp_create (ps_ptr->ia,
 			SERVER_PORT_NUMBER,
 			ps_ptr->creq_evd_hdl,
 			DAT_PSP_CONSUMER_FLAG,
-			&ps_ptr->psp_handle);
+			&ps_ptr->psp);
     if (ret != DAT_SUCCESS)
     {
 	DT_Tdep_PT_Printf (phead, 
 		    "%s: dat_psp_create error: %s\n",
 		    module,
 		    DT_RetToString (ret));
-	ps_ptr->psp_handle = DAT_HANDLE_NULL;
+	ps_ptr->psp = NULL;
         status = 1;
 	goto server_exit;
     }
@@ -233,10 +233,10 @@ DT_cs_Server (Params_t * params_ptr)
      */
     ps_ptr->bpool = DT_BpoolAlloc (NULL,
 	    		       phead,
-			       ps_ptr->ia_handle,
-			       ps_ptr->pz_handle,
-			       ps_ptr->ep_handle,
-			       DAT_HANDLE_NULL, /* no RMR */
+			       ps_ptr->ia,
+			       ps_ptr->pz,
+			       ps_ptr->ep,
+			       NULL, /* no RMR */
 			       DT_RoundSize (sizeof (Transaction_Cmd_t), 8192),
 			       3,	/* num_buffers */
 			       256, /* FIXME query for this value */
@@ -275,7 +275,7 @@ DT_cs_Server (Params_t * params_ptr)
      */
     for (;/* EVER */;)
     {
-	DAT_CR_HANDLE               cr_handle;
+	struct dat_cr *              cr;
 	struct dat_cr_arrival_event_data   cr_stat;
 	enum dat_event_number            event_num;
 
@@ -299,7 +299,7 @@ DT_cs_Server (Params_t * params_ptr)
 	/* Server_Info, Client_Info, Params set up below */
 
 	/* Gather whatever info we want about defaults */
-	if (!DT_query (pt_ptr, ps_ptr->ia_handle, ps_ptr->ep_handle))
+	if (!DT_query (pt_ptr, ps_ptr->ia, ps_ptr->ep))
 	{
             status = 1;
 	    goto server_exit;
@@ -308,7 +308,7 @@ DT_cs_Server (Params_t * params_ptr)
 	/* Post recv buffers for ClientInfo and Transaction_Cmd_t */
 	DT_Tdep_PT_Debug (1,(phead,"%s: Posting 2 recvs\n", module));
 	if (!DT_post_recv_buffer (phead,
-		    		   ps_ptr->ep_handle,
+		    		   ps_ptr->ep,
 				   ps_ptr->bpool,
 				   0,
 				   DT_Bpool_GetBuffSize (ps_ptr->bpool, 0)))
@@ -320,7 +320,7 @@ DT_cs_Server (Params_t * params_ptr)
 	    goto server_exit;
 	}
 	if (!DT_post_recv_buffer (phead,
-		    		   ps_ptr->ep_handle,
+		    		   ps_ptr->ep,
 				   ps_ptr->bpool,
 				   1,
 				   DT_Bpool_GetBuffSize (ps_ptr->bpool, 1)))
@@ -343,9 +343,9 @@ DT_cs_Server (Params_t * params_ptr)
 	if (!DT_cr_event_wait (phead, ps_ptr->creq_evd_hdl, &cr_stat) ||
 	    !DT_cr_check (phead,
 			    &cr_stat,
-			    ps_ptr->psp_handle,
+			    ps_ptr->psp,
 			    SERVER_PORT_NUMBER,
-			    &cr_handle,
+			    &cr,
 			    module))
 	{
 
@@ -357,7 +357,7 @@ DT_cs_Server (Params_t * params_ptr)
 	}
 
 	DT_Tdep_PT_Debug (1,(phead,"%s: Accepting Connection Request\n", module));
-	ret = dat_cr_accept (cr_handle, ps_ptr->ep_handle, 0, (void *)0);
+	ret = dat_cr_accept (cr, ps_ptr->ep, 0, (void *)0);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, 
@@ -370,7 +370,7 @@ DT_cs_Server (Params_t * params_ptr)
 
 	DT_Tdep_PT_Debug (1,(phead,"%s: Awaiting connection ...\n", module));
 	if (!DT_conn_event_wait (phead,
-		    		 ps_ptr->ep_handle, 
+		    		 ps_ptr->ep, 
 				 ps_ptr->conn_evd_hdl,
 				 &event_num))
 	{
@@ -384,7 +384,7 @@ DT_cs_Server (Params_t * params_ptr)
 	if (DT_dapltest_debug)
 	{
 	    DT_Tdep_PT_Debug (1,(phead, "%s: Connected!\n", module));
-	    get_ep_connection_state (phead, ps_ptr->ep_handle);
+	    get_ep_connection_state (phead, ps_ptr->ep);
 	}
 
 	/* Wait for Client_Info */
@@ -395,7 +395,7 @@ DT_cs_Server (Params_t * params_ptr)
 	if (!DT_dto_event_wait (phead, ps_ptr->recv_evd_hdl, &dto_stat) ||
 	    !DT_dto_check ( phead,
 			    &dto_stat,
-			    ps_ptr->ep_handle,
+			    ps_ptr->ep,
 			    DT_Bpool_GetBuffSize (ps_ptr->bpool, 0),
 			    dto_cookie,
 			    "Client_Info_Recv"))
@@ -420,7 +420,7 @@ DT_cs_Server (Params_t * params_ptr)
 	if (!DT_dto_event_wait (phead, ps_ptr->recv_evd_hdl, &dto_stat) ||
 	    !DT_dto_check ( phead,
 			    &dto_stat,
-			    ps_ptr->ep_handle,
+			    ps_ptr->ep,
 			    DT_Bpool_GetBuffSize (ps_ptr->bpool, 1),
 			    dto_cookie,
 			    "Client_Cmd_Recv"))
@@ -585,7 +585,7 @@ DT_cs_Server (Params_t * params_ptr)
 	/* Send the Server_Info */
 	DT_Tdep_PT_Debug (1,(phead,"%s: Send Server_Info\n", module));
 
-	if (!DT_post_send_buffer ( phead, ps_ptr->ep_handle,
+	if (!DT_post_send_buffer ( phead, ps_ptr->ep,
 		ps_ptr->bpool,
 		2,
 		DT_Bpool_GetBuffSize (ps_ptr->bpool, 2)))
@@ -601,7 +601,7 @@ DT_cs_Server (Params_t * params_ptr)
 	if (!DT_dto_event_wait (phead, ps_ptr->reqt_evd_hdl, &dto_stat) ||
 		!DT_dto_check ( phead,
 		    	    &dto_stat,
-		ps_ptr->ep_handle,
+		ps_ptr->ep,
 		DT_Bpool_GetBuffSize (ps_ptr->bpool, 2),
 		dto_cookie,
 		"Server_Info_Send"))
@@ -619,7 +619,7 @@ DT_cs_Server (Params_t * params_ptr)
 	/* we passed the pt_ptr to the thread and must now 'forget' it */
 	pt_ptr = NULL;
 
-	ret = dat_ep_disconnect (ps_ptr->ep_handle, DAT_CLOSE_GRACEFUL_FLAG);
+	ret = dat_ep_disconnect (ps_ptr->ep, DAT_CLOSE_GRACEFUL_FLAG);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, "%s: dat_ep_disconnect fails: %s\n",
@@ -635,7 +635,7 @@ DT_cs_Server (Params_t * params_ptr)
 	}
 
 	/* reset the EP to get back into the game */
-	dat_ep_reset (ps_ptr->ep_handle);
+	dat_ep_reset (ps_ptr->ep);
 	DT_Tdep_PT_Debug (1,(phead,"%s: Waiting for another client...\n", module));
 
     }	/* end loop accepting connections */
@@ -669,9 +669,9 @@ server_exit:
 	 * we also get here on error, hence abrupt closure to
 	 * flush any lingering buffers posted.
 	 */
-	if (ps_ptr->ep_handle)
+	if (ps_ptr->ep)
 	{
-	    ret = dat_ep_disconnect (ps_ptr->ep_handle,
+	    ret = dat_ep_disconnect (ps_ptr->ep,
 				    DAT_CLOSE_ABRUPT_FLAG);
 	    if (ret != DAT_SUCCESS)
 	    {
@@ -704,9 +704,9 @@ server_exit:
 	}
 
 	/* Free the PSP */
-	if (ps_ptr->psp_handle)
+	if (ps_ptr->psp)
 	{
-	    ret = dat_psp_free (ps_ptr->psp_handle);
+	    ret = dat_psp_free (ps_ptr->psp);
 	    if (ret != DAT_SUCCESS)
 	    {
 		DT_Tdep_PT_Printf (phead, "%s: dat_psp_free error: %s\n",
@@ -718,9 +718,9 @@ server_exit:
 	}
 
 	/* Free the EP */
-	if (ps_ptr->ep_handle)
+	if (ps_ptr->ep)
 	{
-	    ret = dat_ep_free (ps_ptr->ep_handle);
+	    ret = dat_ep_free (ps_ptr->ep);
 	    if (ret != DAT_SUCCESS)
 	    {
 		DT_Tdep_PT_Printf (phead, "%s: dat_ep_free error: %s\n",
@@ -781,9 +781,9 @@ server_exit:
 	}
 
 	/* Free the PZ */
-	if (ps_ptr->pz_handle)
+	if (ps_ptr->pz)
 	{
-	    ret = dat_pz_free (ps_ptr->pz_handle);
+	    ret = dat_pz_free (ps_ptr->pz);
 	    if (ret != DAT_SUCCESS)
 	    {
 		DT_Tdep_PT_Printf (phead, "%s: dat_pz_free error: %s\n",
@@ -794,17 +794,17 @@ server_exit:
 	}
 
 	/* Close the IA */
-	if (ps_ptr->ia_handle)
+	if (ps_ptr->ia)
 	{
 	    /* dat_ia_close cleans up async evd handle, too */
-	    ret = dat_ia_close (ps_ptr->ia_handle, DAT_CLOSE_GRACEFUL_FLAG);
+	    ret = dat_ia_close (ps_ptr->ia, DAT_CLOSE_GRACEFUL_FLAG);
 	    if (ret != DAT_SUCCESS)
 	    {
 		DT_Tdep_PT_Printf (phead, 
 			    "%s: dat_ia_close (graceful) error: %s\n",
 			    module, DT_RetToString (ret));
                 status = 1;
-		ret = dat_ia_close (ps_ptr->ia_handle, DAT_CLOSE_ABRUPT_FLAG);
+		ret = dat_ia_close (ps_ptr->ia, DAT_CLOSE_ABRUPT_FLAG);
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, 
@@ -871,7 +871,7 @@ send_control_data (
 	     sizeof (Server_Info_t));
     DT_Server_Info_Endian ((Server_Info_t *) buffp);
 
-    if (!DT_post_send_buffer ( phead, ps_ptr->ep_handle,
+    if (!DT_post_send_buffer ( phead, ps_ptr->ep,
 			       ps_ptr->bpool,
 			       2,
 			       DT_Bpool_GetBuffSize (ps_ptr->bpool, 2)))
@@ -886,7 +886,7 @@ send_control_data (
     if (!DT_dto_event_wait (phead, ps_ptr->reqt_evd_hdl, &dto_stat) ||
 	!DT_dto_check (phead,
 	    	    &dto_stat,
-			ps_ptr->ep_handle,
+			ps_ptr->ep,
 			DT_Bpool_GetBuffSize (ps_ptr->bpool, 2),
 			dto_cookie,
 			"Server_Info_Send"))
Index: linux-kernel/test/dapltest/test/dapl_fft_util.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_fft_util.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_fft_util.c	(working copy)
@@ -55,22 +55,22 @@ void DT_assert_fail (DT_Tdep_Print_Head 
 }
 
 /* helper function to open an IA */
-int DT_ia_open (char *dev_name, DAT_IA_HANDLE *ia_handle)
+int DT_ia_open (char *dev_name, struct dat_ia **ia)
 {
-    DAT_EVD_HANDLE evd_handle;
-    evd_handle = DAT_HANDLE_NULL;
-    return dat_ia_open (dev_name, DEFAULT_QUEUE_LEN, &evd_handle, ia_handle);
+    struct dat_evd *evd;
+    evd = NULL;
+    return dat_ia_open (dev_name, DEFAULT_QUEUE_LEN, &evd, ia);
 }
 
 /* helper function to create an endpoint and its associated EVDs */
 int DT_ep_create (Params_t *params_ptr,
-		  DAT_IA_HANDLE ia_handle, 
-		  DAT_PZ_HANDLE pz_handle,
-		  DAT_EVD_HANDLE *cr_evd,
-		  DAT_EVD_HANDLE *conn_evd, 
-		  DAT_EVD_HANDLE *send_evd,
-		  DAT_EVD_HANDLE *recv_evd, 
-		  DAT_EP_HANDLE *ep_handle)
+		  struct dat_ia *ia, 
+		  struct dat_pz *pz,
+		  struct dat_evd **cr_evd,
+		  struct dat_evd **conn_evd, 
+		  struct dat_evd **send_evd,
+		  struct dat_evd **recv_evd, 
+		  struct dat_ep **ep)
 {
     u32 status;
     DT_Tdep_Print_Head *phead;
@@ -80,7 +80,7 @@ int DT_ep_create (Params_t *params_ptr,
     *cr_evd = NULL;
     phead = params_ptr->phead;
 
-    status = DT_Tdep_evd_create (ia_handle, DEFAULT_QUEUE_LEN, DAT_HANDLE_NULL,
+    status = DT_Tdep_evd_create (ia, DEFAULT_QUEUE_LEN, NULL,
 			    DAT_EVD_CR_FLAG, cr_evd);
     if (status != DAT_SUCCESS)
     {
@@ -88,7 +88,7 @@ int DT_ep_create (Params_t *params_ptr,
 	return status;
     }
 
-    status = DT_Tdep_evd_create (ia_handle, DEFAULT_QUEUE_LEN, DAT_HANDLE_NULL,
+    status = DT_Tdep_evd_create (ia, DEFAULT_QUEUE_LEN, NULL,
 			    DAT_EVD_CONNECTION_FLAG, conn_evd);
     if (status != DAT_SUCCESS)
     {
@@ -96,7 +96,7 @@ int DT_ep_create (Params_t *params_ptr,
 	return status;
     }
 
-    status = DT_Tdep_evd_create (ia_handle, DEFAULT_QUEUE_LEN, DAT_HANDLE_NULL,
+    status = DT_Tdep_evd_create (ia, DEFAULT_QUEUE_LEN, NULL,
 			     DAT_EVD_DTO_FLAG | DAT_EVD_RMR_BIND_FLAG,
 			     send_evd);
     if (status != DAT_SUCCESS)
@@ -105,7 +105,7 @@ int DT_ep_create (Params_t *params_ptr,
 	return status;
     }
 
-    status = DT_Tdep_evd_create (ia_handle, DEFAULT_QUEUE_LEN, DAT_HANDLE_NULL,
+    status = DT_Tdep_evd_create (ia, DEFAULT_QUEUE_LEN, NULL,
 			    DAT_EVD_DTO_FLAG, recv_evd);
     if (status != DAT_SUCCESS)
     {
@@ -113,8 +113,8 @@ int DT_ep_create (Params_t *params_ptr,
 	return status;
     }
 
-    status = dat_ep_create (ia_handle, pz_handle, *recv_evd,
-	    *send_evd, *conn_evd, NULL, ep_handle);
+    status = dat_ep_create (ia, pz, *recv_evd,
+	    *send_evd, *conn_evd, NULL, ep);
     if (status != DAT_SUCCESS)
     {
 	DT_Tdep_PT_Printf (phead, "dat_ep_create failed %s\n", DT_RetToString (status));
@@ -125,15 +125,15 @@ int DT_ep_create (Params_t *params_ptr,
 /* function that initializes the connection struct */
 void DT_fft_init_conn_struct (FFT_Connection_t *conn)
 {
-    conn->ia_handle = NULL;
-    conn->pz_handle = NULL;
-    conn->psp_handle = NULL;
-    conn->ep_handle = NULL;
+    conn->ia = NULL;
+    conn->pz = NULL;
+    conn->psp = NULL;
+    conn->ep = NULL;
     conn->cr_evd = NULL;
     conn->send_evd = NULL;
     conn->conn_evd = NULL;
     conn->recv_evd = NULL;
-    conn->cr_handle = NULL;
+    conn->cr = NULL;
     conn->remote_netaddr = NULL;
     conn->bpool = NULL;
     conn->pt_ptr = NULL;
@@ -154,27 +154,27 @@ void DT_fft_init_client (Params_t *param
     DT_fft_init_conn_struct (conn);
 
     /* open the IA */
-    rc = DT_ia_open (cmd->device_name, &conn->ia_handle);
+    rc = DT_ia_open (cmd->device_name, &conn->ia);
     if (rc != DAT_SUCCESS)
     {
 	/* make sure the handle has an invalid value */
-	conn->ia_handle = NULL;
+	conn->ia = NULL;
     }
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
     /* create a PZ */
-    rc = dat_pz_create (conn->ia_handle, &conn->pz_handle);
+    rc = dat_pz_create (conn->ia, &conn->pz);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
     /* create an EP and its EVDs */
     rc =DT_ep_create (params_ptr, 
-	    	      conn->ia_handle, 
-		      conn->pz_handle, 
+	    	      conn->ia, 
+		      conn->pz, 
 		      &conn->cr_evd,
 		      &conn->conn_evd, 
 		      &conn->send_evd, 
 		      &conn->recv_evd,
-		      &conn->ep_handle);
+		      &conn->ep);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
     /* if a server name is given, allocate memory for a net address and set it
@@ -198,11 +198,11 @@ int DT_fft_destroy_conn_struct (Params_t
     DT_Tdep_Print_Head *phead;
     phead = params_ptr->phead;
     
-    if (conn->ep_handle)
+    if (conn->ep)
     {
 	if (conn->connected)
 	{
-	    rc = dat_ep_disconnect (conn->ep_handle, DAT_CLOSE_DEFAULT);
+	    rc = dat_ep_disconnect (conn->ep, DAT_CLOSE_DEFAULT);
 	    DT_assert_clean (phead, rc == DAT_SUCCESS);
 
 	    if (!DT_disco_event_wait ( phead, conn->cr_evd, NULL ))
@@ -211,16 +211,16 @@ int DT_fft_destroy_conn_struct (Params_t
 		DT_Tdep_PT_Printf (phead, "DT_fft_destroy_conn_struct: bad disconnect event\n");
 	    }
 	}
-	rc = dat_ep_free (conn->ep_handle);
+	rc = dat_ep_free (conn->ep);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
     if (conn->bpool)
     {
 	DT_Bpool_Destroy (NULL, phead, conn->bpool);
     }
-    if (conn->psp_handle)
+    if (conn->psp)
     {
-	rc = dat_psp_free (conn->psp_handle);
+	rc = dat_psp_free (conn->psp);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
     if (conn->cr_evd)
@@ -247,14 +247,14 @@ int DT_fft_destroy_conn_struct (Params_t
     {
 	DT_Free_Per_Test_Data (conn->pt_ptr);
     }
-    if (conn->pz_handle)
+    if (conn->pz)
     {
-	rc = dat_pz_free (conn->pz_handle);
+	rc = dat_pz_free (conn->pz);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
-    if (conn->ia_handle)
+    if (conn->ia)
     {
-	rc = dat_ia_close (conn->ia_handle, DAT_CLOSE_ABRUPT_FLAG);
+	rc = dat_ia_close (conn->ia, DAT_CLOSE_ABRUPT_FLAG);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
     return rc;
@@ -272,31 +272,31 @@ void DT_fft_init_server (Params_t *param
     DT_fft_init_conn_struct (conn);
 
     /* open the IA */
-    rc = DT_ia_open (cmd->device_name, &conn->ia_handle);
+    rc = DT_ia_open (cmd->device_name, &conn->ia);
     DT_assert_dat (phead, rc ==  DAT_SUCCESS);
 
     /* create a PZ */
-    rc = dat_pz_create (conn->ia_handle, &conn->pz_handle);
+    rc = dat_pz_create (conn->ia, &conn->pz);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
     /* create an EP and its EVDs */
     rc =DT_ep_create (params_ptr, 
-	    	      conn->ia_handle, 
-		      conn->pz_handle, 
+	    	      conn->ia, 
+		      conn->pz, 
 		      &conn->cr_evd,
 		      &conn->conn_evd, 
 		      &conn->send_evd, 
 		      &conn->recv_evd,
-		      &conn->ep_handle);
+		      &conn->ep);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
     /* create a PSP */
-    rc = dat_psp_create (conn->ia_handle, SERVER_PORT_NUMBER, conn->cr_evd,
-		DAT_PSP_CONSUMER_FLAG, &conn->psp_handle);
+    rc = dat_psp_create (conn->ia, SERVER_PORT_NUMBER, conn->cr_evd,
+		DAT_PSP_CONSUMER_FLAG, &conn->psp);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
     /* allocate memory for buffers */
-    conn->bpool = DT_BpoolAlloc (NULL, phead, conn->ia_handle, conn->pz_handle, 
+    conn->bpool = DT_BpoolAlloc (NULL, phead, conn->ia, conn->pz, 
                                  NULL, NULL, 8192, 2, 256 /* FIXME query */, 
                                  FALSE, FALSE);
     DT_assert (phead, conn->bpool);
@@ -316,19 +316,19 @@ void DT_fft_listen (Params_t *params_ptr
     DT_assert_dat (phead, DT_cr_event_wait (phead, conn->cr_evd, &conn->cr_stat) &&
 	    DT_cr_check (phead, 
 			 &conn->cr_stat, 
-			 conn->psp_handle, 
+			 conn->psp, 
 			 SERVER_PORT_NUMBER,
-			 &conn->cr_handle, 
+			 &conn->cr, 
 			 "DT_fft_listen"));
 
     /* accept the connection */
-    rc =dat_cr_accept (conn->cr_handle, conn->ep_handle, 0, (void *)0);
+    rc =dat_cr_accept (conn->cr, conn->ep, 0, (void *)0);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
     /* wait on a conn event via the conn EVD */
     DT_assert (phead, 
 	       DT_conn_event_wait (phead, 
-		   		   conn->ep_handle, 
+		   		   conn->ep, 
 				   conn->conn_evd,
 				   &conn->event_num) == TRUE);
     conn->connected = TRUE;
@@ -351,7 +351,7 @@ int DT_fft_connect (Params_t *params_ptr
 	DT_Tdep_PT_Printf (phead, "Connection to server, attempt #%d\n", wait_count+1);
 
 	/* attempt to connect, timeout = 10 secs */
-	rc = dat_ep_connect (conn->ep_handle, conn->remote_netaddr,
+	rc = dat_ep_connect (conn->ep, conn->remote_netaddr,
 		    SERVER_PORT_NUMBER, 10*1000000, 0, (void *)0,
 		    DAT_QOS_BEST_EFFORT, DAT_CONNECT_DEFAULT_FLAG);
 	DT_assert_dat (phead, rc == DAT_SUCCESS);
@@ -359,7 +359,7 @@ int DT_fft_connect (Params_t *params_ptr
 	/* wait on conn event */
 	DT_assert (phead, 
 		   DT_conn_event_wait (phead, 
-		       		       conn->ep_handle, 
+		       		       conn->ep, 
 				       conn->conn_evd,
 				       &conn->event_num) == TRUE);
 
Index: linux-kernel/test/dapltest/test/dapl_fft_mem.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_fft_mem.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_fft_mem.c	(working copy)
@@ -37,28 +37,28 @@ int DT_mem_generic (Params_t *params_ptr
     FFT_Connection_t conn;
     DAT_REGION_DESCRIPTION region;
     u64 reg_size;
-    DAT_LMR_HANDLE lmr_handle;
+    struct dat_lmr *lmr;
     DAT_LMR_CONTEXT lmr_context;
     u64 reg_addr;
     unsigned char *alloc_ptr;
     int res;
     u64 buffer_size;
-    DAT_IA_HANDLE ia_handle;
-    DAT_PZ_HANDLE pz_handle;
+    struct dat_ia *ia;
+    struct dat_pz *pz;
     DT_Tdep_Print_Head *phead; 
     phead = params_ptr->phead;
     rc = 0;
     expect = 0;
     res = 1;
-    lmr_handle = NULL;
+    lmr = NULL;
     lmr_context = 0;
     reg_addr = 0;
     alloc_ptr = NULL;
-    ia_handle = NULL;
-    pz_handle = NULL;
+    ia = NULL;
+    pz = NULL;
 
     DT_fft_init_client (params_ptr, cmd, &conn);
-    DT_assert (phead, NULL != conn.ia_handle);
+    DT_assert (phead, NULL != conn.ia);
 
     if (flag == 2)
     {
@@ -76,24 +76,24 @@ int DT_mem_generic (Params_t *params_ptr
     memset (&region, 0, sizeof (region));
     region.for_va = alloc_ptr;
 
-    ia_handle = conn.ia_handle;
+    ia = conn.ia;
 
     if (flag != 3)
     {
-	pz_handle = conn.pz_handle;
+	pz = conn.pz;
     }
 
     if (flag != 4)
     {
 	DT_Tdep_PT_Printf (phead, "Registering memory\n");
-	rc = dat_lmr_kcreate (ia_handle,
+	rc = dat_lmr_kcreate (ia,
 			      	DAT_MEM_TYPE_VIRTUAL,
 				region,
 				buffer_size,
-				conn.pz_handle,
+				conn.pz,
 				DAT_MEM_PRIV_ALL_FLAG,
 				DAT_MEM_OPTIMIZE_DONT_CARE,
-				&lmr_handle,
+				&lmr,
 				&lmr_context,
 				NULL,	/* FIXME */
 				&reg_size,
@@ -110,21 +110,21 @@ int DT_mem_generic (Params_t *params_ptr
     }
     if (flag == 1)
     {
-	if (lmr_handle)
+	if (lmr)
 	{
-	    rc = dat_lmr_free (lmr_handle);
+	    rc = dat_lmr_free (lmr);
 	    DT_assert_dat (phead, rc == DAT_SUCCESS);
 	}
-	lmr_handle = NULL;
+	lmr = NULL;
 
-	rc = dat_lmr_kcreate (conn.ia_handle,
+	rc = dat_lmr_kcreate (conn.ia,
 				DAT_MEM_TYPE_VIRTUAL,
 				region,
 				buffer_size,
-				conn.pz_handle,
+				conn.pz,
 				DAT_MEM_PRIV_ALL_FLAG,
 				DAT_MEM_OPTIMIZE_DONT_CARE,
-				&lmr_handle,
+				&lmr,
 				&lmr_context,
 				NULL,	/* FIXME */
 				&reg_size,
@@ -133,9 +133,9 @@ int DT_mem_generic (Params_t *params_ptr
     }
 
 cleanup:
-    if (lmr_handle)
+    if (lmr)
     {
-	rc = dat_lmr_free (lmr_handle);
+	rc = dat_lmr_free (lmr);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
     if (alloc_ptr)
@@ -197,7 +197,7 @@ int DT_mem_case4 ( Params_t *params_ptr,
     DT_Tdep_Print_Head *phead; 
     phead = params_ptr->phead;
     DT_Tdep_PT_Printf (phead, "\
-	Description: Try to deregister memory with null lmr_handle\n");
+	Description: Try to deregister memory with null lmr\n");
     return DT_mem_generic (params_ptr, cmd, 4);
 }
 
Index: linux-kernel/test/dapltest/test/dapl_limit.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_limit.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_limit.c	(working copy)
@@ -33,13 +33,13 @@
 
 static boolean_t
 more_handles (DT_Tdep_Print_Head *phead,
-	     DAT_HANDLE **old_ptrptr,	/* pointer to current pointer	*/
+	     void ***old_ptrptr,	/* pointer to current pointer	*/
 	     unsigned int *old_count,	/* number  pointed to	     	*/
 	     unsigned int size)		/* size of one datum		*/
 {
     unsigned int count	     = *old_count;
-    DAT_HANDLE  *old_handles = *old_ptrptr;
-    DAT_HANDLE  *handle_tmp  = DT_Mdep_Malloc (count * 2 * size);
+    void * *old_handles = *old_ptrptr;
+    void * *handle_tmp  = DT_Mdep_Malloc (count * 2 * size);
 
     if (!handle_tmp)
     {
@@ -74,19 +74,19 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	    Limit_Cmd_t *cmd,
 	    Limit_Index depth)
 {
-    DAT_EVD_HANDLE	conn_handle;
+    struct dat_evd *	conn_handle;
     typedef struct obj_set
     {
-	DAT_IA_HANDLE	ia_handle;
-	DAT_EVD_HANDLE	ia_async_handle;
-	DAT_PZ_HANDLE	pz_handle;
+	struct dat_ia *	ia;
+	struct dat_evd *	ia_async_handle;
+	struct dat_pz *	pz;
 	DAT_CNO_HANDLE	cno_handle;
-	DAT_EVD_HANDLE	evd_handle;
-	DAT_EP_HANDLE	ep_handle;
-	DAT_LMR_HANDLE	lmr_handle;
+	struct dat_evd *	evd;
+	struct dat_ep *	ep;
+	struct dat_lmr *	lmr;
 	char * 		lmr_buffer;
 	DAT_LMR_CONTEXT	lmr_context;
-	DAT_RMR_HANDLE	rmr_handle;
+	struct dat_rmr *	rmr_handle;
 	DAT_RMR_CONTEXT	rmr_context;
     } Obj_Set;
 
@@ -135,19 +135,19 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	for (w = 0;  w < cmd->width;  w++)
 	{
 	    /* Specify that we want to get back an async EVD.  */
-	    hdl_sets[w].ia_async_handle = DAT_HANDLE_NULL;
+	    hdl_sets[w].ia_async_handle = NULL;
 	    ret = dat_ia_open (cmd->device_name,
 			      DFLT_QLEN,
 			      &hdl_sets[w].ia_async_handle,
-			      &hdl_sets[w].ia_handle);
+			      &hdl_sets[w].ia);
 	    if (ret != DAT_SUCCESS)
 	    {
 		DT_Tdep_PT_Printf (phead, "%s: dat_ia_open (%s) #%d fails: %s\n",
 				module,  cmd->device_name,
 				w+1,  DT_RetToString (ret));
 		/* handle contents undefined on failure */
-		hdl_sets[w].ia_async_handle = DAT_HANDLE_NULL;
-		hdl_sets[w].ia_handle = DAT_HANDLE_NULL;
+		hdl_sets[w].ia_async_handle = NULL;
+		hdl_sets[w].ia = NULL;
 		goto clean_up_now;
 	    }
 	}
@@ -159,8 +159,8 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	 */
 	typedef struct _ia
 	{
-	    DAT_IA_HANDLE   ia_handle;
-	    DAT_EVD_HANDLE  ia_async_handle;
+	    struct dat_ia *  ia;
+	    struct dat_evd * ia_async_handle;
 	}
 	OneOpen;
 	unsigned int  count	= START_COUNT;
@@ -178,7 +178,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	    {
 		DT_Mdep_Schedule();
 		if (w == count
-		    && !more_handles (phead, (DAT_HANDLE **) &hdlptr,
+		    && !more_handles (phead, (void ***) &hdlptr,
 				    &count,
 				    sizeof (*hdlptr)))
 		{
@@ -187,11 +187,11 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		    break;
 		}
 		/* Specify that we want to get back an async EVD.  */
-		hdlptr[w].ia_async_handle = DAT_HANDLE_NULL;
+		hdlptr[w].ia_async_handle = NULL;
 		ret = dat_ia_open (cmd->device_name,
 				  DFLT_QLEN,
 				  &hdlptr[w].ia_async_handle,
-				  &hdlptr[w].ia_handle);
+				  &hdlptr[w].ia);
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, "%s: dat_ia_open (%s) #%d fails: %s\n",
@@ -209,14 +209,14 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	    for (tmp = 0;  tmp < w;  tmp++)
 	    {
 		DT_Mdep_Schedule();
-		ret = dat_ia_close (hdlptr[tmp].ia_handle,
+		ret = dat_ia_close (hdlptr[tmp].ia,
 				    DAT_CLOSE_GRACEFUL_FLAG);
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, "%s: dat_ia_close (graceful) fails: %s\n",
 			    module,  DT_RetToString (ret));
 		    retval = FALSE;
-		    ret = dat_ia_close (hdlptr[tmp].ia_handle,
+		    ret = dat_ia_close (hdlptr[tmp].ia,
 					DAT_CLOSE_ABRUPT_FLAG);
 		    if (ret != DAT_SUCCESS)
 		    {
@@ -245,14 +245,14 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		       cmd->width));
 	for (w = 0;  w < cmd->width;  w++)
 	{
-	    ret = dat_pz_create (hdl_sets[w].ia_handle,
-				&hdl_sets[w].pz_handle);
+	    ret = dat_pz_create (hdl_sets[w].ia,
+				&hdl_sets[w].pz);
 	    if (ret != DAT_SUCCESS)
 	    {
 		DT_Tdep_PT_Printf (phead, "%s: dat_pz_create #%d fails: %s\n",
 				module,  w+1,  DT_RetToString (ret));
 		/* handle contents undefined on failure */
-		hdl_sets[w].pz_handle = DAT_HANDLE_NULL;
+		hdl_sets[w].pz = NULL;
 		goto clean_up_now;
 	    }
 	}
@@ -263,7 +263,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	 * See how many PZs we can create
 	 */
 	unsigned int   count	= START_COUNT;
-	DAT_PZ_HANDLE *hdlptr	= (DAT_PZ_HANDLE *)
+	struct dat_pz **hdlptr	= (struct dat_pz **)
 				    DT_Mdep_Malloc (count * sizeof (*hdlptr));
 
 	/* PZ Exhaustion test loop */
@@ -279,7 +279,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	    {
 		DT_Mdep_Schedule();
 		if (w == count
-		    && !more_handles (phead, (DAT_HANDLE **) &hdlptr,
+		    && !more_handles (phead, (void ***) &hdlptr,
 				    &count,
 				    sizeof (*hdlptr)))
 		{
@@ -287,7 +287,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		    retval = TRUE;
 		    break;
 		}
-		ret = dat_pz_create (hdl_sets[w % cmd->width].ia_handle,
+		ret = dat_pz_create (hdl_sets[w % cmd->width].ia,
 				    &hdlptr[w]);
 		if (ret != DAT_SUCCESS)
 		{
@@ -335,13 +335,13 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		       cmd->width));
 	for (w = 0;  w < cmd->width;  w++)
 	{
-	    ret = dat_cno_create (hdl_sets[w].ia_handle,
+	    ret = dat_cno_create (hdl_sets[w].ia,
 				DAT_OS_WAIT_PROXY_AGENT_NULL,
 				&hdl_sets[w].cno_handle);
 	    if (DAT_GET_TYPE (ret) == DAT_NOT_IMPLEMENTED)
 	    {
 		DT_Tdep_PT_Printf (phead, "%s: dat_cno_create unimplemented\n", module);
-		hdl_sets[w].cno_handle = DAT_HANDLE_NULL;
+		hdl_sets[w].cno_handle = NULL;
 		/* ignore this error */
 		break;
 	    }
@@ -350,7 +350,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		DT_Tdep_PT_Printf (phead, "%s: dat_cno_create #%d fails: %s\n",
 				module,  w+1,  DT_RetToString (ret));
 		/* handle contents undefined on failure */
-		hdl_sets[w].cno_handle = DAT_HANDLE_NULL;
+		hdl_sets[w].cno_handle = NULL;
 		goto clean_up_now;
 	    }
 	}
@@ -377,7 +377,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	    {
 		DT_Mdep_Schedule();
 		if (w == count
-		    && !more_handles (phead, (DAT_HANDLE **) &hdlptr,
+		    && !more_handles (phead, (void ***) &hdlptr,
 				    &count,
 				    sizeof (*hdlptr)))
 		{
@@ -385,7 +385,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		    retval = TRUE;
 		    break;
 		}
-		ret = dat_cno_create (hdl_sets[w % cmd->width].ia_handle,
+		ret = dat_cno_create (hdl_sets[w % cmd->width].ia,
 				    DAT_OS_WAIT_PROXY_AGENT_NULL,
 				    &hdlptr[w]);
 		if (DAT_GET_TYPE (ret) == DAT_NOT_IMPLEMENTED)
@@ -446,7 +446,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	 * First create a connection EVD to be used for EP creation
 	 */
 
-	ret = DT_Tdep_evd_create (hdl_sets[0].ia_handle,
+	ret = DT_Tdep_evd_create (hdl_sets[0].ia,
 			      DFLT_QLEN,
 			      NULL,
 			      DAT_EVD_CONNECTION_FLAG,
@@ -456,22 +456,22 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	    DT_Tdep_PT_Printf (phead, "%s: conn dat_evd_create #%d fails: %s\n",
 			    module,  w+1,  DT_RetToString (ret));
 	    /* handle contents undefined on failure */
-	    conn_handle = DAT_HANDLE_NULL;
+	    conn_handle = NULL;
 	    goto clean_up_now;
 	}
 	for (w = 0;  w < cmd->width;  w++)
 	{
-	    ret = DT_Tdep_evd_create (hdl_sets[w].ia_handle,
+	    ret = DT_Tdep_evd_create (hdl_sets[w].ia,
 				DFLT_QLEN,
 				hdl_sets[w].cno_handle,
 				flags,
-				&hdl_sets[w].evd_handle);
+				&hdl_sets[w].evd);
 	    if (ret != DAT_SUCCESS)
 	    {
 		DT_Tdep_PT_Printf (phead, "%s: dat_evd_create #%d fails: %s\n",
 				module,  w+1,  DT_RetToString (ret));
 		/* handle contents undefined on failure */
-		hdl_sets[w].evd_handle = DAT_HANDLE_NULL;
+		hdl_sets[w].evd = NULL;
 		goto clean_up_now;
 	    }
 	}
@@ -482,7 +482,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	 * See how many EVDs we can create
 	 */
 	unsigned int   count	= START_COUNT;
-	DAT_EVD_HANDLE *hdlptr	= (DAT_EVD_HANDLE *)
+	struct dat_evd **hdlptr	= (struct dat_evd **)
 				    DT_Mdep_Malloc (count * sizeof (*hdlptr));
 	enum dat_evd_flags flags	= (   DAT_EVD_DTO_FLAG
 				    | DAT_EVD_RMR_BIND_FLAG
@@ -500,7 +500,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	    /*
 	     * First create a connection EVD to be used for EP creation
 	     */
-	    ret = DT_Tdep_evd_create (hdl_sets[0].ia_handle,
+	    ret = DT_Tdep_evd_create (hdl_sets[0].ia,
 				  DFLT_QLEN,
 				  NULL,
 				  DAT_EVD_CONNECTION_FLAG,
@@ -510,13 +510,13 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		DT_Tdep_PT_Printf (phead, "%s: conn dat_evd_create #%d fails: %s\n",
 				module,  w+1,  DT_RetToString (ret));
 		/* handle contents undefined on failure */
-		conn_handle = DAT_HANDLE_NULL;
+		conn_handle = NULL;
 	    }
 	    for (w = 0;  w < cmd->maximum;  w++)
 	    {
 		DT_Mdep_Schedule();
 		if (w == count
-		    && !more_handles (phead, (DAT_HANDLE **) &hdlptr,
+		    && !more_handles (phead, (void ***) &hdlptr,
 				    &count,
 				    sizeof (*hdlptr)))
 		{
@@ -524,7 +524,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		    retval = TRUE;
 		    break;
 		}
-		ret = DT_Tdep_evd_create (hdl_sets[w % cmd->width].ia_handle,
+		ret = DT_Tdep_evd_create (hdl_sets[w % cmd->width].ia,
 				    DFLT_QLEN,
 				    hdl_sets[w % cmd->width].cno_handle,
 				    flags,
@@ -542,10 +542,10 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	    retval = TRUE;
 
 	    /* EVD Cleanup loop */
-	    if (conn_handle != DAT_HANDLE_NULL)
+	    if (conn_handle != NULL)
 	    {
 	        ret = DT_Tdep_evd_free (conn_handle);
-		conn_handle = DAT_HANDLE_NULL;
+		conn_handle = NULL;
 	    }
 	    for (tmp = 0;  tmp < w;  tmp++)
 	    {
@@ -578,19 +578,19 @@ limit_test ( DT_Tdep_Print_Head *phead,
 			cmd->width));
 	for (w = 0;  w < cmd->width;  w++)
 	{
-	    ret = dat_ep_create (hdl_sets[w].ia_handle,
-				hdl_sets[w].pz_handle,
-				hdl_sets[w].evd_handle,	/* recv	    */
-				hdl_sets[w].evd_handle,	/* request  */
+	    ret = dat_ep_create (hdl_sets[w].ia,
+				hdl_sets[w].pz,
+				hdl_sets[w].evd,	/* recv	    */
+				hdl_sets[w].evd,	/* request  */
 				conn_handle,		/* connect  */
 				(struct dat_ep_attr *) NULL,
-				&hdl_sets[w].ep_handle);
+				&hdl_sets[w].ep);
 	    if (ret != DAT_SUCCESS)
 	    {
 		DT_Tdep_PT_Printf (phead, "%s: dat_ep_create #%d fails: %s\n",
 				module,  w+1,  DT_RetToString (ret));
 		/* handle contents undefined on failure */
-		hdl_sets[w].ep_handle = DAT_HANDLE_NULL;
+		hdl_sets[w].ep = NULL;
 		goto clean_up_now;
 	    }
 	}
@@ -601,7 +601,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	 * See how many EPs we can create
 	 */
 	unsigned int   count	= START_COUNT;
-	DAT_EP_HANDLE *hdlptr	= (DAT_EP_HANDLE *)
+	struct dat_ep **hdlptr	= (struct dat_ep **)
 				    DT_Mdep_Malloc (count * sizeof (*hdlptr));
 
 	/* EP Exhaustion test loop */
@@ -615,7 +615,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	    {
 		DT_Mdep_Schedule();
 		if (w == count
-		    && !more_handles (phead, (DAT_HANDLE **) &hdlptr,
+		    && !more_handles (phead, (void ***) &hdlptr,
 				    &count,
 				    sizeof (*hdlptr)))
 		{
@@ -623,10 +623,10 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		    retval = TRUE;
 		    break;
 		}
-		ret = dat_ep_create (hdl_sets[w % cmd->width].ia_handle,
-				    hdl_sets[w % cmd->width].pz_handle,
-				    hdl_sets[w % cmd->width].evd_handle,
-				    hdl_sets[w % cmd->width].evd_handle,
+		ret = dat_ep_create (hdl_sets[w % cmd->width].ia,
+				    hdl_sets[w % cmd->width].pz,
+				    hdl_sets[w % cmd->width].evd,
+				    hdl_sets[w % cmd->width].evd,
 				     conn_handle,		/* connect  */
 				    (struct dat_ep_attr *) NULL,
 				    &hdlptr[w]);
@@ -672,9 +672,9 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	 * See how many RSPs we can create
 	 */
 	unsigned int   count	= START_COUNT;
-	DAT_RSP_HANDLE *hdlptr	= (DAT_RSP_HANDLE *)
+	struct dat_sp **hdlptr	= (struct dat_sp **)
 				    DT_Mdep_Malloc (count * sizeof (*hdlptr));
-	DAT_EP_HANDLE *epptr	= (DAT_EP_HANDLE *)
+	struct dat_ep **epptr	= (struct dat_ep **)
 				    DT_Mdep_Malloc (count * sizeof (*epptr));
 
 	/* RSP Exhaustion test loop */
@@ -692,7 +692,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		    unsigned int count1 = count;
 		    unsigned int count2 = count;
 
-		    if (!more_handles (phead, (DAT_HANDLE **) &hdlptr,
+		    if (!more_handles (phead, (void ***) &hdlptr,
 				       &count1,
 				       sizeof (*hdlptr)))
 		    {
@@ -700,7 +700,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 			retval = TRUE;
 			break;
 		    }
-		    if (!more_handles (phead, (DAT_HANDLE **) &epptr,
+		    if (!more_handles (phead, (void ***) &epptr,
 				       &count2,
 				       sizeof (*epptr)))
 		    {
@@ -723,10 +723,10 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		/*
 		 * Each RSP needs a unique EP, so create one first
 		 */
-		ret = dat_ep_create (hdl_sets[w % cmd->width].ia_handle,
-				    hdl_sets[w % cmd->width].pz_handle,
-				    hdl_sets[w % cmd->width].evd_handle,
-				    hdl_sets[w % cmd->width].evd_handle,
+		ret = dat_ep_create (hdl_sets[w % cmd->width].ia,
+				    hdl_sets[w % cmd->width].pz,
+				    hdl_sets[w % cmd->width].evd,
+				    hdl_sets[w % cmd->width].evd,
 				    conn_handle,
 				    (struct dat_ep_attr *) NULL,
 				    &epptr[w]);
@@ -738,10 +738,10 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		    break;
 		}
 
-		ret = dat_rsp_create (hdl_sets[w % cmd->width].ia_handle,
+		ret = dat_rsp_create (hdl_sets[w % cmd->width].ia,
 				    CONN_QUAL0 + w,
 				    epptr[w],
-				    hdl_sets[w % cmd->width].evd_handle,
+				    hdl_sets[w % cmd->width].evd,
 				    &hdlptr[w]);
 		if (DAT_GET_TYPE (ret) == DAT_NOT_IMPLEMENTED)
 		{
@@ -808,7 +808,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	 * See how many PSPs we can create
 	 */
 	unsigned int   count	= START_COUNT;
-	DAT_PSP_HANDLE *hdlptr	= (DAT_PSP_HANDLE *)
+	struct dat_sp **hdlptr	= (struct dat_sp **)
 				    DT_Mdep_Malloc (count * sizeof (*hdlptr));
 
 	/* PSP Exhaustion test loop */
@@ -822,7 +822,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	    {
 		DT_Mdep_Schedule();    
 		if (w == count
-		    && !more_handles (phead, (DAT_HANDLE **) &hdlptr,
+		    && !more_handles (phead, (void ***) &hdlptr,
 				    &count,
 				    sizeof (*hdlptr)))
 		{
@@ -830,9 +830,9 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		    retval = TRUE;
 		    break;
 		}
-		ret = dat_psp_create (hdl_sets[w % cmd->width].ia_handle,
+		ret = dat_psp_create (hdl_sets[w % cmd->width].ia,
 				    CONN_QUAL0 + w,
-				    hdl_sets[w % cmd->width].evd_handle,
+				    hdl_sets[w % cmd->width].evd,
 				    DAT_PSP_CONSUMER_FLAG,
 				    &hdlptr[w]);
 		if (ret != DAT_SUCCESS)
@@ -840,7 +840,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		    DT_Tdep_PT_Printf (phead, "%s: dat_psp_create #%d fails: %s\n",
 				    module,  w+1,  DT_RetToString (ret));
 		    retval = TRUE;
-		    hdlptr[w] = DAT_HANDLE_NULL;
+		    hdlptr[w] = NULL;
 		    break;
 		}
 	    }
@@ -897,14 +897,14 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	    memset (&region, 0, sizeof (region));
 	    region.for_va = hdl_sets[w].lmr_buffer;
 
-	    ret = dat_lmr_kcreate (hdl_sets[w].ia_handle,
+	    ret = dat_lmr_kcreate (hdl_sets[w].ia,
 				    DAT_MEM_TYPE_VIRTUAL,
 				    region,
 				    DFLT_BUFFSZ,
-				    hdl_sets[w].pz_handle,
+				    hdl_sets[w].pz,
 				    DAT_MEM_PRIV_ALL_FLAG,
 				    DAT_MEM_OPTIMIZE_DONT_CARE,
-				    &hdl_sets[w].lmr_handle,
+				    &hdl_sets[w].lmr,
 				    &hdl_sets[w].lmr_context,
 				      NULL,	/* FIXME */
 				    &reg_size, &reg_addr);
@@ -913,7 +913,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		DT_Tdep_PT_Printf (phead, "%s: dat_lmr_kcreate #%d fails: %s\n",
 				module,  w+1,  DT_RetToString (ret));
 		/* handle contents undefined on failure */
-		hdl_sets[w].lmr_handle = DAT_HANDLE_NULL;
+		hdl_sets[w].lmr = NULL;
 		goto clean_up_now;
 	    }
 	    if ((uintptr_t)reg_addr > (uintptr_t)hdl_sets[w].lmr_buffer
@@ -949,7 +949,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	    {
 		DT_Mdep_Schedule();
 		if (w == count
-		    && !more_handles (phead, (DAT_HANDLE **) &hdlptr,
+		    && !more_handles (phead, (void ***) &hdlptr,
 				    &count,
 				    sizeof (*hdlptr)))
 		{
@@ -966,10 +966,10 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		 */
 		hdlptr[w] = DT_BpoolAlloc ((Per_Test_Data_t *)0,
 					  phead,
-					  hdl_sets[w % cmd->width].ia_handle,
-					  hdl_sets[w % cmd->width].pz_handle,
-					  hdl_sets[w % cmd->width].ep_handle,
-					  hdl_sets[w % cmd->width].evd_handle,
+					  hdl_sets[w % cmd->width].ia,
+					  hdl_sets[w % cmd->width].pz,
+					  hdl_sets[w % cmd->width].ep,
+					  hdl_sets[w % cmd->width].evd,
 					  DFLT_BUFFSZ,
 					  1,
 					  256, /* FIXME should query for this */
@@ -1026,7 +1026,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 	    {
 		DT_Mdep_Schedule();
 		if (w == count
-		    && !more_handles (phead, (DAT_HANDLE **) &hdlptr,
+		    && !more_handles (phead, (void ***) &hdlptr,
 				    &count,
 				    cmd->width * sizeof (*hdlptr)))
 		{
@@ -1054,7 +1054,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 
 		    DT_Tdep_PT_Printf (phead, "%s: dat_ep_post_recv #%d\n", module,
 					w * cmd->width + i + 1);
-		    ret = dat_ep_post_recv (hdl_sets[i].ep_handle,
+		    ret = dat_ep_post_recv (hdl_sets[i].ep,
 					   1,
 					   iovp,
 					   cookie,
@@ -1091,7 +1091,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		 * outstanding recv DTOs in error, and otherwise
 		 * be a no-op.
 		 */
-		ret = dat_ep_reset (hdl_sets[i].ep_handle);
+		ret = dat_ep_reset (hdl_sets[i].ep);
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, "%s: dat_ep_disconnect (abrupt) fails: %s\n",
@@ -1107,7 +1107,7 @@ limit_test ( DT_Tdep_Print_Head *phead,
 		     */
 		    do
 		    {
-			ret = DT_Tdep_evd_dequeue ( hdl_sets[i].evd_handle,
+			ret = DT_Tdep_evd_dequeue ( hdl_sets[i].evd,
 					       &event);
 		    } while (ret == DAT_SUCCESS);
 		}
@@ -1130,10 +1130,10 @@ limit_test ( DT_Tdep_Print_Head *phead,
             DT_Mdep_Schedule();
 	    test_bpool = DT_BpoolAlloc ((Per_Test_Data_t *)0,
 		    			  phead,
-					  hdl_sets[0].ia_handle,
-					  hdl_sets[0].pz_handle,
-					  hdl_sets[0].ep_handle,
-					  hdl_sets[0].evd_handle,
+					  hdl_sets[0].ia,
+					  hdl_sets[0].pz,
+					  hdl_sets[0].ep,
+					  hdl_sets[0].evd,
 					  test_size,
 					  1,
 					  256, /* FIXME should query for this */
@@ -1185,9 +1185,9 @@ clean_up_now:
 
 	for (w = 0;  w < cmd->width;  w++)
 	{
-	    if (hdl_sets[w].lmr_handle)
+	    if (hdl_sets[w].lmr)
 	    {
-		ret = dat_lmr_free (hdl_sets[w].lmr_handle);
+		ret = dat_lmr_free (hdl_sets[w].lmr);
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, "%s: dat_lmr_free fails: %s\n",
@@ -1220,9 +1220,9 @@ clean_up_now:
 
 	for (w = 0;  w < cmd->width;  w++)
 	{
-	    if (hdl_sets[w].ep_handle)
+	    if (hdl_sets[w].ep)
 	    {
-		ret = dat_ep_free (hdl_sets[w].ep_handle);
+		ret = dat_ep_free (hdl_sets[w].ep);
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, "%s: dat_ep_free fails: %s\n",
@@ -1237,16 +1237,16 @@ clean_up_now:
     {
 	unsigned int  w;
 
-	if (conn_handle != DAT_HANDLE_NULL)
+	if (conn_handle != NULL)
 	{
 	    ret = DT_Tdep_evd_free (conn_handle);
-	    conn_handle = DAT_HANDLE_NULL;
+	    conn_handle = NULL;
 	}
 	for (w = 0;  w < cmd->width;  w++)
 	{
-	    if (hdl_sets[w].evd_handle)
+	    if (hdl_sets[w].evd)
 	    {
-		ret = DT_Tdep_evd_free (hdl_sets[w].evd_handle);
+		ret = DT_Tdep_evd_free (hdl_sets[w].evd);
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, "%s: dat_evd_free fails: %s\n",
@@ -1284,9 +1284,9 @@ clean_up_now:
 
 	for (w = 0;  w < cmd->width;  w++)
 	{
-	    if (hdl_sets[w].pz_handle)
+	    if (hdl_sets[w].pz)
 	    {
-		ret = dat_pz_free (hdl_sets[w].pz_handle);
+		ret = dat_pz_free (hdl_sets[w].pz);
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, "%s: dat_pz_free fails: %s\n",
@@ -1303,10 +1303,10 @@ clean_up_now:
 
 	for (w = 0;  w < cmd->width;  w++)
 	{
-	    if (hdl_sets[w].ia_handle)
+	    if (hdl_sets[w].ia)
 	    {
 		/* dat_ia_close cleans up async evd handle, too */
-		ret = dat_ia_close (hdl_sets[w].ia_handle,
+		ret = dat_ia_close (hdl_sets[w].ia,
 				    DAT_CLOSE_GRACEFUL_FLAG);
 		if (ret != DAT_SUCCESS)
 		{
@@ -1318,7 +1318,7 @@ clean_up_now:
 		     * we may as well try the largest hammer we have.
 		     */
 		    retval = FALSE;
-		    ret = dat_ia_close (hdl_sets[w].ia_handle,
+		    ret = dat_ia_close (hdl_sets[w].ia,
 					DAT_CLOSE_ABRUPT_FLAG);
 		    if (ret != DAT_SUCCESS)
 		    {
Index: linux-kernel/test/dapltest/test/dapl_fft_queryinfo.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_fft_queryinfo.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_fft_queryinfo.c	(working copy)
@@ -37,31 +37,31 @@ int DT_queryinfo_basic (Params_t *params
 			u32  result_wanted)
 {
     char *dev_name;
-    DAT_IA_HANDLE ia_handle;
+    struct dat_ia *ia;
     struct dat_ia_attr ia_attributes;
     struct dat_provider_attr provider_attributes;
-    DAT_EVD_HANDLE evd_handle;
-    DAT_EVD_HANDLE conn_evd_handle;
-    DAT_EVD_HANDLE cr_evd_handle;
-    DAT_EVD_HANDLE send_evd_handle;
-    DAT_EVD_HANDLE recv_evd_handle;
-    DAT_EP_HANDLE ep_handle;
+    struct dat_evd *evd;
+    struct dat_evd *conn_evd;
+    struct dat_evd *cr_evd;
+    struct dat_evd *send_evd;
+    struct dat_evd *recv_evd;
+    struct dat_ep *ep;
     struct dat_ep_param ep_param;
     DAT_CNO_HANDLE cno_handle;
 #ifndef __KDAPLTEST__
     DAT_CNO_PARAM  cno_param;
 #endif
     struct dat_evd_param  evd_param;
-    DAT_PSP_HANDLE  psp_handle;
+    struct dat_sp * psp;
     struct dat_psp_param psp_param;
-    DAT_RSP_HANDLE  rsp_handle;
+    struct dat_sp * rsp;
     struct dat_rsp_param rsp_param;
-    DAT_PZ_HANDLE pz_handle;
+    struct dat_pz *pz;
     struct dat_pz_param pz_param;
-    DAT_LMR_HANDLE lmr_handle;
+    struct dat_lmr *lmr;
     struct dat_lmr_param lmr_param;
     DAT_LMR_CONTEXT lmr_context;
-    DAT_RMR_HANDLE rmr_handle;
+    struct dat_rmr * rmr_handle;
     struct dat_rmr_param rmr_param;
     DAT_REGION_DESCRIPTION region;
     u64 reg_size;
@@ -77,30 +77,30 @@ int DT_queryinfo_basic (Params_t *params
     reg_addr = 0;
     alloc_ptr = NULL;
 
-    ia_handle = NULL;
-    pz_handle = NULL;
-    ep_handle = NULL;
-    lmr_handle = NULL;
+    ia = NULL;
+    pz = NULL;
+    ep = NULL;
+    lmr = NULL;
     rmr_handle = NULL;
-    pz_handle = NULL;
-    psp_handle = NULL;
-    rsp_handle = NULL;
+    pz = NULL;
+    psp = NULL;
+    rsp = NULL;
     cno_handle = NULL;
-    evd_handle = DAT_HANDLE_NULL;
-    conn_evd_handle = DAT_HANDLE_NULL;
-    cr_evd_handle = DAT_HANDLE_NULL;
-    recv_evd_handle = DAT_HANDLE_NULL;
-    send_evd_handle = DAT_HANDLE_NULL;
+    evd = NULL;
+    conn_evd = NULL;
+    cr_evd = NULL;
+    recv_evd = NULL;
+    send_evd = NULL;
     dev_name = cmd->device_name;
 
-    /* All functions require an ia_handle to be created */
+    /* All functions require an ia to be created */
     rc = dat_ia_open ((const char *)dev_name,
 		       DEFAULT_QUEUE_LEN,
-		       &evd_handle,
-		       &ia_handle);
+		       &evd,
+		       &ia);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
-    /* These functions require a pz_handle to be created */
+    /* These functions require a pz to be created */
     if ( (object_to_query == QUERY_EVD) ||
 	 (object_to_query == QUERY_RMR) ||
 	 (object_to_query == QUERY_LMR) ||
@@ -108,43 +108,43 @@ int DT_queryinfo_basic (Params_t *params
 	 (object_to_query == QUERY_RSP) ||
 	 (object_to_query == QUERY_PZ) )
     {
-	rc = dat_pz_create (ia_handle,
-			    &pz_handle);
+	rc = dat_pz_create (ia,
+			    &pz);
 	DT_assert_dat (phead, rc == DAT_SUCCESS);
     }
 
-    /* These functions require a ep_handle to be created */
+    /* These functions require a ep to be created */
     if ( (object_to_query == QUERY_EP) ||
 	 (object_to_query == QUERY_RSP) )
     {
-	rc = DT_Tdep_evd_create (ia_handle,
+	rc = DT_Tdep_evd_create (ia,
 			     DEFAULT_QUEUE_LEN,
 			     cno_handle,
 			     DAT_EVD_DTO_FLAG | DAT_EVD_RMR_BIND_FLAG,
-			     &send_evd_handle);
+			     &send_evd);
 	DT_assert_dat (phead, rc == DAT_SUCCESS);
 
-	rc = DT_Tdep_evd_create (ia_handle,
+	rc = DT_Tdep_evd_create (ia,
 			     DEFAULT_QUEUE_LEN,
 			     cno_handle,
 			     DAT_EVD_DTO_FLAG,
-			     &recv_evd_handle);
+			     &recv_evd);
 	DT_assert_dat (phead, rc == DAT_SUCCESS);
 
-	rc = DT_Tdep_evd_create (ia_handle,
+	rc = DT_Tdep_evd_create (ia,
 			     DEFAULT_QUEUE_LEN,
 			     cno_handle,
 			     DAT_EVD_CONNECTION_FLAG,
-			     &conn_evd_handle);
+			     &conn_evd);
 	DT_assert_dat (phead, rc == DAT_SUCCESS);
 
-	rc = dat_ep_create (ia_handle,
-			    pz_handle,
-			    recv_evd_handle,
-			    send_evd_handle,
-			    conn_evd_handle,
+	rc = dat_ep_create (ia,
+			    pz,
+			    recv_evd,
+			    send_evd,
+			    conn_evd,
 			    NULL,
-			    &ep_handle);
+			    &ep);
 	DT_assert_dat (phead, rc == DAT_SUCCESS);
     }
 
@@ -152,11 +152,11 @@ int DT_queryinfo_basic (Params_t *params
     if ( (object_to_query == QUERY_PSP) ||
 	 (object_to_query == QUERY_RSP) )
     {
-	rc = DT_Tdep_evd_create (ia_handle,
+	rc = DT_Tdep_evd_create (ia,
 			     DEFAULT_QUEUE_LEN,
 			     cno_handle,
 			     DAT_EVD_CR_FLAG,
-			     &cr_evd_handle);
+			     &cr_evd);
 	DT_assert_dat (phead, rc == DAT_SUCCESS);
     }
 
@@ -165,8 +165,8 @@ int DT_queryinfo_basic (Params_t *params
     {
 	if (result_wanted == DAT_SUCCESS)
 	{
-	    rc = dat_ia_query (ia_handle,
-			       &evd_handle,
+	    rc = dat_ia_query (ia,
+			       &evd,
 			       &ia_attributes,
 			       &provider_attributes);
 	}
@@ -177,15 +177,15 @@ int DT_queryinfo_basic (Params_t *params
 	     * NULL out ia_attr and for the DAT_IA_ATTR_MASK to
 	     * have values
 	     */
-	    rc = dat_ia_query (ia_handle,
-			       &evd_handle,
+	    rc = dat_ia_query (ia,
+			       &evd,
 			       NULL,
 			       &provider_attributes);
 	}
 	else if (result_wanted == DAT_INVALID_HANDLE)
 	{
-	    rc = dat_ia_query (evd_handle,
-			       &evd_handle,
+	    rc = dat_ia_query (ia,
+			       &evd,
 			       &ia_attributes,
 			       &provider_attributes);
 	}
@@ -197,11 +197,11 @@ int DT_queryinfo_basic (Params_t *params
 
 #ifndef __KDAPLTEST__
 #if defined(WIN32)
-	rc = dat_cno_create (ia_handle,
+	rc = dat_cno_create (ia,
 						NULLPROXY,
 						&cno_handle);
 #else
-	rc = dat_cno_create (ia_handle,
+	rc = dat_cno_create (ia,
 			     DAT_OS_WAIT_PROXY_AGENT_NULL,
 			     &cno_handle);
 #endif
@@ -220,7 +220,7 @@ int DT_queryinfo_basic (Params_t *params
 	}
 	else if (result_wanted == DAT_INVALID_HANDLE)
 	{
-	    rc = dat_cno_query (ia_handle,
+	    rc = dat_cno_query (ia,
 				&cno_param);
 	}
 #endif
@@ -230,17 +230,17 @@ int DT_queryinfo_basic (Params_t *params
     {
 	if (result_wanted == DAT_SUCCESS)
 	{
-	    rc = dat_evd_query (evd_handle,
+	    rc = dat_evd_query (evd,
 				&evd_param);
 	}
 	else if (result_wanted == DAT_INVALID_PARAMETER)
 	{
-	    rc = dat_evd_query (evd_handle,
+	    rc = dat_evd_query (evd,
 				NULL);
 	}
 	else if (result_wanted == DAT_INVALID_HANDLE)
 	{
-	    rc = dat_evd_query (ia_handle,
+	    rc = dat_evd_query (evd,
 				&evd_param);
 	}
     }
@@ -248,25 +248,25 @@ int DT_queryinfo_basic (Params_t *params
     /* Test dat_psp_query function */
     else if (object_to_query == QUERY_PSP)
     {
-	rc = dat_psp_create (ia_handle,
+	rc = dat_psp_create (ia,
 			     SERVER_PORT_NUMBER,
-			     cr_evd_handle,
+			     cr_evd,
 			     DAT_PSP_PROVIDER_FLAG,
-			     &psp_handle);
+			     &psp);
 	DT_assert_dat (phead, rc == DAT_SUCCESS);
 	if (result_wanted == DAT_SUCCESS)
 	{
-	    rc = dat_psp_query (psp_handle,
+	    rc = dat_psp_query (psp,
 				&psp_param);
 	}
 	else if (result_wanted == DAT_INVALID_PARAMETER)
 	{
-	    rc = dat_psp_query (psp_handle,
+	    rc = dat_psp_query (psp,
 				NULL);
 	}
 	else if (result_wanted == DAT_INVALID_HANDLE)
 	{
-	    rc = dat_psp_query (evd_handle,
+	    rc = dat_psp_query (psp,
 				&psp_param);
 	}
     }
@@ -274,13 +274,13 @@ int DT_queryinfo_basic (Params_t *params
     /* Test dat_rsp_query function */
     else if (object_to_query == QUERY_RSP)
     {
-	rc = dat_rsp_create (ia_handle,
+	rc = dat_rsp_create (ia,
 			     SERVER_PORT_NUMBER,
-			     ep_handle,
-			     cr_evd_handle,
-			     &rsp_handle);
+			     ep,
+			     cr_evd,
+			     &rsp);
 	DT_assert_dat (phead, rc == DAT_SUCCESS);
-	rc = dat_rsp_query (rsp_handle,
+	rc = dat_rsp_query (rsp,
 			    &rsp_param);
     }
 
@@ -294,14 +294,14 @@ int DT_queryinfo_basic (Params_t *params
     /* Test dat_ep_query function */
     else if (object_to_query == QUERY_EP)
     {
-	rc = dat_ep_query (ep_handle,
+	rc = dat_ep_query (ep,
 			   &ep_param);
     }
 
     /* Test dat_pz_query function */
     else if (object_to_query == QUERY_PZ)
     {
-	rc = dat_pz_query (pz_handle,
+	rc = dat_pz_query (pz,
 			   &pz_param);
     }
 
@@ -312,27 +312,27 @@ int DT_queryinfo_basic (Params_t *params
 	DT_assert (phead, alloc_ptr);
 	memset (&region, 0, sizeof (region));
 	region.for_va = alloc_ptr;
-	rc = dat_lmr_kcreate (ia_handle,
+	rc = dat_lmr_kcreate (ia,
 				 DAT_MEM_TYPE_VIRTUAL,
 				 region,
 				 buffer_size,
-				 pz_handle,
+				 pz,
 				 DAT_MEM_PRIV_ALL_FLAG,
 				 DAT_MEM_OPTIMIZE_DONT_CARE,
-				 &lmr_handle,
+				 &lmr,
 				 &lmr_context,
 				 NULL,	/* FIXME */
 				 &reg_size,
 				 &reg_addr);
 	DT_assert_dat (phead, rc == DAT_SUCCESS);
-	rc = dat_lmr_query (lmr_handle,
+	rc = dat_lmr_query (lmr,
 			    &lmr_param);
     }
 
     /* Test dat_rmr_query function */
     else if (object_to_query == QUERY_RMR)
     {
-	rc = dat_rmr_create (pz_handle,
+	rc = dat_rmr_create (pz,
 			     &rmr_handle);
 	DT_assert_dat (phead, rc == DAT_SUCCESS);
 	rc = dat_rmr_query (rmr_handle,
@@ -342,39 +342,39 @@ int DT_queryinfo_basic (Params_t *params
     DT_assert_dat (phead, DAT_GET_TYPE (rc) == result_wanted);
 
 cleanup:
-    if (rsp_handle)
+    if (rsp)
     {
-	rc = dat_rsp_free (rsp_handle);
+	rc = dat_rsp_free (rsp);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
-    if (ep_handle)
+    if (ep)
     {
-	rc = dat_ep_free (ep_handle);
+	rc = dat_ep_free (ep);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
-    if (send_evd_handle)
+    if (send_evd)
     {
-	rc = DT_Tdep_evd_free (send_evd_handle);
+	rc = DT_Tdep_evd_free (send_evd);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
-    if (recv_evd_handle)
+    if (recv_evd)
     {
-	rc = DT_Tdep_evd_free (recv_evd_handle);
+	rc = DT_Tdep_evd_free (recv_evd);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
-    if (conn_evd_handle)
+    if (conn_evd)
     {
-	rc = DT_Tdep_evd_free (conn_evd_handle);
+	rc = DT_Tdep_evd_free (conn_evd);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
-    if (lmr_handle)
+    if (lmr)
     {
-	rc = dat_lmr_free (lmr_handle);
+	rc = dat_lmr_free (lmr);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
@@ -391,27 +391,27 @@ cleanup:
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 #endif
-    if (psp_handle)
+    if (psp)
     {
-	rc = dat_psp_free (psp_handle);
+	rc = dat_psp_free (psp);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
-    if (cr_evd_handle)
+    if (cr_evd)
     {
-	rc = DT_Tdep_evd_free (cr_evd_handle);
+	rc = DT_Tdep_evd_free (cr_evd);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
-    if (pz_handle)
+    if (pz)
     {
-	rc = dat_pz_free (pz_handle);
+	rc = dat_pz_free (pz);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
-    if (ia_handle)
+    if (ia)
     {
-	rc = dat_ia_close (ia_handle, DAT_CLOSE_ABRUPT_FLAG);
+	rc = dat_ia_close (ia, DAT_CLOSE_ABRUPT_FLAG);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
Index: linux-kernel/test/dapltest/test/dapl_transaction_test.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_transaction_test.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_transaction_test.c	(working copy)
@@ -47,7 +47,7 @@
 /****************************************************************************/
 int
 DT_Transaction_Test_Client (Per_Test_Data_t * pt_ptr,
-			DAT_IA_HANDLE ia_handle,
+			struct dat_ia *ia,
 			struct sockaddr *remote_ia_addr)
 {
     Transaction_Cmd_t *cmd = &pt_ptr->Params.u.Transaction_Cmd;
@@ -68,7 +68,7 @@ DT_Transaction_Test_Client (Per_Test_Dat
 
 	DT_Tdep_PT_Debug (1,(phead,"Client: Starting Client side of test\n"));
 	if (!DT_Transaction_Create_Test (pt_ptr,
-				     ia_handle,
+				     ia,
 				     FALSE,
 				     port_num,
 				     pt_ptr->Server_Info.is_little_endian,
@@ -110,7 +110,7 @@ DT_Transaction_Test_Server (void *params
 					+ i * cmd->eps_per_thread;
 
 	if (!DT_Transaction_Create_Test (pt_ptr,
-				     pt_ptr->ps_ptr->ia_handle,
+				     pt_ptr->ps_ptr->ia,
 				     TRUE,
 				     port_num,
 				     pt_ptr->Client_Info.is_little_endian,
@@ -156,7 +156,7 @@ DT_Transaction_Test_Server (void *params
 
 boolean_t
 DT_Transaction_Create_Test (Per_Test_Data_t * pt_ptr,
-			DAT_IA_HANDLE *ia_handle,
+			struct dat_ia *ia,
 			boolean_t is_server,
 			unsigned int port_num,
 			boolean_t remote_is_little_endian,
@@ -181,7 +181,7 @@ DT_Transaction_Create_Test (Per_Test_Dat
     test_ptr->remote_is_little_endian = remote_is_little_endian;
     test_ptr->is_server	     = is_server;
     test_ptr->pt_ptr	     = pt_ptr;
-    test_ptr->ia_handle	     = ia_handle;
+    test_ptr->ia	     = ia;
     test_ptr->base_port     = (DAT_CONN_QUAL) port_num;
     test_ptr->cmd	     = &pt_ptr->Params.u.Transaction_Cmd;
     test_ptr->time_out	     = DFLT_TMO * 1000;	    /* DFLT_TMO seconds  */
@@ -244,18 +244,18 @@ DT_Transaction_Main (void *param)
     private_data_str = "DAPL and RDMA rule! Test 4321.";
 
     /* create a protection zone */
-    ret = dat_pz_create (test_ptr->ia_handle, &test_ptr->pz_handle);
+    ret = dat_pz_create (test_ptr->ia, &test_ptr->pz);
     if (ret != DAT_SUCCESS)
     {
 	DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_pz_create error: %s\n",
 		    test_ptr->base_port, DT_RetToString (ret));
-	test_ptr->pz_handle = DAT_HANDLE_NULL;
+	test_ptr->pz = NULL;
         status = 1;
 	goto test_failure;
     }
 
     /* create 4 EVDs - recv, request+RMR, conn-request, connect */
-    ret = DT_Tdep_evd_create (test_ptr->ia_handle,
+    ret = DT_Tdep_evd_create (test_ptr->ia,
 			      test_ptr->evd_length,
 			      NULL,
 			      DAT_EVD_DTO_FLAG,
@@ -264,12 +264,12 @@ DT_Transaction_Main (void *param)
     {
 	DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_evd_create (recv) error: %s\n",
 		    test_ptr->base_port, DT_RetToString (ret));
-	test_ptr->recv_evd_hdl = DAT_HANDLE_NULL;
+	test_ptr->recv_evd_hdl = NULL;
         status = 1;
 	goto test_failure;
     }
 
-    ret = DT_Tdep_evd_create (test_ptr->ia_handle,
+    ret = DT_Tdep_evd_create (test_ptr->ia,
 			      test_ptr->evd_length,
 			      NULL,
 			      DAT_EVD_DTO_FLAG | DAT_EVD_RMR_BIND_FLAG,
@@ -278,7 +278,7 @@ DT_Transaction_Main (void *param)
     {
 	DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_evd_create (request) error: %s\n",
 		    test_ptr->base_port, DT_RetToString (ret));
-	test_ptr->reqt_evd_hdl = DAT_HANDLE_NULL;
+	test_ptr->reqt_evd_hdl = NULL;
         status = 1;
 	goto test_failure;
     }
@@ -286,7 +286,7 @@ DT_Transaction_Main (void *param)
     if (pt_ptr->local_is_server)
     {
 	/* Client-side doesn't need CR events */
-	ret = DT_Tdep_evd_create (test_ptr->ia_handle,
+	ret = DT_Tdep_evd_create (test_ptr->ia,
 				  test_ptr->evd_length,
 				  NULL,
 				  DAT_EVD_CR_FLAG,
@@ -295,13 +295,13 @@ DT_Transaction_Main (void *param)
 	{
 	    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_evd_create (cr) error: %s\n",
 			test_ptr->base_port, DT_RetToString (ret));
-	    test_ptr->creq_evd_hdl = DAT_HANDLE_NULL;
+	    test_ptr->creq_evd_hdl = NULL;
             status = 1;
 	    goto test_failure;
 	}
     }
 
-    ret = DT_Tdep_evd_create (test_ptr->ia_handle,
+    ret = DT_Tdep_evd_create (test_ptr->ia,
 			      test_ptr->evd_length,
 			      NULL,
 			      DAT_EVD_CONNECTION_FLAG,
@@ -310,7 +310,7 @@ DT_Transaction_Main (void *param)
     {
 	DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_evd_create (conn) error: %s\n",
 		    test_ptr->base_port, DT_RetToString (ret));
-	test_ptr->conn_evd_hdl = DAT_HANDLE_NULL;
+	test_ptr->conn_evd_hdl = NULL;
         status = 1;
 	goto test_failure;
     }
@@ -363,18 +363,18 @@ DT_Transaction_Main (void *param)
 	}
 
 	/* Create EP */
-	ret = dat_ep_create (test_ptr->ia_handle,    /* IA       */
-			    test_ptr->pz_handle,    /* PZ       */
+	ret = dat_ep_create (test_ptr->ia,    /* IA       */
+			    test_ptr->pz,    /* PZ       */
 			    test_ptr->recv_evd_hdl, /* recv     */
 			    test_ptr->reqt_evd_hdl, /* request  */
 			    test_ptr->conn_evd_hdl, /* connect  */
 			    &ep_attr,		    /* EP attrs */
-			    &test_ptr->ep_context[i].ep_handle);
+			    &test_ptr->ep_context[i].ep);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_ep_create #%d error: %s\n",
 			test_ptr->base_port, i, DT_RetToString (ret));
-	    test_ptr->ep_context[i].ep_handle = DAT_HANDLE_NULL;
+	    test_ptr->ep_context[i].ep = NULL;
             status = 1;
 	    goto test_failure;
 	}
@@ -385,10 +385,10 @@ DT_Transaction_Main (void *param)
 	 */
 	test_ptr->ep_context[i].bp = DT_BpoolAlloc (pt_ptr,
 						phead,
-						test_ptr->ia_handle,
-						test_ptr->pz_handle,
-					    test_ptr->ep_context[i].ep_handle,
-						DAT_HANDLE_NULL, /* rmr */
+						test_ptr->ia,
+						test_ptr->pz,
+					    test_ptr->ep_context[i].ep,
+						NULL, /* rmr */
 						buff_size,
 						4,
 						pt_ptr->provider_attr.optimal_buffer_alignment,
@@ -423,7 +423,7 @@ DT_Transaction_Main (void *param)
 	 * Post recv and sync buffers
 	 */
 	if (!DT_post_recv_buffer ( phead,
-		    		    test_ptr->ep_context[i].ep_handle,
+		    		    test_ptr->ep_context[i].ep,
 				    test_ptr->ep_context[i].bp,
 				    RMI_RECV_BUFFER_ID,
 				    buff_size))
@@ -433,7 +433,7 @@ DT_Transaction_Main (void *param)
 	    goto test_failure;
 	}
 	if (!DT_post_recv_buffer ( phead,
-		    		    test_ptr->ep_context[i].ep_handle,
+		    		    test_ptr->ep_context[i].ep,
 				    test_ptr->ep_context[i].bp,
 				    SYNC_RECV_BUFFER_ID,
 				    SYNC_BUFF_SIZE))
@@ -457,11 +457,11 @@ DT_Transaction_Main (void *param)
 		 *	    await a connection for this EP
 		 */
 
-		ret = dat_rsp_create (test_ptr->ia_handle,
+		ret = dat_rsp_create (test_ptr->ia,
 				     test_ptr->ep_context[i].ia_port,
-				     test_ptr->ep_context[i].ep_handle,
+				     test_ptr->ep_context[i].ep,
 				     test_ptr->creq_evd_hdl,
-					&test_ptr->ep_context[i].rsp_handle);
+					&test_ptr->ep_context[i].rsp);
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_rsp_create #%d error: %s\n",
@@ -472,11 +472,11 @@ DT_Transaction_Main (void *param)
 	    }
 	    else
 	    {
-		ret = dat_psp_create (test_ptr->ia_handle,
+		ret = dat_psp_create (test_ptr->ia,
 				      test_ptr->ep_context[i].ia_port,
 				      test_ptr->creq_evd_hdl,
 				      DAT_PSP_CONSUMER_FLAG,
-				      &test_ptr->ep_context[i].psp_handle);
+				      &test_ptr->ep_context[i].psp);
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_psp_create #%d error: %s\n",
@@ -519,7 +519,7 @@ DT_Transaction_Main (void *param)
 	RemoteMemoryInfo    *RemoteMemInfo;
 	struct dat_dto_completion_event_data dto_stat;
 	struct dat_cr_arrival_event_data   cr_stat;
-	DAT_CR_HANDLE               cr_handle;
+	struct dat_cr *              cr;
 
 	/*
 	 * Establish the connection
@@ -538,16 +538,16 @@ DT_Transaction_Main (void *param)
 				       &cr_stat) ||
 		    !DT_cr_check ( phead,
 				   &cr_stat,
-				   test_ptr->ep_context[i].rsp_handle,
+				   test_ptr->ep_context[i].rsp,
 				    test_ptr->ep_context[i].ia_port,
-				    &cr_handle,
+				    &cr,
 				    "Server") )
 		{
                     status = 1;
 		    goto test_failure;
 		}
 
-		ret = dat_cr_query (cr_handle, &cr_param);
+		ret = dat_cr_query (cr, &cr_param);
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_cr_query #%d error:(%x) %s\n",
@@ -571,21 +571,21 @@ DT_Transaction_Main (void *param)
 		}
 
 		/* what, me query?  just try to accept the connection */
-		ret = dat_cr_accept (cr_handle,
+		ret = dat_cr_accept (cr,
 				     NULL, /* NULL for RSP */
 				     0, (void *)0 /* no private data */ );
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_cr_accept #%d error: %s\n",
 				test_ptr->base_port, i, DT_RetToString (ret));
-		    /* cr_handle consumed on failure */
+		    /* cr consumed on failure */
                     status = 1;
 		    goto test_failure;
 		}
 
 		/* wait for DAT_CONNECTION_EVENT_ESTABLISHED */
 		if (!DT_conn_event_wait (  phead,
-			    		   test_ptr->ep_context[i].ep_handle,
+			    		   test_ptr->ep_context[i].ep,
 					   test_ptr->conn_evd_hdl,
 					   &event_num))
 		{
@@ -594,7 +594,7 @@ DT_Transaction_Main (void *param)
 		    goto test_failure;
 		}
 		/* throw away single-use PSP */
-		ret = dat_rsp_free (test_ptr->ep_context[i].rsp_handle);
+		ret = dat_rsp_free (test_ptr->ep_context[i].rsp);
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_rsp_free #%d error: %s\n",
@@ -622,16 +622,16 @@ DT_Transaction_Main (void *param)
 
 		if (  !DT_cr_check ( phead,
 			    	   &cr_stat,
-				     test_ptr->ep_context[i].psp_handle,
+				     test_ptr->ep_context[i].psp,
 				     test_ptr->ep_context[i].ia_port,
-				     &cr_handle,
+				     &cr,
 				     "Server") )
 		{
                     status = 1;
 		    goto test_failure;
 		}
 
-		ret = dat_cr_query (cr_handle, &cr_param);
+		ret = dat_cr_query (cr, &cr_param);
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_cr_query #%d error: %s\n",
@@ -656,33 +656,33 @@ DT_Transaction_Main (void *param)
 
 
 		/* what, me query?  just try to accept the connection */
-		ret = dat_cr_accept (cr_handle,
-				    test_ptr->ep_context[i].ep_handle,
+		ret = dat_cr_accept (cr,
+				    test_ptr->ep_context[i].ep,
 				    0, (void *)0 /* no private data */ );
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_cr_accept #%d error: %s\n",
 				test_ptr->base_port, i, DT_RetToString (ret));
-		    /* cr_handle consumed on failure */
-		    (void) dat_psp_free (test_ptr->ep_context[i].psp_handle);
+		    /* cr consumed on failure */
+		    (void) dat_psp_free (test_ptr->ep_context[i].psp);
                     status = 1;
 		    goto test_failure;
 		}
 
 		/* wait for DAT_CONNECTION_EVENT_ESTABLISHED */
 		if (!DT_conn_event_wait (  phead,
-			    		    test_ptr->ep_context[i].ep_handle,
+			    		    test_ptr->ep_context[i].ep,
 					    test_ptr->conn_evd_hdl,
 					   &event_num))
 		{
 		    /* error message printed by DT_cr_event_wait */
-		    (void) dat_psp_free (&test_ptr->ep_context[i].psp_handle);
+		    (void) dat_psp_free (test_ptr->ep_context[i].psp);
                     status = 1;
 		    goto test_failure;
 		}
 
 		/* throw away single-use PSP */
-		ret = dat_psp_free (test_ptr->ep_context[i].psp_handle);
+		ret = dat_psp_free (test_ptr->ep_context[i].psp);
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_psp_free #%d error: %s\n",
@@ -709,7 +709,7 @@ DT_Transaction_Main (void *param)
 			    test_ptr->ep_context[i].ia_port));
 
 retry:
-	    ret = dat_ep_connect (test_ptr->ep_context[i].ep_handle,
+	    ret = dat_ep_connect (test_ptr->ep_context[i].ep,
 				  test_ptr->remote_ia_addr,
 				  test_ptr->ep_context[i].ia_port,
 				  DAT_TIMEOUT_MAX,
@@ -726,7 +726,7 @@ retry:
 
 	    /* wait for DAT_CONNECTION_EVENT_ESTABLISHED */
 	    if (!DT_conn_event_wait (  phead,
-				       test_ptr->ep_context[i].ep_handle,
+				       test_ptr->ep_context[i].ep,
 				       test_ptr->conn_evd_hdl,
 				       &event_num))
 	    {
@@ -742,7 +742,7 @@ retry:
 			struct dat_event       event;
 			int	drained = 0;
 
-			dat_ep_reset (test_ptr->ep_context[i].ep_handle);
+			dat_ep_reset (test_ptr->ep_context[i].ep);
 			do
 			{
 			    ret = DT_Tdep_evd_dequeue ( test_ptr->recv_evd_hdl,
@@ -756,7 +756,7 @@ retry:
 			     * Post recv and sync buffers
 			     */
 			    if (!DT_post_recv_buffer ( phead,
-							test_ptr->ep_context[i].ep_handle,
+							test_ptr->ep_context[i].ep,
 						       test_ptr->ep_context[i].bp,
 						       RMI_RECV_BUFFER_ID,
 						       buff_size))
@@ -766,7 +766,7 @@ retry:
 				goto test_failure;
 			    }
 			    if (!DT_post_recv_buffer ( phead,
-							test_ptr->ep_context[i].ep_handle,
+							test_ptr->ep_context[i].ep,
 						       test_ptr->ep_context[i].bp,
 						       SYNC_RECV_BUFFER_ID,
 						       SYNC_BUFF_SIZE))
@@ -835,9 +835,9 @@ retry:
 		    test_ptr->ep_context[i].op[j].bp =
 			DT_BpoolAlloc (pt_ptr,
 				   phead,
-				   test_ptr->ia_handle,
-				   test_ptr->pz_handle,
-				   test_ptr->ep_context[i].ep_handle,
+				   test_ptr->ia,
+				   test_ptr->pz,
+				   test_ptr->ep_context[i].ep,
 				   test_ptr->reqt_evd_hdl,
 				   test_ptr->ep_context[i].op[j].seg_size,
 				   test_ptr->ep_context[i].op[j].num_segs,
@@ -871,9 +871,9 @@ retry:
 		    test_ptr->ep_context[i].op[j].bp =
 			DT_BpoolAlloc (pt_ptr,
 				   phead,
-				   test_ptr->ia_handle,
-				   test_ptr->pz_handle,
-				   test_ptr->ep_context[i].ep_handle,
+				   test_ptr->ia,
+				   test_ptr->pz,
+				   test_ptr->ep_context[i].ep,
 				   test_ptr->reqt_evd_hdl,
 				   test_ptr->ep_context[i].op[j].seg_size,
 				   test_ptr->ep_context[i].op[j].num_segs,
@@ -906,10 +906,10 @@ retry:
 		    test_ptr->ep_context[i].op[j].bp =
 			DT_BpoolAlloc (pt_ptr,
 				   phead,
-				   test_ptr->ia_handle,
-				   test_ptr->pz_handle,
-				   test_ptr->ep_context[i].ep_handle,
-				   DAT_HANDLE_NULL, /* rmr */
+				   test_ptr->ia,
+				   test_ptr->pz,
+				   test_ptr->ep_context[i].ep,
+				   NULL, /* rmr */
 				   test_ptr->ep_context[i].op[j].seg_size,
 				   test_ptr->ep_context[i].op[j].num_segs,
 				   pt_ptr->provider_attr.optimal_buffer_alignment,
@@ -976,7 +976,7 @@ retry:
 
 	/* post the send buffer */
 	if (!DT_post_send_buffer (phead,
-		    		  test_ptr->ep_context[i].ep_handle,
+		    		  test_ptr->ep_context[i].ep,
 				  test_ptr->ep_context[i].bp,
 				  RMI_SEND_BUFFER_ID,
 				  buff_size))
@@ -993,7 +993,7 @@ retry:
 	if (!DT_dto_event_wait (phead, test_ptr->reqt_evd_hdl, &dto_stat) ||
 	    !DT_dto_check ( phead,
 			    &dto_stat,
-			    test_ptr->ep_context[i].ep_handle,
+			    test_ptr->ep_context[i].ep,
 			    buff_size,
 			    dto_cookie,
 			    test_ptr->is_server ? "Client_Mem_Info_Send"
@@ -1017,7 +1017,7 @@ retry:
 	if (!DT_dto_event_wait (phead, test_ptr->recv_evd_hdl, &dto_stat) ||
 	    !DT_dto_check ( phead,
 		 	    &dto_stat,
-			    test_ptr->ep_context[i].ep_handle,
+			    test_ptr->ep_context[i].ep,
 			    buff_size,
 			    dto_cookie,
 			    test_ptr->is_server ? "Client_Mem_Info_Recv"
@@ -1082,9 +1082,9 @@ test_failure:
 	/* Foreach EP */
 	for (i = 0;  i < test_ptr->cmd->eps_per_thread;  i++)
 	{
-	    DAT_EP_HANDLE               ep_handle;
+	    struct dat_ep *              ep;
 
-	    ep_handle = DAT_HANDLE_NULL;
+	    ep = NULL;
 
 	    /* Free the per-op buffers */
 	    for (j = 0;  j < test_ptr->cmd->num_ops;  j++)
@@ -1122,9 +1122,9 @@ test_failure:
 	     *		     bailed out mid-setup, or ran to completion
 	     *		     normally, so we use abrupt closure.
 	     */
-	    if (test_ptr->ep_context[i].ep_handle)
+	    if (test_ptr->ep_context[i].ep)
 	    {
-		ret = dat_ep_disconnect (test_ptr->ep_context[i].ep_handle,
+		ret = dat_ep_disconnect (test_ptr->ep_context[i].ep,
 					DAT_CLOSE_ABRUPT_FLAG);
 		if (ret != DAT_SUCCESS)
 		{
@@ -1148,7 +1148,7 @@ test_failure:
 	    {
 		if (!DT_disco_event_wait ( phead,
 			    		   test_ptr->conn_evd_hdl,
-						    &ep_handle))
+						    &ep))
 		{
 		    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: bad disconnect event\n",
 				    test_ptr->base_port);
@@ -1164,16 +1164,16 @@ test_failure:
 		     */
 		    for (j = 0;  j < test_ptr->cmd->eps_per_thread;  j++)
 		    {
-			if ( test_ptr->ep_context[j].ep_handle == ep_handle )
+			if ( test_ptr->ep_context[j].ep == ep )
 			{
-			    test_ptr->ep_context[j].ep_handle = NULL;
+			    test_ptr->ep_context[j].ep = NULL;
 			}
 		    }
 		}
 	    }
 	    else /* !success - QP may be in error state */
 	    {
-		ep_handle =  test_ptr->ep_context[i].ep_handle;
+		ep =  test_ptr->ep_context[i].ep;
 	    }
 
 	    /*
@@ -1182,7 +1182,7 @@ test_failure:
 	     * disconnected as we are racing with the remote side
 	     * disconnects.
 	     */
-	    if ( DAT_HANDLE_NULL != ep_handle)
+	    if ( NULL != ep)
 	    {
 		struct dat_event       		event;
 		/*
@@ -1195,7 +1195,7 @@ test_failure:
 					   &event);
 		} while (ret == DAT_SUCCESS);
 		/* Destroy the EP */
-		ret = dat_ep_free (ep_handle);
+		ret = dat_ep_free (ep);
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_ep_free #%d error: %s\n",
@@ -1259,9 +1259,9 @@ test_failure:
     }
 
     /* clean up the PZ */
-    if (test_ptr->pz_handle)
+    if (test_ptr->pz)
     {
-	ret = dat_pz_free (test_ptr->pz_handle);
+	ret = dat_pz_free (test_ptr->pz);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_pz_free error: %s\n",
@@ -1357,7 +1357,7 @@ DT_Transaction_Run (DT_Tdep_Print_Head *
 	for (i = 0;  i < test_ptr->cmd->eps_per_thread;  i++)
 	{
 	    if (!DT_post_send_buffer (phead,
-				      test_ptr->ep_context[i].ep_handle,
+				      test_ptr->ep_context[i].ep,
 				     test_ptr->ep_context[i].bp,
 				     SYNC_SEND_BUFFER_ID,
 				     SYNC_BUFF_SIZE))
@@ -1432,7 +1432,7 @@ DT_Transaction_Run (DT_Tdep_Print_Head *
 	for (i = 0;  i < test_ptr->cmd->eps_per_thread;  i++)
 	{
 	    if (!DT_post_send_buffer (phead,
-				     test_ptr->ep_context[i].ep_handle,
+				     test_ptr->ep_context[i].ep,
 				     test_ptr->ep_context[i].bp,
 				     SYNC_SEND_BUFFER_ID,
 				     SYNC_BUFF_SIZE))
@@ -1923,8 +1923,8 @@ DT_Print_Transaction_Test (DT_Tdep_Print
 		    test_ptr->remote_is_little_endian);
     DT_Tdep_PT_Printf (phead, "TransTest.base_port              : " F64x "\n",
 		    test_ptr->base_port);
-    DT_Tdep_PT_Printf (phead, "TransTest.pz_handle              : %p\n",
-		    test_ptr->pz_handle);
+    DT_Tdep_PT_Printf (phead, "TransTest.pz              : %p\n",
+		    test_ptr->pz);
     /* statistics */
     DT_Tdep_PT_Printf (phead, "TransTest.bytes_send             : %d\n",
 		    test_ptr->stats.stat_bytes_send);
Index: linux-kernel/test/dapltest/test/dapl_performance_server.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_performance_server.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_performance_server.c	(working copy)
@@ -41,7 +41,7 @@ DT_Performance_Test_Server (
     DT_Tdep_PT_Debug (1,(phead,"Server: Starting performance test\n"));
 
     if ( !DT_Performance_Test_Create (pt_ptr,
-				     pt_ptr->ps_ptr->ia_handle,
+				     pt_ptr->ps_ptr->ia,
 				     (struct sockaddr *) 0,
 				     TRUE,
 				     pt_ptr->Client_Info.is_little_endian,
@@ -97,15 +97,15 @@ DT_Performance_Test_Server_Connect (
 {
     u32 			ret;
     boolean_t 		status;
-    DAT_RSP_HANDLE              rsp_handle;
-    DAT_PSP_HANDLE              psp_handle;
+    struct dat_sp *             rsp;
+    struct dat_sp *             psp;
 
     struct dat_cr_arrival_event_data   cr_stat;
-    DAT_CR_HANDLE               cr_handle;
+    struct dat_cr *              cr;
     enum dat_event_number            event_num;
 
-    rsp_handle = DAT_HANDLE_NULL;
-    psp_handle = DAT_HANDLE_NULL;
+    rsp = NULL;
+    psp = NULL;
 #if 0 /* FIXME */
     if (test_ptr->cmd->use_rsp)
     {
@@ -113,11 +113,11 @@ DT_Performance_Test_Server_Connect (
 	 * Server - create a single-use RSP and
 	 *	    await a connection for this EP
 	 */
-	ret = dat_rsp_create (test_ptr->ia_handle,
+	ret = dat_rsp_create (test_ptr->ia,
 			     test_ptr->ep_context.port,
-			     test_ptr->ep_context.ep_handle,
+			     test_ptr->ep_context.ep,
 			     test_ptr->creq_evd_hdl,
-			     &rsp_handle);
+			     &rsp);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_rsp_create error: %s\n",
@@ -132,9 +132,9 @@ DT_Performance_Test_Server_Connect (
 	/* wait for the connection request */
 	if (!DT_cr_event_wait (test_ptr->conn_evd_hdl, &cr_stat) ||
 	    !DT_cr_check ( &cr_stat,
-			  DAT_HANDLE_NULL,
+			  NULL,
 			  test_ptr->ep_context.port,
-			  &cr_handle,
+			  &cr,
 			  "Server") )
 	{
 	    status = FALSE;
@@ -142,20 +142,20 @@ DT_Performance_Test_Server_Connect (
 	}
 
 	/* what, me query?  just try to accept the connection */
-	ret = dat_cr_accept (cr_handle,
-			    test_ptr->ep_context.ep_handle,
+	ret = dat_cr_accept (cr,
+			    test_ptr->ep_context.ep,
 			    0, (void *)0 /* no private data */ );
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_cr_accept error: %s\n",
 			   test_ptr->base_port, DT_RetToString (ret));
-	    /* cr_handle consumed on failure */
+	    /* cr consumed on failure */
 	    status = FALSE;
 	    goto psp_free;
 	}
 
 	/* wait for DAT_CONNECTION_EVENT_ESTABLISHED */
-	if (!DT_conn_event_wait (  test_ptr->ep_context.ep_handle,
+	if (!DT_conn_event_wait (  test_ptr->ep_context.ep,
 				  test_ptr->conn_evd_hdl,
 				  &event_num))
 	{
@@ -173,17 +173,17 @@ DT_Performance_Test_Server_Connect (
 	 */
 	status = TRUE;
 
-	ret = dat_psp_create (test_ptr->ia_handle,
+	ret = dat_psp_create (test_ptr->ia,
 			      test_ptr->ep_context.port,
 			      test_ptr->creq_evd_hdl,
 			      DAT_PSP_CONSUMER_FLAG,
-			      &psp_handle);
+			      &psp);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_psp_create error: %s\n",
 			   test_ptr->base_port, DT_RetToString (ret));
 	    status = FALSE;
-	    psp_handle = DAT_HANDLE_NULL;
+	    psp = NULL;
 	    return (status);
 	}
 
@@ -204,9 +204,9 @@ DT_Performance_Test_Server_Connect (
     if (!DT_cr_event_wait (phead, test_ptr->creq_evd_hdl, &cr_stat) ||
 	!DT_cr_check ( phead,
 	    		&cr_stat,
-		       psp_handle,
+		       psp,
 		       test_ptr->ep_context.port,
-		       &cr_handle,
+		       &cr,
 		       "Server") )
     {
 	status = FALSE;
@@ -214,22 +214,22 @@ DT_Performance_Test_Server_Connect (
     }
 
     /* what, me query?  just try to accept the connection */
-    ret = dat_cr_accept (cr_handle,
-			 test_ptr->ep_context.ep_handle,
+    ret = dat_cr_accept (cr,
+			 test_ptr->ep_context.ep,
 			 0,
 			 (void *)0 /* no private data */ );
     if (ret != DAT_SUCCESS)
     {
 	DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_cr_accept error: %s\n",
 			test_ptr->base_port, DT_RetToString (ret));
-	/* cr_handle consumed on failure */
+	/* cr consumed on failure */
 	status = FALSE;
 	goto psp_free;
     }
 
     /* wait for DAT_CONNECTION_EVENT_ESTABLISHED */
     if (!DT_conn_event_wait (phead, 
-			     test_ptr->ep_context.ep_handle,
+			     test_ptr->ep_context.ep,
 			     test_ptr->conn_evd_hdl,
 			     &event_num ) )
     {
@@ -241,10 +241,10 @@ DT_Performance_Test_Server_Connect (
     DT_Tdep_PT_Debug (1, (phead,"Server[" F64x "]: Accept on port 0x" F64x "\n",
 		    test_ptr->base_port, test_ptr->ep_context.port));
 psp_free:
-    if ( DAT_HANDLE_NULL != psp_handle )
+    if ( NULL != psp )
     {
 	/* throw away single-use PSP */
-	ret = dat_psp_free (psp_handle);
+	ret = dat_psp_free (psp);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_psp_free error: %s\n",
@@ -252,10 +252,10 @@ psp_free:
 	    status = FALSE;
 	}
     }
-    if ( DAT_HANDLE_NULL != rsp_handle )
+    if ( NULL != rsp )
     {
 	/* throw away single-use PSP */
-	ret = dat_rsp_free (rsp_handle);
+	ret = dat_rsp_free (rsp);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, "Test[" F64x "]: dat_rsp_free error: %s\n",
@@ -282,9 +282,9 @@ DT_Performance_Test_Server_Exchange (
     test_ptr->ep_context.op.bp =
 	DT_BpoolAlloc (test_ptr->pt_ptr,
 		      phead,
-		      test_ptr->ia_handle,
-		      test_ptr->pz_handle,
-		      test_ptr->ep_context.ep_handle,
+		      test_ptr->ia,
+		      test_ptr->pz,
+		      test_ptr->ep_context.ep,
 		      test_ptr->reqt_evd_hdl,
 		      test_ptr->ep_context.op.seg_size,
 		      test_ptr->ep_context.op.num_segs,
@@ -340,7 +340,7 @@ DT_Performance_Test_Server_Exchange (
 
     /* post the send buffer */
     if (!DT_post_send_buffer (phead,
-			     test_ptr->ep_context.ep_handle,
+			     test_ptr->ep_context.ep,
 			     test_ptr->ep_context.bp,
 			     DT_PERF_SYNC_SEND_BUFFER_ID,
 			     DT_PERF_SYNC_BUFF_SIZE))
@@ -358,7 +358,7 @@ DT_Performance_Test_Server_Exchange (
     if ( !DT_dto_event_wait (phead, test_ptr->reqt_evd_hdl, &dto_stat) ||
 	 !DT_dto_check (phead,
 	     		&dto_stat,
-		       test_ptr->ep_context.ep_handle,
+		       test_ptr->ep_context.ep,
 		       DT_PERF_SYNC_BUFF_SIZE,
 		       dto_cookie,
 		       "Send Sync_Msg") )
@@ -380,7 +380,7 @@ DT_Performance_Test_Server_Exchange (
     if ( !DT_dto_event_wait (phead, test_ptr->recv_evd_hdl, &dto_stat) ||
 	 !DT_dto_check ( phead,
 	     		&dto_stat,
-			test_ptr->ep_context.ep_handle,
+			test_ptr->ep_context.ep,
 			DT_PERF_SYNC_BUFF_SIZE,
 			dto_cookie,
 			"Recieve Sync_Msg") )
Index: linux-kernel/test/dapltest/test/dapl_fft_dataxfer_client.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_fft_dataxfer_client.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_fft_dataxfer_client.c	(working copy)
@@ -40,7 +40,7 @@ int DT_dataxfer_client_generic (DT_Tdep_
     u32 rc=0;
 
     DT_fft_init_client (phead, cmd, &conn);
-    DT_assert_dat (phead, conn.ia_handle != NULL)
+    DT_assert_dat (phead, conn.ia != NULL)
 
     DT_assert (phead, DT_fft_connect (phead, &conn));
 
@@ -58,8 +58,8 @@ int DT_dataxfer_client_generic (DT_Tdep_
     {
 	conn.bpool = DT_BpoolAlloc (0, 
 				    phead, 
-				    conn.ia_handle, 
-				    conn.pz_handle, 
+				    conn.ia, 
+				    conn.pz, 
 				    NULL,
 				    NULL, 
 				    4096, 
@@ -68,7 +68,7 @@ int DT_dataxfer_client_generic (DT_Tdep_
 				    FALSE, 
 				    FALSE);
 	DT_assert (phead, conn.bpool != 0);
-	rc = DT_post_send_buffer (phead, conn.ep_handle, conn.bpool, 0,
+	rc = DT_post_send_buffer (phead, conn.ep, conn.bpool, 0,
 		    DT_Bpool_GetBuffSize (conn.bpool, 0));
 	DT_assert_dat (phead, rc == DAT_SUCCESS);
 	rc = dat_evd_wait (conn.send_evd, 10*1000000, 1, &conn.event,
@@ -80,11 +80,11 @@ int DT_dataxfer_client_generic (DT_Tdep_
     /* cleanup */
 cleanup:
 
-    if (conn.ep_handle)
+    if (conn.ep)
     {
 	/* disconnect */
 	DT_Tdep_PT_Printf (phead, "Disconnect\n");
-	rc = dat_ep_disconnect (conn.ep_handle, DAT_CLOSE_ABRUPT_FLAG);
+	rc = dat_ep_disconnect (conn.ep, DAT_CLOSE_ABRUPT_FLAG);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
     rc = DT_fft_destroy_conn_struct (phead, &conn);
Index: linux-kernel/test/dapltest/test/dapl_fft_connmgt.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_fft_connmgt.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_fft_connmgt.c	(working copy)
@@ -39,7 +39,7 @@ int DT_connmgt_case0 (Params_t *params_p
 	Description: Ensure time in dat_evd_wait works correctly\n");
 
     DT_fft_init_server (params_ptr, cmd, &conn);
-    DT_assert (phead, NULL != conn.ia_handle);
+    DT_assert (phead, NULL != conn.ia);
     rc = DT_Tdep_evd_wait (conn.cr_evd, 10000, &conn.event);
     DT_assert_dat (phead, DAT_GET_TYPE (rc) == DAT_TIMEOUT_EXPIRED);
 
@@ -62,7 +62,7 @@ int DT_connmgt_case1 (Params_t *params_p
 	Description: Attempt to use timeout of 0 in dat_evd_wait\n");
 
     DT_fft_init_server (params_ptr, cmd, &conn);
-    DT_assert (phead, NULL != conn.ia_handle);
+    DT_assert (phead, NULL != conn.ia);
 
     rc = DT_Tdep_evd_wait (conn.cr_evd, 0, &conn.event);
     DT_assert_dat (phead, DAT_GET_TYPE (rc) == DAT_TIMEOUT_EXPIRED);
Index: linux-kernel/test/dapltest/test/dapl_bpool.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_bpool.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_bpool.c	(working copy)
@@ -86,10 +86,10 @@ Bpool          *
 DT_BpoolAlloc (
 	   Per_Test_Data_t    *pt_ptr,
 	   DT_Tdep_Print_Head *phead,
-	   DAT_IA_HANDLE      ia_handle,
-	   DAT_PZ_HANDLE      pz_handle,
-	   DAT_EP_HANDLE      ep_handle,
-	   DAT_EVD_HANDLE     rmr_evd_handle,
+	   struct dat_ia *     ia,
+	   struct dat_pz *     pz,
+	   struct dat_ep *     ep,
+	   struct dat_evd *    rmr_evd,
 	   int          seg_size,
 	   int          num_segs,
 	   int          alignment,
@@ -131,16 +131,16 @@ DT_BpoolAlloc (
 
     bpool_ptr->alloc_ptr    = alloc_ptr;
     bpool_ptr->alloc_size   = alloc_size;
-    bpool_ptr->pz_handle    = pz_handle;
+    bpool_ptr->pz    = pz;
     bpool_ptr->num_segs     = num_segs;
-    bpool_ptr->ep_handle    = ep_handle;
+    bpool_ptr->ep    = ep;
     bpool_ptr->buffer_size  = seg_size * num_segs;
     bpool_ptr->buffer_start = DT_AlignPtr (alloc_ptr, alignment) + GG_ALLOC_OFFSET;
     bpool_ptr->tripl_start  = (struct dat_lmr_triplet *) (bpool_ptr + 1);
     bpool_ptr->seg_size     = seg_size;
     bpool_ptr->enable_rdma_write = enable_rdma_write;
     bpool_ptr->enable_rdma_read  = enable_rdma_read;
-    bpool_ptr->rmr_evd_handle    = rmr_evd_handle;
+    bpool_ptr->rmr_evd    = rmr_evd;
     DT_Tdep_PT_Debug (3,
 		  (phead, 
 		  "lmr_create    [%p, " F64x "]\n",
@@ -160,14 +160,14 @@ DT_BpoolAlloc (
         region.for_pa = virt_to_phys(region.for_va);
     }
     
-    ret = dat_lmr_kcreate (ia_handle,
+    ret = dat_lmr_kcreate (ia,
                            DT_mem_type,
                            region,
                            bp_len,
-                           pz_handle,
+                           pz,
                            DAT_MEM_PRIV_ALL_FLAG,
 			   DAT_MEM_OPTIMIZE_DONT_CARE,
-                           &bpool_ptr->lmr_handle,
+                           &bpool_ptr->lmr,
                            &bpool_ptr->lmr_context,
                            &bpool_ptr->rmr_context,
                            &bpool_ptr->reg_size,
@@ -213,7 +213,7 @@ DT_BpoolAlloc (
     	struct dat_rmr_bind_completion_event_data rmr_stat;
     
     	/* create the RMR */
-    	ret = dat_rmr_create (pz_handle, &bpool_ptr->rmr_handle);
+    	ret = dat_rmr_create (pz, &bpool_ptr->rmr_handle);
     	if (ret != DAT_SUCCESS)
     	{
     	    DT_Tdep_PT_Printf (phead, "%s: dat_rmr_create failed %s\n",
@@ -238,7 +238,7 @@ DT_BpoolAlloc (
     	ret = dat_rmr_bind ( bpool_ptr->rmr_handle,
     			    &iov,
     			    mflags,
-    			    bpool_ptr->ep_handle,
+    			    bpool_ptr->ep,
     			    cookie,
     			    DAT_COMPLETION_DEFAULT_FLAG,
     			    &bpool_ptr->rmr_context);
@@ -253,7 +253,7 @@ DT_BpoolAlloc (
     
     	/* await the bind result */
     	if (!DT_rmr_event_wait (phead, 
-    		    		bpool_ptr->rmr_evd_handle, 
+    		    		bpool_ptr->rmr_evd, 
     				&rmr_stat) ||
     	    !DT_rmr_check (phead, 
     			   &rmr_stat,
@@ -290,9 +290,9 @@ err:
 				 DT_RetToString (ret));
 	    }
 	}
-	if (bpool_ptr->lmr_handle)
+	if (bpool_ptr->lmr)
 	{
-	    ret = dat_lmr_free (bpool_ptr->lmr_handle);
+	    ret = dat_lmr_free (bpool_ptr->lmr);
 	    if (ret != DAT_SUCCESS)
 	    {
 		DT_Tdep_PT_Printf (phead,
@@ -357,9 +357,9 @@ DT_Bpool_Destroy (Per_Test_Data_t * pt_p
 		}
 	    }
 
-	    if (bpool_ptr->lmr_handle)
+	    if (bpool_ptr->lmr)
 	    {
-		u32 ret = dat_lmr_free (bpool_ptr->lmr_handle);
+		u32 ret = dat_lmr_free (bpool_ptr->lmr);
 		if (ret != DAT_SUCCESS)
 		{
 		    DT_Tdep_PT_Printf (phead,
@@ -433,8 +433,8 @@ DT_Bpool_print (DT_Tdep_Print_Head *phea
 	    	     "BPOOL alloc_size     %x\n",
 		     (int) bpool_ptr->alloc_size);
     DT_Tdep_PT_Printf (phead, 
-	    	     "BPOOL pz_handle      %p\n",
-		      bpool_ptr->pz_handle);
+	    	     "BPOOL pz      %p\n",
+		      bpool_ptr->pz);
     DT_Tdep_PT_Printf (phead, 
 	    	     "BPOOL num_segs       %x\n",
 		     (int) bpool_ptr->num_segs);
Index: linux-kernel/test/dapltest/test/dapl_test_util.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_test_util.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_test_util.c	(working copy)
@@ -32,11 +32,11 @@
  */
 boolean_t
 DT_query (   Per_Test_Data_t *pt_ptr,
-	    DAT_IA_HANDLE   ia_handle,
-	    DAT_EP_HANDLE   ep_handle)
+	    struct dat_ia *  ia,
+	    struct dat_ep *  ep)
 {
     unsigned char   *module = "DT_query";
-    DAT_EVD_HANDLE  async_evd_hdl;  /* not used */
+    struct dat_evd * async_evd_hdl;  /* not used */
     struct dat_ep_param ep_params;
     u32      ret;
     DT_Tdep_Print_Head *phead;
@@ -44,7 +44,7 @@ DT_query (   Per_Test_Data_t *pt_ptr,
     phead = pt_ptr->Params.phead;
 
     /* Query the IA */
-    ret = dat_ia_query (ia_handle,
+    ret = dat_ia_query (ia,
                         &async_evd_hdl,
                         &pt_ptr->ia_attr,
                         &pt_ptr->provider_attr);
@@ -57,7 +57,7 @@ DT_query (   Per_Test_Data_t *pt_ptr,
     }
 
     /* Query the EP */
-    ret = dat_ep_query (ep_handle, &ep_params);
+    ret = dat_ep_query (ep, &ep_params);
     if (ret != DAT_SUCCESS)
     {
 	DT_Tdep_PT_Printf (phead, "%s: dat_ep_query error: %s\n",
@@ -160,7 +160,7 @@ DT_query (   Per_Test_Data_t *pt_ptr,
  */
 boolean_t
 DT_post_recv_buffer (DT_Tdep_Print_Head *phead,
-		     DAT_EP_HANDLE ep_handle,
+		     struct dat_ep *ep,
 		     Bpool * bp,
 		     int index,
 		     int size)
@@ -184,7 +184,7 @@ DT_post_recv_buffer (DT_Tdep_Print_Head 
     DT_Tdep_PT_Debug (3, (phead, "Post-Recv #%d [%p, %x]\n", index, buff, size));
 
     /* Post the recv buffer */
-    ret = dat_ep_post_recv (ep_handle,
+    ret = dat_ep_post_recv (ep,
 			    1,
 			    iov,
 			    cookie,
@@ -205,7 +205,7 @@ DT_post_recv_buffer (DT_Tdep_Print_Head 
  */
 boolean_t
 DT_post_send_buffer (DT_Tdep_Print_Head *phead, 
-		     DAT_EP_HANDLE ep_handle,
+		     struct dat_ep *ep,
 		     Bpool * bp,
 		     int index,
 		     int size)
@@ -228,7 +228,7 @@ DT_post_send_buffer (DT_Tdep_Print_Head 
 
     DT_Tdep_PT_Debug (3, (phead, "Post-Send #%d [%p, %x]\n", index, buff, size));
     /* Post the recv buffer */
-    ret = dat_ep_post_send (ep_handle,
+    ret = dat_ep_post_send (ep,
 			    1,
 			    iov,
 			    cookie,
@@ -249,7 +249,7 @@ DT_post_send_buffer (DT_Tdep_Print_Head 
  */
 boolean_t
 DT_cr_event_wait ( DT_Tdep_Print_Head *phead,
-		   DAT_EVD_HANDLE evd_handle,
+		   struct dat_evd *evd,
 		   struct dat_cr_arrival_event_data *cr_stat_p)
 {
     int err_cnt;
@@ -261,7 +261,7 @@ DT_cr_event_wait ( DT_Tdep_Print_Head *p
 	u32      ret;
 	struct dat_event       event;
 
-	ret = DT_Tdep_evd_wait (evd_handle, DAT_TIMEOUT_MAX, &event);
+	ret = DT_Tdep_evd_wait (evd, DAT_TIMEOUT_MAX, &event);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, "Test Error: dapl_event_wait (CR) failed: %s\n",
@@ -306,8 +306,8 @@ DT_cr_event_wait ( DT_Tdep_Print_Head *p
  */
 boolean_t
 DT_conn_event_wait (DT_Tdep_Print_Head *phead,
-		    DAT_EP_HANDLE  ep_handle,
-		    DAT_EVD_HANDLE evd_handle,
+		    struct dat_ep * ep,
+		    struct dat_evd *evd,
 		    enum dat_event_number *event_number)
 
 {
@@ -316,7 +316,7 @@ DT_conn_event_wait (DT_Tdep_Print_Head *
 	u32      ret;
 	struct dat_event       event;
 
-	ret = DT_Tdep_evd_wait (evd_handle, DAT_TIMEOUT_MAX, &event);
+	ret = DT_Tdep_evd_wait (evd, DAT_TIMEOUT_MAX, &event);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, "Test Error: dapl_event_wait (CONN) failed: %s\n",
@@ -341,7 +341,7 @@ DT_conn_event_wait (DT_Tdep_Print_Head *
 	{
 	    /*
 	     * Could return struct dat_connection_event_data and verify:
-	     *      event.event_data.connect_event_data.ep_handle
+	     *      event.event_data.connect_event_data.ep
 	     *      event.event_data.connect_event_data.private_data_size
 	     *      event.event_data.connect_event_data.private_data
 	     */
@@ -361,15 +361,15 @@ DT_conn_event_wait (DT_Tdep_Print_Head *
  */
 boolean_t
 DT_disco_event_wait ( DT_Tdep_Print_Head *phead,
-		      DAT_EVD_HANDLE evd_handle,
-		      DAT_EP_HANDLE  *ep_handle )
+		      struct dat_evd *evd,
+		      struct dat_ep * *ep )
 {
     for (;;)
     {
 	u32      ret;
 	struct dat_event       event;
 
-	ret = DT_Tdep_evd_wait (evd_handle, DAT_TIMEOUT_MAX, &event);
+	ret = DT_Tdep_evd_wait (evd, DAT_TIMEOUT_MAX, &event);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, "Test Error: dapl_event_wait (DISCONN) failed: %s\n",
@@ -392,9 +392,9 @@ DT_disco_event_wait ( DT_Tdep_Print_Head
 
 	if (event.event_number == DAT_CONNECTION_EVENT_DISCONNECTED)
 	{
-	    if ( ep_handle != NULL )
+	    if ( ep != NULL )
 	    {
-		*ep_handle = event.event_data.connect_event_data.ep_handle;
+		*ep = event.event_data.connect_event_data.ep;
 	    }
 	    return (TRUE);
 	}
@@ -412,17 +412,17 @@ DT_disco_event_wait ( DT_Tdep_Print_Head
  */
 boolean_t
 DT_dto_event_reap (DT_Tdep_Print_Head *phead,
-		  DAT_EVD_HANDLE evd_handle,
+		  struct dat_evd *evd,
 		  boolean_t poll,
 		  struct dat_dto_completion_event_data *dto_statusp)
 {
     if (poll)
     {
-	return DT_dto_event_poll (phead, evd_handle, dto_statusp);
+	return DT_dto_event_poll (phead, evd, dto_statusp);
     }
     else
     {
-	return DT_dto_event_wait (phead, evd_handle, dto_statusp);
+	return DT_dto_event_wait (phead, evd, dto_statusp);
     }
 }
 
@@ -432,7 +432,7 @@ DT_dto_event_reap (DT_Tdep_Print_Head *p
  */
 boolean_t
 DT_dto_event_poll (DT_Tdep_Print_Head *phead,
-		  DAT_EVD_HANDLE evd_handle,
+		  struct dat_evd *evd,
 		  struct dat_dto_completion_event_data *dto_statusp)
 {
     for (;;)
@@ -440,7 +440,7 @@ DT_dto_event_poll (DT_Tdep_Print_Head *p
 	u32      ret;
 	struct dat_event       event;
 
-	ret = DT_Tdep_evd_dequeue ( evd_handle,
+	ret = DT_Tdep_evd_dequeue ( evd,
 			       &event);
 
 	if (DAT_GET_TYPE (ret) == DAT_QUEUE_EMPTY)
@@ -460,7 +460,7 @@ DT_dto_event_poll (DT_Tdep_Print_Head *p
 	{
 	    /*
 	     * Pass back all the useful bits if requested:
-	     *      ep_handle,  user_cookie.as_ptr
+	     *      ep,  user_cookie.as_ptr
 	     *      status,     transfered_length
 	     */
 	    if (dto_statusp)
@@ -484,7 +484,7 @@ DT_dto_event_poll (DT_Tdep_Print_Head *p
  */
 boolean_t
 DT_dto_event_wait (DT_Tdep_Print_Head *phead,
-		    DAT_EVD_HANDLE evd_handle,
+		    struct dat_evd *evd,
 		    struct dat_dto_completion_event_data *dto_statusp)
 {
     for (;;)
@@ -492,7 +492,7 @@ DT_dto_event_wait (DT_Tdep_Print_Head *p
 	u32      ret;
 	struct dat_event       event;
 
-	ret = DT_Tdep_evd_wait (evd_handle, DAT_TIMEOUT_MAX, &event);
+	ret = DT_Tdep_evd_wait (evd, DAT_TIMEOUT_MAX, &event);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, "Test Error: dapl_event_wait (DTO) failed: %s\n",
@@ -505,7 +505,7 @@ DT_dto_event_wait (DT_Tdep_Print_Head *p
 	{
 	    /*
 	     * Pass back all the useful bits if requested:
-	     *      ep_handle,  user_cookie.as_ptr
+	     *      ep,  user_cookie.as_ptr
 	     *      status,     transfered_length
 	     */
 	    if (dto_statusp)
@@ -528,7 +528,7 @@ DT_dto_event_wait (DT_Tdep_Print_Head *p
  */
 boolean_t
 DT_rmr_event_wait (DT_Tdep_Print_Head *phead,
-		    DAT_EVD_HANDLE evd_handle,
+		    struct dat_evd *evd,
 		    struct dat_rmr_bind_completion_event_data *rmr_statusp)
 {
     for (;;)
@@ -536,7 +536,7 @@ DT_rmr_event_wait (DT_Tdep_Print_Head *p
 	u32      ret;
 	struct dat_event       event;
 
-	ret = DT_Tdep_evd_wait (evd_handle, DAT_TIMEOUT_MAX, &event);
+	ret = DT_Tdep_evd_wait (evd, DAT_TIMEOUT_MAX, &event);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, "Test Error: dapl_event_wait (RMR) failed: %s\n",
@@ -572,12 +572,12 @@ DT_rmr_event_wait (DT_Tdep_Print_Head *p
 boolean_t
 DT_dto_check ( DT_Tdep_Print_Head *phead,
 	       struct dat_dto_completion_event_data *dto_p,
-	       DAT_EP_HANDLE   ep_expected,
+	       struct dat_ep *  ep_expected,
 	       int       len_expected,
 	       DAT_DTO_COOKIE  cookie_expected,
 	       char           *message )
 {
-    if ( ( (ep_expected != NULL) && (dto_p->ep_handle != ep_expected) )
+    if ( ( (ep_expected != NULL) && (dto_p->ep != ep_expected) )
 	 || dto_p->transfered_length != len_expected
 	 || dto_p->user_cookie.as_64 != cookie_expected.as_64
 	 || dto_p->status != DAT_DTO_SUCCESS )
@@ -588,10 +588,10 @@ DT_dto_check ( DT_Tdep_Print_Head *phead
 		       : (dto_p->status == DAT_DTO_ERR_FLUSHED ? "FAILURE"
 			  : "LengthError")));
 	DT_Test_Error ();
-	if ( (ep_expected != NULL) && (dto_p->ep_handle != ep_expected) )
+	if ( (ep_expected != NULL) && (dto_p->ep != ep_expected) )
 	{
 	    DT_Tdep_PT_Printf (phead, "\tEndPoint mismatch (got %p wanted %p)\n",
-			    dto_p->ep_handle,
+			    dto_p->ep,
 			    ep_expected);
 	}
 	if (dto_p->transfered_length != len_expected)
@@ -620,11 +620,11 @@ DT_dto_check ( DT_Tdep_Print_Head *phead
 boolean_t
 DT_rmr_check ( DT_Tdep_Print_Head *phead,
 		struct dat_rmr_bind_completion_event_data *rmr_p,
-		DAT_RMR_HANDLE  rmr_expected,
+		struct dat_rmr *  rmr_expected,
 		void *      cookie_expected,
 		char            *message)
 {
-    if ( rmr_p->rmr_handle != rmr_expected
+    if ( rmr_p->rmr != rmr_expected
 	 || rmr_p->user_cookie.as_ptr != cookie_expected
 	 || rmr_p->status != DAT_RMR_BIND_SUCCESS )
     {
@@ -634,10 +634,10 @@ DT_rmr_check ( DT_Tdep_Print_Head *phead
 		      (rmr_p->status == DAT_RMR_BIND_SUCCESS
 		       ? "OK" : "FAILURE"));
 	DT_Test_Error ();
-	if (rmr_p->rmr_handle != rmr_expected)
+	if (rmr_p->rmr != rmr_expected)
 	{
 	    DT_Tdep_PT_Printf (phead, "\tRMR handle mismatch (got 0x%p wanted 0x%p)\n",
-			    rmr_p->rmr_handle,
+			    rmr_p->rmr,
 			    rmr_expected);
 	}
 	if (rmr_p->user_cookie.as_ptr != cookie_expected)
@@ -659,21 +659,21 @@ DT_rmr_check ( DT_Tdep_Print_Head *phead
 boolean_t
 DT_cr_check (  DT_Tdep_Print_Head *phead,
 		struct dat_cr_arrival_event_data *cr_stat_p,
-		DAT_PSP_HANDLE  psp_handle_expected,
+		struct dat_sp * psp_expected,
 		DAT_CONN_QUAL   port_expected,
-		DAT_CR_HANDLE   *cr_handlep,
+		struct dat_cr *  *crp,
 		char            *message)
 {
     u32 ret;
 
-    if (cr_handlep)
+    if (crp)
     {
-	*cr_handlep = (DAT_CR_HANDLE) 0;
+	*crp = (struct dat_cr *) 0;
     }
 
     if (cr_stat_p->conn_qual != port_expected ||
-	(psp_handle_expected &&
-	    cr_stat_p->sp_handle.psp_handle != psp_handle_expected))
+	(psp_expected &&
+	    cr_stat_p->sp != psp_expected))
     {
 
 	DT_Tdep_PT_Printf (phead, "Test Error: %s CR data problem\n", message);
@@ -684,20 +684,20 @@ DT_cr_check (  DT_Tdep_Print_Head *phead
 			   " (got 0x" F64x " wanted 0x" F64x ")\n",
 			    cr_stat_p->conn_qual, port_expected);
 	}
-	if (psp_handle_expected &&
-		cr_stat_p->sp_handle.psp_handle != psp_handle_expected)
+	if (psp_expected &&
+		cr_stat_p->sp != psp_expected)
 	{
 	    DT_Tdep_PT_Printf (phead, "\tPSP mismatch (got 0x%p wanted 0x%p)\n",
-			    cr_stat_p->sp_handle.psp_handle,
-			    psp_handle_expected);
+			    cr_stat_p->sp,
+			    psp_expected);
 	}
-	if (!cr_stat_p->cr_handle)
+	if (!cr_stat_p->cr)
 	{
-	    DT_Tdep_PT_Printf (phead, "\tGot NULL cr_handle\n");
+	    DT_Tdep_PT_Printf (phead, "\tGot NULL cr\n");
 	}
 	else
 	{
-	    ret = dat_cr_reject (cr_stat_p->cr_handle);
+	    ret = dat_cr_reject (cr_stat_p->cr);
 	    if (ret != DAT_SUCCESS)
 	    {
 		DT_Tdep_PT_Printf (phead, "\tdat_cr_reject error: %s\n",
@@ -707,9 +707,9 @@ DT_cr_check (  DT_Tdep_Print_Head *phead
 	return ( FALSE );
     }
 
-    if (cr_handlep)
+    if (crp)
     {
-	*cr_handlep = cr_stat_p->cr_handle;
+	*crp = cr_stat_p->cr;
     }
     return ( TRUE );
 }
Index: linux-kernel/test/dapltest/test/dapl_client.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_client.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_client.c	(working copy)
@@ -41,13 +41,13 @@ DT_cs_Client (Params_t * params_ptr,
 	  u32 total_threads)
 {
     Per_Test_Data_t     *pt_ptr             = NULL;
-    DAT_IA_HANDLE       ia_handle           = DAT_HANDLE_NULL;
-    DAT_PZ_HANDLE       pz_handle           = DAT_HANDLE_NULL;
-    DAT_EVD_HANDLE      recv_evd_hdl        = DAT_HANDLE_NULL;
-    DAT_EVD_HANDLE      reqt_evd_hdl        = DAT_HANDLE_NULL;
-    DAT_EVD_HANDLE      conn_evd_hdl        = DAT_HANDLE_NULL;
-    DAT_EVD_HANDLE      async_evd_hdl       = DAT_HANDLE_NULL;
-    DAT_EP_HANDLE       ep_handle           = DAT_HANDLE_NULL;
+    struct dat_ia	*ia           = NULL;
+    struct dat_pz	*pz           = NULL;
+    struct dat_evd	*recv_evd_hdl        = NULL;
+    struct dat_evd	*reqt_evd_hdl        = NULL;
+    struct dat_evd	*conn_evd_hdl        = NULL;
+    struct dat_evd	*async_evd_hdl       = NULL;
+    struct dat_ep	*ep           = NULL;
     Server_Info_t       *sinfo              = NULL;
     Transaction_Cmd_t   *Transaction_Cmd    = NULL;
     Quit_Cmd_t          *Quit_Cmd           = NULL;
@@ -98,7 +98,7 @@ DT_cs_Client (Params_t * params_ptr,
     ret = dat_ia_open (dapl_name,
 		      DFLT_QLEN,
 		      &async_evd_hdl,
-		      &ia_handle);
+		      &ia);
     if (ret != DAT_SUCCESS)
     {
 	DT_Tdep_PT_Printf (phead, 
@@ -106,28 +106,28 @@ DT_cs_Client (Params_t * params_ptr,
 		         module, 
 			 dapl_name, 
 			 DT_RetToString (ret));
-	ia_handle = DAT_HANDLE_NULL;
+	ia = NULL;
     	status = 1;
     	goto client_exit;
     }
     DT_Tdep_PT_Debug (1,(phead, "%s: IA %s opened\n", module, dapl_name));
 
     /* Create a PZ */
-    ret = dat_pz_create (ia_handle, &pz_handle);
+    ret = dat_pz_create (ia, &pz);
     if (ret != DAT_SUCCESS)
     {
 	DT_Tdep_PT_Printf (phead, 
 			 "%s: dat_pz_create error: %s\n",
 		    	 module, 
 			 DT_RetToString (ret));
-	pz_handle = DAT_HANDLE_NULL;
+	pz = NULL;
 	status = 1;
 	goto client_exit;
     }
 
     /* Create 3 events - recv, request, connect */
 
-    ret = DT_Tdep_evd_create (ia_handle,
+    ret = DT_Tdep_evd_create (ia,
 			      DFLT_QLEN,
 			      NULL,
 			      DAT_EVD_DTO_FLAG,
@@ -138,11 +138,11 @@ DT_cs_Client (Params_t * params_ptr,
 			 "%s: dat_evd_create (recv) failed %s\n",
 		         module, 
 			 DT_RetToString (ret));
-	recv_evd_hdl = DAT_HANDLE_NULL;
+	recv_evd_hdl = NULL;
     	status = 1;
 	goto client_exit;
     }
-    ret = DT_Tdep_evd_create (ia_handle,
+    ret = DT_Tdep_evd_create (ia,
 			      DFLT_QLEN,
 			      NULL,
 			      DAT_EVD_DTO_FLAG | DAT_EVD_RMR_BIND_FLAG,
@@ -153,11 +153,11 @@ DT_cs_Client (Params_t * params_ptr,
 			 "%s: dat_evd_create (send) failed %s\n",
 			 module, 
 			 DT_RetToString (ret));
-	reqt_evd_hdl = DAT_HANDLE_NULL;
+	reqt_evd_hdl = NULL;
     	status = 1;
 	goto client_exit;
     }
-    ret = DT_Tdep_evd_create (ia_handle,
+    ret = DT_Tdep_evd_create (ia,
 			      DFLT_QLEN,
 			      NULL,
 			      DAT_EVD_CONNECTION_FLAG,
@@ -168,26 +168,26 @@ DT_cs_Client (Params_t * params_ptr,
 			 "%s: dat_evd_create (conn) failed %s\n",
 		    	 module, 
 			 DT_RetToString (ret));
-	conn_evd_hdl = DAT_HANDLE_NULL;
+	conn_evd_hdl = NULL;
     	status = 1;
 	goto client_exit;
     }
 
     /* Create an EP */
-    ret = dat_ep_create (ia_handle,		 /* IA       */
-			pz_handle,		/* PZ       */
+    ret = dat_ep_create (ia,		 /* IA       */
+			pz,		/* PZ       */
 			recv_evd_hdl,		/* recv     */
 			reqt_evd_hdl,		/* request  */
 			conn_evd_hdl,		/* connect  */
 			(struct dat_ep_attr *) NULL,
-			&ep_handle);
+			&ep);
     if (ret != DAT_SUCCESS)
     {
 	DT_Tdep_PT_Printf (phead, 
 			 "%s: dat_ep_create error: %s\n",
 		    	 module,
 		         DT_RetToString (ret));
-	ep_handle = DAT_HANDLE_NULL;
+	ep = NULL;
     	status = 1;
 	goto client_exit;
     }
@@ -197,7 +197,7 @@ DT_cs_Client (Params_t * params_ptr,
      * Gather whatever info we want about defaults,
      * and check that we can handle the requested parameters.
      */
-    if (!DT_query (pt_ptr, ia_handle, ep_handle) ||
+    if (!DT_query (pt_ptr, ia, ep) ||
 	!DT_check_params (pt_ptr, module))
     {
         status = 1;
@@ -206,10 +206,10 @@ DT_cs_Client (Params_t * params_ptr,
 
     bpool = DT_BpoolAlloc (pt_ptr,
 	    	       phead,
-		       ia_handle,
-		       pz_handle,
-		       ep_handle,
-		       DAT_HANDLE_NULL, /* no RMR */
+		       ia,
+		       pz,
+		       ep,
+		       NULL, /* no RMR */
 		       DT_RoundSize (sizeof (Transaction_Cmd_t), 8192),
 		       3,	/* num_buffers */
 		       pt_ptr->provider_attr.optimal_buffer_alignment,
@@ -238,7 +238,7 @@ DT_cs_Client (Params_t * params_ptr,
     DT_Tdep_PT_Debug (1,(phead, "%s: Posting 1 recv buffer\n", module));
 retry_repost:
     if (!DT_post_recv_buffer (phead,
-			       ep_handle,
+			       ep,
 			       bpool,
 			       0,
 			       DT_Bpool_GetBuffSize (bpool, 0)))
@@ -253,7 +253,7 @@ retry_repost:
     DT_Tdep_PT_Debug (1,(phead, "%s: Connect Endpoint\n", module));
     try_connect =1;
 retry:
-    ret = dat_ep_connect (ep_handle,
+    ret = dat_ep_connect (ep,
 			 server_netaddr,
 			 SERVER_PORT_NUMBER,
 			 DAT_TIMEOUT_MAX,
@@ -271,7 +271,7 @@ retry:
     }
 
     DT_Tdep_PT_Debug (1,(phead, "%s: Await connection ...\n", module));
-    if (!DT_conn_event_wait (phead, ep_handle, conn_evd_hdl, &event_num))
+    if (!DT_conn_event_wait (phead, ep, conn_evd_hdl, &event_num))
     {
 	if ( event_num == DAT_CONNECTION_EVENT_PEER_REJECTED )
 	{
@@ -287,7 +287,7 @@ retry:
 	     * See if any buffers were flushed as a result of
 	     * the REJECT; clean them up and repost if so
 	     */
-	    dat_ep_reset (ep_handle);
+	    dat_ep_reset (ep);
 	    do
 	    {
 
@@ -315,7 +315,7 @@ retry:
     if (DT_dapltest_debug)
     {
 	DT_Tdep_PT_Debug (1,(phead, "%s: Connected!\n", module));
-	get_ep_connection_state (phead, ep_handle);
+	get_ep_connection_state (phead, ep);
     }
 
     /* Send Client_Info (using 2nd buffer in the pool) */
@@ -326,7 +326,7 @@ retry:
 	    sizeof (Client_Info_t));
     DT_Client_Info_Endian ((Client_Info_t *) buffp);
     if (!DT_post_send_buffer ( phead,
-				ep_handle,
+				ep,
 				bpool,
 				1,
 				DT_Bpool_GetBuffSize (bpool, 1)))
@@ -343,7 +343,7 @@ retry:
     if (!DT_dto_event_wait (phead, reqt_evd_hdl, &dto_stat) ||
 	!DT_dto_check ( phead,
 	    		&dto_stat,
-			ep_handle,
+			ep,
 			DT_Bpool_GetBuffSize (bpool, 1),
 			dto_cookie,
 			"Client_Info_Send"))
@@ -396,7 +396,7 @@ retry:
 
     /* Send the Command buffer */
     if (!DT_post_send_buffer ( phead,
-				ep_handle,
+				ep,
 				bpool,
 				2,
 				DT_Bpool_GetBuffSize (bpool, 2)))
@@ -414,7 +414,7 @@ retry:
     if (!DT_dto_event_wait (phead, reqt_evd_hdl, &dto_stat) ||
 	!DT_dto_check ( phead,
 	    		&dto_stat,
-			ep_handle,
+			ep,
 			DT_Bpool_GetBuffSize (bpool, 2),
 			dto_cookie,
 			"Client_Cmd_Send"))
@@ -430,7 +430,7 @@ retry:
     if (!DT_dto_event_wait (phead, recv_evd_hdl, &dto_stat) ||
 	!DT_dto_check ( phead,
 	    		&dto_stat,
-			ep_handle,
+			ep,
 			DT_Bpool_GetBuffSize (bpool, 0),
 			dto_cookie,
 			"Server_Info_Recv"))
@@ -476,7 +476,7 @@ retry:
 		DT_Transaction_Cmd_PT_Print (phead, Transaction_Cmd);
 	    }
 	    status = DT_Transaction_Test_Client (pt_ptr,
-				    ia_handle,
+				    ia,
 				    server_netaddr);
             params_ptr->Client_Stats_T.bytes_rdma_read = 
 			pt_ptr->Client_Stats.bytes_rdma_read;
@@ -508,7 +508,7 @@ retry:
 			
 	    status = DT_Performance_Test_Client (params_ptr,
 						 pt_ptr,
-						 ia_handle,
+						 (struct dat_ia *)ia,
 						 server_netaddr);
 	    break;
 	}
@@ -521,13 +521,13 @@ client_exit:
     DT_Tdep_PT_Debug (1,(phead, "%s: Cleaning Up ...\n", module));
 
     /* Disconnect the EP */
-    if (ep_handle && try_connect)
+    if (ep && try_connect)
     {
 	/*
 	 * graceful attempt might fail because we got here due to
 	 * some error above, so we may as well try harder.
 	 */
-	ret = dat_ep_disconnect (ep_handle, DAT_CLOSE_ABRUPT_FLAG);
+	ret = dat_ep_disconnect (ep, DAT_CLOSE_ABRUPT_FLAG);
 	if (ret != DAT_SUCCESS)
 	{
 		DT_Tdep_PT_Printf (phead, 
@@ -547,7 +547,7 @@ client_exit:
     DT_Bpool_Destroy (pt_ptr, phead, bpool);
 
     /* Free the EP */
-    if (ep_handle)
+    if (ep)
     {
 	struct dat_event       		event;
 	/*
@@ -560,7 +560,7 @@ client_exit:
 				   &event);
 	} while (ret == DAT_SUCCESS);
 
-	ret = dat_ep_free (ep_handle);
+	ret = dat_ep_free (ep);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, 
@@ -614,9 +614,9 @@ client_exit:
     }
 
     /* Free the PZ */
-    if (pz_handle)
+    if (pz)
     {
-	ret = dat_pz_free (pz_handle);
+	ret = dat_pz_free (pz);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, 
@@ -629,10 +629,10 @@ client_exit:
     }
 
     /* Close the IA */
-    if (ia_handle)
+    if (ia)
     {
 	/* dat_ia_close cleans up async evd handle, too */
-	ret = dat_ia_close (ia_handle, DAT_CLOSE_GRACEFUL_FLAG);
+	ret = dat_ia_close (ia, DAT_CLOSE_GRACEFUL_FLAG);
 	if (ret != DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, 
@@ -640,7 +640,7 @@ client_exit:
 			     module, 
 			     DT_RetToString (ret));
             status = 1;
-	    ret = dat_ia_close (ia_handle, DAT_CLOSE_ABRUPT_FLAG);
+	    ret = dat_ia_close (ia, DAT_CLOSE_ABRUPT_FLAG);
 	    if (ret != DAT_SUCCESS)
 	    {
 		DT_Tdep_PT_Printf (phead, 
Index: linux-kernel/test/dapltest/test/dapl_fft_endpoint.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_fft_endpoint.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_fft_endpoint.c	(working copy)
@@ -36,59 +36,59 @@ int DT_endpoint_generic (Params_t *param
 			 boolean_t destroy_pz_early)
 {
     char *dev_name;
-    DAT_IA_HANDLE ia_handle;
-    DAT_PZ_HANDLE pz_handle;
-    DAT_EP_HANDLE ep_handle;
-    DAT_EVD_HANDLE evd_handle;
-    DAT_EVD_HANDLE conn_evd_handle;
-    DAT_EVD_HANDLE send_evd_handle;
-    DAT_EVD_HANDLE recv_evd_handle;
+    struct dat_ia *ia;
+    struct dat_pz *pz;
+    struct dat_ep *ep;
+    struct dat_evd *evd;
+    struct dat_evd *conn_evd;
+    struct dat_evd *send_evd;
+    struct dat_evd *recv_evd;
     u32 rc, wanted;
     int res;
     DT_Tdep_Print_Head *phead;
 
     res = 1;
-    ia_handle = NULL;
-    pz_handle = NULL;
-    ep_handle = NULL;
-    evd_handle = NULL;
-    conn_evd_handle = NULL;
-    send_evd_handle = NULL;
-    recv_evd_handle = NULL;
+    ia = NULL;
+    pz = NULL;
+    ep = NULL;
+    evd = NULL;
+    conn_evd = NULL;
+    send_evd = NULL;
+    recv_evd = NULL;
     dev_name = cmd->device_name;
-    evd_handle = DAT_HANDLE_NULL;
+    evd = NULL;
     phead = params_ptr->phead;
 
-    rc = dat_ia_open (dev_name, DEFAULT_QUEUE_LEN, &evd_handle, &ia_handle);
+    rc = dat_ia_open (dev_name, DEFAULT_QUEUE_LEN, &evd, &ia);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
-    rc = dat_pz_create (ia_handle, &pz_handle);
+    rc = dat_pz_create (ia, &pz);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
     if (destroy_pz_early)
     {
-	if (pz_handle)
+	if (pz)
 	{
-	    rc = dat_pz_free (pz_handle);
+	    rc = dat_pz_free (pz);
 	    DT_assert_dat (phead, rc == DAT_SUCCESS);
 	}
     }
 
-    rc = DT_Tdep_evd_create (ia_handle, DEFAULT_QUEUE_LEN, NULL,
+    rc = DT_Tdep_evd_create (ia, DEFAULT_QUEUE_LEN, NULL,
 			 DAT_EVD_DTO_FLAG | DAT_EVD_RMR_BIND_FLAG,
-			 &send_evd_handle);
+			 &send_evd);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
-    rc = DT_Tdep_evd_create (ia_handle, DEFAULT_QUEUE_LEN, NULL, DAT_EVD_DTO_FLAG,
-	    &recv_evd_handle);
+    rc = DT_Tdep_evd_create (ia, DEFAULT_QUEUE_LEN, NULL, DAT_EVD_DTO_FLAG,
+	    &recv_evd);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
-    rc = DT_Tdep_evd_create (ia_handle, DEFAULT_QUEUE_LEN, NULL,
-	    DAT_EVD_CONNECTION_FLAG, &conn_evd_handle);
+    rc = DT_Tdep_evd_create (ia, DEFAULT_QUEUE_LEN, NULL,
+	    DAT_EVD_CONNECTION_FLAG, &conn_evd);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
-    rc = dat_ep_create (ia_handle, pz_handle, recv_evd_handle, send_evd_handle,
-	    conn_evd_handle, NULL, &ep_handle);
+    rc = dat_ep_create (ia, pz, recv_evd, send_evd,
+	    conn_evd, NULL, &ep);
     if (destroy_pz_early)
     {
 	wanted = DAT_INVALID_HANDLE;
@@ -100,39 +100,39 @@ int DT_endpoint_generic (Params_t *param
     DT_assert_dat (phead, DAT_GET_TYPE (rc) == wanted);
 
 cleanup:
-    if (ep_handle)
+    if (ep)
     {
-	rc = dat_ep_free (ep_handle);
+	rc = dat_ep_free (ep);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
-    if (send_evd_handle)
+    if (send_evd)
     {
-	rc = DT_Tdep_evd_free (send_evd_handle);
+	rc = DT_Tdep_evd_free (send_evd);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
-    if (recv_evd_handle)
+    if (recv_evd)
     {
-	rc = DT_Tdep_evd_free (recv_evd_handle);
+	rc = DT_Tdep_evd_free (recv_evd);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
-    if (conn_evd_handle)
+    if (conn_evd)
     {
-	rc = DT_Tdep_evd_free (conn_evd_handle);
+	rc = DT_Tdep_evd_free (conn_evd);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
-    if (!destroy_pz_early && pz_handle)
+    if (!destroy_pz_early && pz)
     {
-	rc = dat_pz_free (pz_handle);
+	rc = dat_pz_free (pz);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
-    if (ia_handle)
+    if (ia)
     {
-	rc = dat_ia_close (ia_handle, DAT_CLOSE_ABRUPT_FLAG);
+	rc = dat_ia_close (ia, DAT_CLOSE_ABRUPT_FLAG);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
     return res;
@@ -163,10 +163,10 @@ int DT_endpoint_case1 (Params_t *params_
 int DT_endpoint_case2 (Params_t *params_ptr, FFT_Cmd_t *cmd)
 {
     char *dev_name;
-    DAT_IA_HANDLE ia_handle;
-    DAT_EP_HANDLE ep_handle;
-    DAT_EVD_HANDLE send_evd, conn_evd, recv_evd, cr_evd;
-    DAT_PZ_HANDLE pz_handle;
+    struct dat_ia *ia;
+    struct dat_ep *ep;
+    struct dat_evd *send_evd, *conn_evd, *recv_evd, *cr_evd;
+    struct dat_pz *pz;
     struct dat_event event;
     Bpool *bpool;
     int res;
@@ -177,39 +177,39 @@ int DT_endpoint_case2 (Params_t *params_
 	Description: try to destroy ep with descriptor still in working queue\n");
     res = 1;
     bpool = NULL;
-    pz_handle = NULL;
-    ia_handle = NULL;
-    ep_handle = NULL;
+    pz = NULL;
+    ia = NULL;
+    ep = NULL;
     send_evd = NULL;
     conn_evd = NULL;
     recv_evd = NULL;
     cr_evd = NULL;
     dev_name = cmd->device_name;
 
-    rc = DT_ia_open (dev_name, &ia_handle);
+    rc = DT_ia_open (dev_name, &ia);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
-    rc = dat_pz_create (ia_handle, &pz_handle);
+    rc = dat_pz_create (ia, &pz);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
     rc = DT_ep_create (params_ptr, 
-	    	       ia_handle, 
-		       pz_handle, 
+	    	       ia, 
+		       pz, 
 		       &cr_evd, 
 		       &conn_evd, 
 		       &send_evd,
 		       &recv_evd, 
-		       &ep_handle);
+		       &ep);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
-    bpool = DT_BpoolAlloc (NULL, phead, ia_handle, pz_handle, NULL, NULL, 4096, 
+    bpool = DT_BpoolAlloc (NULL, phead, ia, pz, NULL, NULL, 4096, 
                            1, 256 /* FIXME query */, FALSE, FALSE);
     DT_assert (phead, bpool != 0);
     DT_assert (phead, DT_post_recv_buffer (phead, 
-				    ep_handle, 
+				    ep, 
 				    bpool, 
 				    0, 
 				    4096) == TRUE);
-    if (ep_handle)
+    if (ep)
     {
-	rc = dat_ep_free (ep_handle);
+	rc = dat_ep_free (ep);
 	DT_assert_dat (phead, rc == DAT_SUCCESS);
     }
 
@@ -229,14 +229,14 @@ cleanup:
 	rc = DT_Bpool_Destroy (NULL, phead, bpool);
 	DT_assert_clean (phead, rc != FALSE);
     }
-    if (pz_handle)
+    if (pz)
     {
-	rc = dat_pz_free (pz_handle);
+	rc = dat_pz_free (pz);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
-    if (ia_handle)
+    if (ia)
     {
-	rc = dat_ia_close (ia_handle, DAT_CLOSE_ABRUPT_FLAG);
+	rc = dat_ia_close (ia, DAT_CLOSE_ABRUPT_FLAG);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
     return res;
Index: linux-kernel/test/dapltest/test/dapl_transaction_util.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_transaction_util.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_transaction_util.c	(working copy)
@@ -59,7 +59,7 @@ DT_handle_post_recv_buf (DT_Tdep_Print_H
 	     | (((uintptr_t) DT_Bpool_GetBuffer (op->bp, 0)) & 0xffffffffUL));
 
 	/* Post the recv */
-	ret = dat_ep_post_recv ( ep_context[i].ep_handle,
+	ret = dat_ep_post_recv ( ep_context[i].ep,
 				op->num_segs,
 				iov,
 				cookie,
@@ -85,7 +85,7 @@ DT_handle_post_recv_buf (DT_Tdep_Print_H
 boolean_t
 DT_handle_send_op (DT_Tdep_Print_Head *phead, 
 		  Ep_Context_t * ep_context,
-		  DAT_EVD_HANDLE reqt_evd_hdl,
+		  struct dat_evd *reqt_evd_hdl,
 		  unsigned int num_eps,
 		  int op_indx,
 		  boolean_t poll)
@@ -122,7 +122,7 @@ DT_handle_send_op (DT_Tdep_Print_Head *p
 	     | (((uintptr_t) DT_Bpool_GetBuffer (op->bp, 0)) & 0xffffffffUL));
 
 	/* Post the send */
-	ret = dat_ep_post_send ( ep_context[i].ep_handle,
+	ret = dat_ep_post_send ( ep_context[i].ep,
 				op->num_segs,
 				iov,
 				cookie,
@@ -173,7 +173,7 @@ DT_handle_send_op (DT_Tdep_Print_Head *p
 	    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.ep, dto_stat.user_cookie.as_64,
 			   dto_stat.transfered_length);
 	    DT_Test_Error ();
 	    DT_Mdep_Free (completion_reaped);
@@ -188,7 +188,7 @@ DT_handle_send_op (DT_Tdep_Print_Head *p
 
 	if (!DT_dto_check (phead,
 		    	  &dto_stat,
-			  ep_context[epnum].ep_handle,
+			  ep_context[epnum].ep,
 			  op->num_segs * op->seg_size,
 			  dto_cookie,
 			  "Send"))
@@ -201,7 +201,7 @@ DT_handle_send_op (DT_Tdep_Print_Head *p
 	{
 	    DT_Tdep_PT_Printf (phead, 
 		    	"Test Error: Send: Secondary completion seen for endpoint 0x%p (%d)\n",
-			   ep_context[epnum].ep_handle, epnum);
+			   ep_context[epnum].ep, epnum);
 	    DT_Test_Error ();
 	    DT_Mdep_Free (completion_reaped);
 	    return ( FALSE );
@@ -215,7 +215,7 @@ DT_handle_send_op (DT_Tdep_Print_Head *p
 	{
 	    DT_Tdep_PT_Printf (phead, 
 		    	"Test Error: Send: No completion seen for endpoint 0x%p (#%d)\n",
-			   ep_context[i].ep_handle, i);
+			   ep_context[i].ep, i);
 	    DT_Test_Error ();
 	    DT_Mdep_Free (completion_reaped);
 	    return ( FALSE );
@@ -235,8 +235,8 @@ DT_handle_send_op (DT_Tdep_Print_Head *p
 boolean_t
 DT_handle_recv_op (DT_Tdep_Print_Head *phead,
 		  Ep_Context_t * ep_context,
-		  DAT_EVD_HANDLE recv_evd_hdl,
-		  DAT_EVD_HANDLE reqt_evd_hdl,
+		  struct dat_evd *recv_evd_hdl,
+		  struct dat_evd *reqt_evd_hdl,
 		  unsigned int num_eps,
 		  int op_indx,
 		  boolean_t poll,
@@ -283,7 +283,7 @@ DT_handle_recv_op (DT_Tdep_Print_Head *p
 	    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.ep, dto_stat.user_cookie.as_64,
 			   dto_stat.transfered_length);
 	    DT_Test_Error ();
 	    DT_Mdep_Free (recv_completion_reaped);
@@ -298,7 +298,7 @@ DT_handle_recv_op (DT_Tdep_Print_Head *p
 
 	if (!DT_dto_check (phead,
 		    	   &dto_stat,
-			  ep_context[epnum].ep_handle,
+			  ep_context[epnum].ep,
 			  op->num_segs * op->seg_size,
 			  dto_cookie,
 			  "Recv"))
@@ -315,7 +315,7 @@ DT_handle_recv_op (DT_Tdep_Print_Head *p
 	{
 	    DT_Tdep_PT_Printf (phead, 
 		    	"Test Error: Receive: Secondary completion seen for endpoint 0x%p (%d)\n",
-			   ep_context[epnum].ep_handle, epnum);
+			   ep_context[epnum].ep, epnum);
 	    DT_Test_Error ();
 	    DT_Mdep_Free (recv_completion_reaped);
 	    DT_Mdep_Free (send_completion_reaped);
@@ -353,7 +353,7 @@ DT_handle_recv_op (DT_Tdep_Print_Head *p
 		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.ep, dto_stat.user_cookie.as_64,
 			       dto_stat.transfered_length);
 		DT_Test_Error ();
 		DT_Mdep_Free (recv_completion_reaped);
@@ -374,11 +374,11 @@ DT_handle_recv_op (DT_Tdep_Print_Head *p
 
 	    /*
 	     * If we have multiple EPs we can't guarantee the order of
-	     * completions, so disable ep_handle check
+	     * completions, so disable ep check
 	     */
 	    if (!DT_dto_check (phead, 
 			      &dto_stat,
-			      num_eps == 1?ep_context[i].ep_handle: NULL,
+			      num_eps == 1?ep_context[i].ep: NULL,
 			      op->num_segs * op->seg_size,
 			      dto_cookie,
 			      "Send-reaped-on-recv"))
@@ -395,7 +395,7 @@ DT_handle_recv_op (DT_Tdep_Print_Head *p
 	    {
 		DT_Tdep_PT_Printf (phead, 
 				"Test Error: Send (ror): Secondary completion seen for endpoint 0x%p (%d)\n",
-			       ep_context[epnum].ep_handle, epnum);
+			       ep_context[epnum].ep, epnum);
 		DT_Test_Error ();
 		DT_Mdep_Free (recv_completion_reaped);
 		DT_Mdep_Free (send_completion_reaped);
@@ -411,7 +411,7 @@ DT_handle_recv_op (DT_Tdep_Print_Head *p
 	{
 	    DT_Tdep_PT_Printf (phead, 
 		    	"Test Error: Receive: No completion seen for endpoint 0x%p (#%d)\n",
-			   ep_context[i].ep_handle, i);
+			   ep_context[i].ep, i);
 	    DT_Test_Error ();
 	    DT_Mdep_Free (recv_completion_reaped);
 	    DT_Mdep_Free (send_completion_reaped);
@@ -428,7 +428,7 @@ DT_handle_recv_op (DT_Tdep_Print_Head *p
 	    {
 		DT_Tdep_PT_Printf (phead, 
 				"Test Error: Send (ror): No completion seen for endpoint 0x%p (#%d)\n",
-			       ep_context[i].ep_handle, i);
+			       ep_context[i].ep, i);
 		DT_Test_Error ();
 		DT_Mdep_Free (recv_completion_reaped);
 		DT_Mdep_Free (send_completion_reaped);
@@ -463,7 +463,7 @@ DT_handle_recv_op (DT_Tdep_Print_Head *p
 boolean_t
 DT_handle_rdma_op (DT_Tdep_Print_Head *phead,
 		  Ep_Context_t * ep_context,
-		  DAT_EVD_HANDLE reqt_evd_hdl,
+		  struct dat_evd *reqt_evd_hdl,
 		  unsigned int num_eps,
 		  DT_Transfer_Type opcode,
 		  int op_indx,
@@ -516,7 +516,7 @@ DT_handle_rdma_op (DT_Tdep_Print_Head *p
 	if (opcode == RDMA_WRITE)
 	{
 
-	    ret = dat_ep_post_rdma_write (ep_context[i].ep_handle,
+	    ret = dat_ep_post_rdma_write (ep_context[i].ep,
 					 op->num_segs,
 					 iov,
 					 cookie,
@@ -527,7 +527,7 @@ DT_handle_rdma_op (DT_Tdep_Print_Head *p
 	else /* opcode == RDMA_READ */
 	{
 
-	    ret = dat_ep_post_rdma_read ( ep_context[i].ep_handle,
+	    ret = dat_ep_post_rdma_read ( ep_context[i].ep,
 					 op->num_segs,
 					 iov,
 					 cookie,
@@ -574,7 +574,7 @@ DT_handle_rdma_op (DT_Tdep_Print_Head *p
 	    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.ep, dto_stat.user_cookie.as_64,
 			   dto_stat.transfered_length);
 	    DT_Test_Error ();
 	    DT_Mdep_Free (completion_reaped);
@@ -588,7 +588,7 @@ DT_handle_rdma_op (DT_Tdep_Print_Head *p
 
 	if (!DT_dto_check (phead, 
 		    	    &dto_stat,
-			    ep_context[epnum].ep_handle,
+			    ep_context[epnum].ep,
 			    op->num_segs * op->seg_size,
 			    dto_cookie,
 			    (opcode == RDMA_WRITE ? "RDMA/WR" : "RDMA/RD")))
@@ -601,7 +601,7 @@ DT_handle_rdma_op (DT_Tdep_Print_Head *p
 	{
 	    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);
+			   ep_context[epnum].ep, epnum);
 	    DT_Test_Error ();
 	    DT_Mdep_Free (completion_reaped);
 	    return ( FALSE );
@@ -619,7 +619,7 @@ DT_handle_rdma_op (DT_Tdep_Print_Head *p
 	{
 	    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);
+			   ep_context[i].ep, i);
 	    DT_Test_Error ();
 	    DT_Mdep_Free (completion_reaped);
 	    return ( FALSE );
Index: linux-kernel/test/dapltest/test/dapl_fft_pz.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_fft_pz.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_fft_pz.c	(working copy)
@@ -35,9 +35,9 @@ int DT_pz_case0 ( Params_t *params_ptr, 
 		FFT_Cmd_t *cmd)
 {
     char* dev_name;
-    DAT_IA_HANDLE  ia_handle;
-    DAT_PZ_HANDLE pz_handle;
-    DAT_EVD_HANDLE evd_handle;
+    struct dat_ia * ia;
+    struct dat_pz *pz;
+    struct dat_evd *evd;
     u32 rc;
     int res;
     DT_Tdep_Print_Head *phead;
@@ -47,25 +47,25 @@ int DT_pz_case0 ( Params_t *params_ptr, 
 	Description: Test if we can normally create pz and destroy it.\n");
 
     res=1;
-    ia_handle = NULL;
-    pz_handle = NULL;
-    evd_handle = DAT_HANDLE_NULL;
+    ia = NULL;
+    pz = NULL;
+    evd = NULL;
     dev_name= cmd->device_name;
 
-    rc = DT_ia_open (dev_name, &ia_handle);
+    rc = DT_ia_open (dev_name, &ia);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
-    rc = dat_pz_create (ia_handle, &pz_handle);
+    rc = dat_pz_create (ia, &pz);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
 cleanup:
-    if (pz_handle)
+    if (pz)
     {
-	rc = dat_pz_free (pz_handle);
+	rc = dat_pz_free (pz);
 	DT_assert_dat (phead, rc == DAT_SUCCESS);
     }
-    if (ia_handle)
+    if (ia)
     {
-	rc = dat_ia_close (ia_handle, DAT_CLOSE_ABRUPT_FLAG);
+	rc = dat_ia_close (ia, DAT_CLOSE_ABRUPT_FLAG);
 	DT_assert_dat (phead, rc == DAT_SUCCESS);
     }
     return res;
@@ -75,10 +75,10 @@ cleanup:
 int DT_pz_case1 (Params_t *params_ptr, FFT_Cmd_t *cmd)
 {
     char* dev_name;
-    DAT_IA_HANDLE  ia_handle;
-    DAT_PZ_HANDLE pz_handle;
-    DAT_EP_HANDLE ep_handle;
-    DAT_EVD_HANDLE conn_evd, send_evd, recv_evd, cr_evd;
+    struct dat_ia * ia;
+    struct dat_pz *pz;
+    struct dat_ep *ep;
+    struct dat_evd *conn_evd, *send_evd, *recv_evd, *cr_evd;
     u32 rc;
     int res;
     DT_Tdep_Print_Head *phead;
@@ -88,42 +88,42 @@ int DT_pz_case1 (Params_t *params_ptr, F
 	Description: try to destroy pz with vi still associated with it\n");
 
     res=1;
-    ia_handle = NULL;
-    pz_handle = NULL;
-    ep_handle = NULL;
+    ia = NULL;
+    pz = NULL;
+    ep = NULL;
     conn_evd = NULL;
     send_evd = NULL;
     recv_evd = NULL;
     cr_evd = NULL;
     dev_name= cmd->device_name;
 
-    rc = DT_ia_open (dev_name, &ia_handle);
+    rc = DT_ia_open (dev_name, &ia);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
-    rc = dat_pz_create (ia_handle, &pz_handle);
+    rc = dat_pz_create (ia, &pz);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
     rc = DT_ep_create (params_ptr, 
-	    	       ia_handle, 
-		       pz_handle, 
+	    	       ia, 
+		       pz, 
 		       &cr_evd, 
 		       &conn_evd, 
 		       &send_evd,
 		       &recv_evd, 
-		       &ep_handle);
+		       &ep);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
-    if (pz_handle)
+    if (pz)
     {
-	rc = dat_pz_free (pz_handle);
+	rc = dat_pz_free (pz);
 	DT_assert_dat (phead, DAT_GET_TYPE (rc) == DAT_INVALID_STATE);
     }
 
 cleanup:
     /* corrrect order */
-    if (ep_handle)
+    if (ep)
     {
-	rc=dat_ep_free (ep_handle);
+	rc=dat_ep_free (ep);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
     if (conn_evd)
@@ -141,15 +141,15 @@ cleanup:
 	rc = DT_Tdep_evd_free (recv_evd);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
-    if (pz_handle)
+    if (pz)
     {
-	rc=dat_pz_free (pz_handle);
+	rc=dat_pz_free (pz);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
-    if (ia_handle)
+    if (ia)
     {
-	rc=dat_ia_close (ia_handle, DAT_CLOSE_ABRUPT_FLAG);
+	rc=dat_ia_close (ia, DAT_CLOSE_ABRUPT_FLAG);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
@@ -160,8 +160,8 @@ cleanup:
 int DT_pz_case2 (Params_t *params_ptr, FFT_Cmd_t *cmd)
 {
     char* dev_name;
-    DAT_IA_HANDLE  ia_handle;
-    DAT_PZ_HANDLE pz_handle;
+    struct dat_ia * ia;
+    struct dat_pz *pz;
     Bpool *bpool;
     u32 rc;
     int res;
@@ -174,26 +174,26 @@ int DT_pz_case2 (Params_t *params_ptr, F
 	associated with it\n");
 
     res=1;
-    ia_handle = NULL;
-    pz_handle = NULL;
+    ia = NULL;
+    pz = NULL;
     bpool = NULL;
     dev_name= cmd->device_name;
 
-    rc = DT_ia_open (dev_name, &ia_handle);
+    rc = DT_ia_open (dev_name, &ia);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
-    rc = dat_pz_create (ia_handle, &pz_handle);
+    rc = dat_pz_create (ia, &pz);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
     /* allocate and register bpool */
-    bpool = DT_BpoolAlloc (NULL, phead, ia_handle, pz_handle, NULL,
+    bpool = DT_BpoolAlloc (NULL, phead, ia, pz, NULL,
                            NULL, BUFFSIZE, 1, 256 /* FIXME query */,
                            FALSE, FALSE);
     DT_assert (phead, bpool != 0);
 
-    if (pz_handle)
+    if (pz)
     {
-	rc = dat_pz_free (pz_handle);
+	rc = dat_pz_free (pz);
 	DT_assert_dat (phead, DAT_GET_TYPE (rc) == DAT_INVALID_STATE);
     }
 
@@ -205,15 +205,15 @@ cleanup:
 	DT_Tdep_PT_Printf (phead, "Warning: Destroy bpool fails, reboot for cleanup\n");
 	return 0;
     }
-    if (pz_handle)
+    if (pz)
     {
-	rc=dat_pz_free (pz_handle);
+	rc=dat_pz_free (pz);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
-    if (ia_handle)
+    if (ia)
     {
-	rc=dat_ia_close (ia_handle, DAT_CLOSE_ABRUPT_FLAG);
+	rc=dat_ia_close (ia, DAT_CLOSE_ABRUPT_FLAG);
 	DT_assert_clean (phead, rc == DAT_SUCCESS);
     }
 
Index: linux-kernel/test/dapltest/test/dapl_fft_hwconn.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_fft_hwconn.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_fft_hwconn.c	(working copy)
@@ -31,8 +31,8 @@
 int DT_hwconn_case0 ( Params_t *params_ptr, FFT_Cmd_t *cmd)
 {
     char* dev_name;
-    DAT_IA_HANDLE  nic_handle;
-    DAT_EVD_HANDLE evd_handle;
+    struct dat_ia * nic_handle;
+    struct dat_evd *evd;
     u32 rc;
     int res = 1;
     DT_Tdep_Print_Head *phead;
@@ -43,9 +43,9 @@ int DT_hwconn_case0 ( Params_t *params_p
 
     dev_name= cmd->device_name;
     nic_handle = NULL;
-    evd_handle = DAT_HANDLE_NULL;
+    evd = NULL;
 
-    rc=dat_ia_open ((const char *)dev_name, 10, &evd_handle, &nic_handle);
+    rc=dat_ia_open ((const char *)dev_name, 10, &evd, &nic_handle);
     DT_assert_dat (phead, rc == DAT_SUCCESS);
 
     rc=dat_ia_close (nic_handle, DAT_CLOSE_ABRUPT_FLAG);
@@ -58,9 +58,9 @@ cleanup:
 /*--------------------------------------------------------*/
 int DT_hwconn_case1 ( Params_t *params_ptr, FFT_Cmd_t *cmd)
 {
-    DAT_IA_HANDLE  nic_handle;
+    struct dat_ia * nic_handle;
     u32 rc;
-    DAT_EVD_HANDLE evd_handle;
+    struct dat_evd *evd;
     char dev_name[100];
     int i;
     DT_Tdep_Print_Head *phead;
@@ -94,8 +94,8 @@ int DT_hwconn_case1 ( Params_t *params_p
 	    sprintf (dev_name, "%s", "34df"); /* number_letter */
 	}
 
-	evd_handle = DAT_HANDLE_NULL;
-	rc=dat_ia_open ((const char *)dev_name, 10, &evd_handle, &nic_handle);
+	evd = NULL;
+	rc=dat_ia_open ((const char *)dev_name, 10, &evd, &nic_handle);
 	if (DAT_GET_TYPE (rc) != DAT_PROVIDER_NOT_FOUND)
 	{
 	    const char *major_msg, *minor_msg;
@@ -120,7 +120,7 @@ int DT_hwconn_case1 ( Params_t *params_p
 /*--------------------------------------------------------*/
 int DT_hwconn_case2 (Params_t *params_ptr, FFT_Cmd_t *cmd)
 {
-    DAT_IA_HANDLE  nic_handle;
+    struct dat_ia * nic_handle;
     u32 rc;
     int res=1;
     DT_Tdep_Print_Head *phead;
@@ -156,9 +156,9 @@ int DT_hwconn_case3 (Params_t *params_pt
     DT_fft_init_client (params_ptr, cmd, &conn);
 
     /* try to close nic when vi have not destroyed */
-    if (conn.ia_handle)
+    if (conn.ia)
     {
-	rc= dat_ia_close (conn.ia_handle, DAT_CLOSE_ABRUPT_FLAG);
+	rc= dat_ia_close (conn.ia, DAT_CLOSE_ABRUPT_FLAG);
 	if (rc !=DAT_SUCCESS)
 	{
 	    DT_Tdep_PT_Printf (phead, "Warning: dat_ia_close fails %s, reboot for cleanup\n",
Index: linux-kernel/test/dapltest/test/dapl_fft_dataxfer.c
===================================================================
--- linux-kernel/test/dapltest/test/dapl_fft_dataxfer.c	(revision 2572)
+++ linux-kernel/test/dapltest/test/dapl_fft_dataxfer.c	(working copy)
@@ -34,7 +34,7 @@ int DT_dataxfer_generic ( DT_Tdep_Print_
     u32 rc=0;
     int res=1;
     DT_fft_init_server (phead, cmd, &conn);
-    DT_assert (phead, NULL != conn.ia_handle);
+    DT_assert (phead, NULL != conn.ia);
 
     DT_fft_listen (phead, &conn);
 
@@ -81,7 +81,7 @@ cleanup:
 int DT_dataxfer_case0 ( DT_Tdep_Print_Head *phead, FFT_Cmd_t *cmd)
 {
     DT_Tdep_PT_Printf (phead, "\
-	Description: Call dat_ep_post_send with null ep_handle.\n");
+	Description: Call dat_ep_post_send with null ep.\n");
     return DT_dataxfer_generic (phead, cmd, 0);
 }
 
Index: linux-kernel/test/dapltest/include/dapl_tdep.h
===================================================================
--- linux-kernel/test/dapltest/include/dapl_tdep.h	(revision 2572)
+++ linux-kernel/test/dapltest/include/dapl_tdep.h	(working copy)
@@ -31,7 +31,7 @@
 #include "dapl_proto.h"
 
 #ifdef __KDAPL__
-typedef DAT_HANDLE      DAT_CNO_HANDLE;
+typedef void *     DAT_CNO_HANDLE;
 #endif
 
 /* function prototypes */
@@ -45,21 +45,21 @@ int
 DT_Tdep_Execute_Test ( Params_t *params_ptr ) ;
 
 u32
-DT_Tdep_evd_create (DAT_IA_HANDLE	ia_handle,
+DT_Tdep_evd_create (struct dat_ia *	ia,
 		    int		evd_min_qlen,
 		    DAT_CNO_HANDLE	cno_handle,
 		    enum dat_evd_flags	evd_flags,
-		    DAT_EVD_HANDLE 	*evd_handle_ptr);
+		    struct dat_evd *	*evd_ptr);
 
 u32
-DT_Tdep_evd_free (DAT_EVD_HANDLE 	evd_handle);
+DT_Tdep_evd_free (struct dat_evd *	evd);
 
 u32
-DT_Tdep_evd_wait (DAT_EVD_HANDLE 	evd_handle,
+DT_Tdep_evd_wait (struct dat_evd *	evd,
 		  unsigned long   	timeout,
 		  struct dat_event    	*event);
 u32
-DT_Tdep_evd_dequeue (DAT_EVD_HANDLE	evd_handle,
+DT_Tdep_evd_dequeue (struct dat_evd *	evd,
 		     struct dat_event	*event);
 
 #endif
Index: linux-kernel/test/dapltest/include/dapl_performance_test.h
===================================================================
--- linux-kernel/test/dapltest/include/dapl_performance_test.h	(revision 2572)
+++ linux-kernel/test/dapltest/include/dapl_performance_test.h	(working copy)
@@ -54,7 +54,7 @@ typedef struct {
 
 typedef struct
 {
-    DAT_EP_HANDLE           ep_handle;
+    struct dat_ep *          ep;
     struct dat_ep_attr	    ep_attr;
     DAT_CONN_QUAL           port;
     int               pipeline_len;
@@ -70,17 +70,17 @@ typedef struct
     boolean_t             	is_remote_little_endian;
     DAT_CONN_QUAL           	base_port;
     struct dat_ia_attr		ia_attr;
-    DAT_IA_HANDLE           	ia_handle;
-    DAT_PZ_HANDLE           	pz_handle;
+    struct dat_ia *          	ia;
+    struct dat_pz *          	pz;
     DAT_CNO_HANDLE          	cno_handle;
     int               	reqt_evd_length;
-    DAT_EVD_HANDLE          	reqt_evd_hdl;	/* request+rmr  */
+    struct dat_evd *         	reqt_evd_hdl;	/* request+rmr  */
     int               	recv_evd_length;
-    DAT_EVD_HANDLE          	recv_evd_hdl;	/* receive	*/
+    struct dat_evd *         	recv_evd_hdl;	/* receive	*/
     int               	conn_evd_length;
-    DAT_EVD_HANDLE          	conn_evd_hdl;	/* connect	*/
+    struct dat_evd *         	conn_evd_hdl;	/* connect	*/
     int               	creq_evd_length;
-    DAT_EVD_HANDLE          	creq_evd_hdl;	/* "" request   */
+    struct dat_evd *         	creq_evd_hdl;	/* "" request   */
     Performance_Ep_Context_t 	ep_context;
 } Performance_Test_t;
 
Index: linux-kernel/test/dapltest/include/dapl_proto.h
===================================================================
--- linux-kernel/test/dapltest/include/dapl_proto.h	(revision 2572)
+++ linux-kernel/test/dapltest/include/dapl_proto.h	(working copy)
@@ -81,10 +81,10 @@ extern int g_status;
 /* dapl_bpool.c */
 Bpool *         DT_BpoolAlloc (Per_Test_Data_t * pt_ptr,
 			       DT_Tdep_Print_Head* phead,
-			       DAT_IA_HANDLE ia_handle,
-			       DAT_PZ_HANDLE pz_handle,
-			       DAT_EP_HANDLE ep_handle,
-			       DAT_EVD_HANDLE rmr_evd_handle,
+			       struct dat_ia *ia,
+			       struct dat_pz *pz,
+			       struct dat_ep *ep,
+			       struct dat_evd *rmr_evd,
 			       int seg_size,
 			       int num_segs,
 			       int alignment,
@@ -106,7 +106,7 @@ void            DT_Bpool_print (DT_Tdep_
 
 /* dapl_cnxn.c */
 int             get_ep_connection_state (DT_Tdep_Print_Head* phead, 
-				 	 DAT_EP_HANDLE ep_handle);
+				 	 struct dat_ep *ep);
 
 /* dapl_client.c */
 int             DT_cs_Client (Params_t * params_ptr,
@@ -236,7 +236,7 @@ void            DT_Performance_Cmd_Endia
 /* dapl_performance_client.c */
 int             DT_Performance_Test_Client (   Params_t	*params_ptr,
 					       Per_Test_Data_t * pt_ptr,
-					       DAT_IA_HANDLE ia_handle,
+					       struct dat_ia *ia,
 					       struct sockaddr *remote);
 
 boolean_t            DT_Performance_Test_Client_Connect (
@@ -261,7 +261,7 @@ boolean_t            DT_Performance_Test
 
 /* dapl_performance_util.c */
 boolean_t            DT_Performance_Test_Create (Per_Test_Data_t * pt_ptr,
-					   DAT_IA_HANDLE ia_handle,
+					   struct dat_ia *ia,
 					   struct sockaddr *remote_ia_addr,
 					   boolean_t is_server,
 					   boolean_t is_remote_little_endian,
@@ -272,20 +272,20 @@ int             DT_Performance_Test_Dest
 					    boolean_t is_server);
 
 boolean_t            DT_performance_post_rdma_op (Performance_Ep_Context_t *ep_context,
-					    DAT_EVD_HANDLE 	reqt_evd_hdl,
+					    struct dat_evd *	reqt_evd_hdl,
 					    Performance_Stats_t *stats);
 
 unsigned int   DT_performance_reap (DT_Tdep_Print_Head* phead, 
-				    DAT_EVD_HANDLE evd_handle,
+				    struct dat_evd *evd,
 				    Performance_Mode_Type mode,
 				    Performance_Stats_t *stats);
 
 unsigned int   DT_performance_wait (DT_Tdep_Print_Head* phead, 
-				    DAT_EVD_HANDLE evd_handle,
+				    struct dat_evd *evd,
 				    Performance_Stats_t *stats);
 
 unsigned int   DT_performance_poll (DT_Tdep_Print_Head* phead, 
-				    DAT_EVD_HANDLE evd_handle,
+				    struct dat_evd *evd,
 				    Performance_Stats_t *stats);
 
 /* dapl_performance_stats.c */
@@ -346,69 +346,69 @@ void 		DT_Free_Per_Test_Data (Per_Test_D
 
 /* dapl_test_util.c */
 boolean_t     DT_query (Per_Test_Data_t *pt_ptr,
-			     DAT_IA_HANDLE   ia_handle,
-			     DAT_EP_HANDLE   ep_handle);
+			     struct dat_ia *  ia,
+			     struct dat_ep *  ep);
 
 boolean_t     DT_post_recv_buffer (DT_Tdep_Print_Head* phead, 
-    				       DAT_EP_HANDLE ep_handle,
+    				       struct dat_ep *ep,
 					Bpool * bp,
 					int index,
 					int size);
 
 boolean_t     DT_post_send_buffer (DT_Tdep_Print_Head* phead, 
-    				       DAT_EP_HANDLE ep_handle,
+    				       struct dat_ep *ep,
 					Bpool * bp,
 					int index,
 					int size);
 
 boolean_t            DT_conn_event_wait (DT_Tdep_Print_Head* phead,  
-    				       DAT_EP_HANDLE ep_handle,
-				       DAT_EVD_HANDLE evd_handle,
+    				       struct dat_ep *ep,
+				       struct dat_evd *evd,
 				       enum dat_event_number *event_number);
 
 boolean_t 	DT_disco_event_wait ( DT_Tdep_Print_Head* phead, 
-				    DAT_EVD_HANDLE evd_handle,
-				      DAT_EP_HANDLE  *ep_handle );
+				    struct dat_evd *evd,
+				      struct dat_ep * *ep );
 
 boolean_t            DT_cr_event_wait (DT_Tdep_Print_Head* phead, 
-				DAT_EVD_HANDLE evd_handle,
+				struct dat_evd *evd,
 				  struct dat_cr_arrival_event_data *cr_stat_p);
 
 boolean_t            DT_dto_event_reap (DT_Tdep_Print_Head* phead, 
-				   DAT_EVD_HANDLE evd_handle,
+				   struct dat_evd *evd,
 				   boolean_t poll,
 				   struct dat_dto_completion_event_data *dtop);
 
 boolean_t            DT_dto_event_wait (DT_Tdep_Print_Head* phead, 
-				   DAT_EVD_HANDLE evd_handle,
+				   struct dat_evd *evd,
 				   struct dat_dto_completion_event_data *dtop);
 
 boolean_t            DT_dto_event_poll (DT_Tdep_Print_Head* phead, 
-				   DAT_EVD_HANDLE evd_handle,
+				   struct dat_evd *evd,
 				   struct dat_dto_completion_event_data *dtop);
 
 boolean_t            DT_rmr_event_wait (DT_Tdep_Print_Head* phead, 
-				DAT_EVD_HANDLE evd_handle,
+				struct dat_evd *evd,
 			struct dat_rmr_bind_completion_event_data *rmr_ptr);
 
 boolean_t            DT_dto_check ( DT_Tdep_Print_Head* phead, 
 				  struct dat_dto_completion_event_data *dto_p,
-				  DAT_EP_HANDLE   ep_expected,
+				  struct dat_ep *  ep_expected,
 				  int       len_expected,
 				  DAT_DTO_COOKIE  cookie_expected,
 				  char            *message);
 
 boolean_t            DT_rmr_check ( DT_Tdep_Print_Head* phead, 
 			      struct dat_rmr_bind_completion_event_data *rmr_p,
-				  DAT_RMR_HANDLE  rmr_expected,
+				  struct dat_rmr *  rmr_expected,
 				  void *      cookie_expected,
 				  char            *message);
 
 boolean_t            DT_cr_check (DT_Tdep_Print_Head* phead, 
 				struct dat_cr_arrival_event_data *cr_stat_p,
-				DAT_PSP_HANDLE psp_handle_expected,
+				struct dat_sp *psp_expected,
 				DAT_CONN_QUAL  port_expected,
-				DAT_CR_HANDLE *cr_handlep,
+				struct dat_cr **crp,
 				char          *message);
 
 /* dapl_thread.c */
@@ -460,13 +460,13 @@ void            DT_Transaction_Cmd_Endia
 					   boolean_t to_wire);
 /* dapl_transaction_test.c */
 int             DT_Transaction_Test_Client (Per_Test_Data_t * pt_ptr,
-					    DAT_IA_HANDLE ia_handle,
+					    struct dat_ia *ia,
 					    struct sockaddr *remote);
 
 void            DT_Transaction_Test_Server (void *params);
 
 boolean_t            DT_Transaction_Create_Test (Per_Test_Data_t * pt_ptr,
-					    DAT_IA_HANDLE * ia_handle,
+					    struct dat_ia *ia,
 					    boolean_t is_server,
 					    unsigned int port_num,
 					    boolean_t remote_is_little_endian,
@@ -491,15 +491,15 @@ boolean_t            DT_handle_post_recv
 
 boolean_t            DT_handle_send_op (DT_Tdep_Print_Head* phead, 
 					Ep_Context_t * ep_context,
-					DAT_EVD_HANDLE reqt_evd_hdl,
+					struct dat_evd *reqt_evd_hdl,
 					unsigned int num_eps,
 					int op_indx,
 					boolean_t poll);
 
 boolean_t            DT_handle_recv_op (DT_Tdep_Print_Head* phead, 
 					Ep_Context_t * ep_context,
-					DAT_EVD_HANDLE recv_evd_hdl,
-					DAT_EVD_HANDLE reqt_evd_hdl,
+					struct dat_evd *recv_evd_hdl,
+					struct dat_evd *reqt_evd_hdl,
 					unsigned int num_eps,
 					int op_indx,
 					boolean_t poll,
@@ -507,7 +507,7 @@ boolean_t            DT_handle_recv_op (
 
 boolean_t            DT_handle_rdma_op (DT_Tdep_Print_Head* phead, 
 					Ep_Context_t * ep_context,
-					DAT_EVD_HANDLE reqt_evd_hdl,
+					struct dat_evd *reqt_evd_hdl,
 					unsigned int num_eps,
 					DT_Transfer_Type opcode,
 					int op_indx,
@@ -600,15 +600,15 @@ void	    DT_assert_fail (DT_Tdep_Print_H
 			    char *file, 
 			    char *baseFile, 
 			    int line);
-int	    DT_ia_open (char *dev_name, DAT_IA_HANDLE *ia_handle);
+int	    DT_ia_open (char *dev_name, struct dat_ia **ia);
 int	    DT_ep_create (Params_t *params_ptr,
-			  DAT_IA_HANDLE ia_handle, 
-			  DAT_PZ_HANDLE pz_handle,
-			  DAT_EVD_HANDLE *cr_evd,
-			  DAT_EVD_HANDLE *conn_evd, 
-			  DAT_EVD_HANDLE *send_evd,
-			  DAT_EVD_HANDLE *recv_evd, 
-			  DAT_EP_HANDLE *ep_handle);
+			  struct dat_ia *ia, 
+			  struct dat_pz *pz,
+			  struct dat_evd **cr_evd,
+			  struct dat_evd **conn_evd, 
+			  struct dat_evd **send_evd,
+			  struct dat_evd **recv_evd, 
+			  struct dat_ep **ep);
 void	    DT_fft_init_conn_struct (FFT_Connection_t *conn);
 void	    DT_fft_init_client (Params_t *params_ptr,
 				FFT_Cmd_t *cmd, 
Index: linux-kernel/test/dapltest/include/dapl_test_data.h
===================================================================
--- linux-kernel/test/dapltest/include/dapl_test_data.h	(revision 2572)
+++ linux-kernel/test/dapltest/include/dapl_test_data.h	(working copy)
@@ -46,16 +46,16 @@ typedef struct
     int             	NextPortNumber;
     int             	num_clients;
     spinlock_t   	num_clients_lock;
-    DAT_IA_HANDLE   	ia_handle;
-    DAT_PZ_HANDLE   	pz_handle;
-    DAT_EVD_HANDLE  	recv_evd_hdl;
-    DAT_EVD_HANDLE  	reqt_evd_hdl;
-    DAT_EVD_HANDLE  	conn_evd_hdl;
-    DAT_EVD_HANDLE  	creq_evd_hdl;
-    DAT_EVD_HANDLE  	async_evd_hdl;
-    DAT_EVD_HANDLE  	rmr_evd_hdl;
-    DAT_EP_HANDLE   	ep_handle;
-    DAT_PSP_HANDLE  	psp_handle;
+    struct dat_ia	*ia;
+    struct dat_pz	*pz;
+    struct dat_evd	*recv_evd_hdl;
+    struct dat_evd	*reqt_evd_hdl;
+    struct dat_evd	*conn_evd_hdl;
+    struct dat_evd	*creq_evd_hdl;
+    struct dat_evd	*async_evd_hdl;
+    struct dat_evd	*rmr_evd_hdl;
+    struct dat_ep	*ep;
+    struct dat_sp   	*psp;
     Bpool          	*bpool;
 } Per_Server_Data_t;
 
Index: linux-kernel/test/dapltest/include/dapl_bpool.h
===================================================================
--- linux-kernel/test/dapltest/include/dapl_bpool.h	(revision 2572)
+++ linux-kernel/test/dapltest/include/dapl_bpool.h	(working copy)
@@ -38,21 +38,21 @@ typedef struct Bpool_tag Bpool;
 struct Bpool_tag {
     unsigned char          *alloc_ptr;
     uint32_t                alloc_size;
-    DAT_PZ_HANDLE           pz_handle;
+    struct dat_pz *          pz;
     int               seg_size;
     int               num_segs;		/* num segments */
     unsigned char          *buffer_start;	/* Start of buffer area */
     u64                buffer_size;    /* Size of data buffer (rounded) */
     u64               reg_addr;		/* start of registered area */
     u64                reg_size;		/* size of registered area */
-    DAT_EP_HANDLE           ep_handle;		/* EP area is registered to */
-    DAT_LMR_HANDLE          lmr_handle;		/* local access */
+    struct dat_ep *          ep;		/* EP area is registered to */
+    struct dat_lmr *         lmr;		/* local access */
     DAT_LMR_CONTEXT         lmr_context;
     struct dat_lmr_triplet *tripl_start;	/* local IOV */
     boolean_t             enable_rdma_write;	/* remote access */
     boolean_t             enable_rdma_read;
-    DAT_RMR_HANDLE          rmr_handle;
+    struct dat_rmr *          rmr_handle;
     DAT_RMR_CONTEXT         rmr_context;
-    DAT_EVD_HANDLE          rmr_evd_handle;
+    struct dat_evd *         rmr_evd;
 };
 #endif
Index: linux-kernel/test/dapltest/include/dapl_fft_util.h
===================================================================
--- linux-kernel/test/dapltest/include/dapl_fft_util.h	(revision 2572)
+++ linux-kernel/test/dapltest/include/dapl_fft_util.h	(working copy)
@@ -55,14 +55,14 @@
 
 typedef struct
 {
-    DAT_IA_HANDLE ia_handle;
-    DAT_PZ_HANDLE pz_handle;
-    DAT_PSP_HANDLE psp_handle;
-    DAT_EP_HANDLE ep_handle;
-    DAT_EVD_HANDLE cr_evd, conn_evd, send_evd, recv_evd;
+    struct dat_ia *ia;
+    struct dat_pz *pz;
+    struct dat_sp *psp;
+    struct dat_ep *ep;
+    struct dat_evd *cr_evd, *conn_evd, *send_evd, *recv_evd;
     struct dat_event event;
     int count;
-    DAT_CR_HANDLE cr_handle;
+    struct dat_cr *cr;
     Bpool *bpool;
     struct dat_cr_arrival_event_data cr_stat;
     enum dat_event_number event_num;
Index: linux-kernel/test/dapltest/include/dapl_transaction_test.h
===================================================================
--- linux-kernel/test/dapltest/include/dapl_transaction_test.h	(revision 2572)
+++ linux-kernel/test/dapltest/include/dapl_transaction_test.h	(working copy)
@@ -49,13 +49,13 @@ typedef struct
 
 typedef struct
 {
-    DAT_EP_HANDLE           ep_handle;
+    struct dat_ep *          ep;
     struct dat_ep_attr	    ep_attr;
     DAT_CONN_QUAL           ia_port;
     Bpool                   *bp;
     Transaction_Test_Op_t   op[ MAX_OPS ];
-    DAT_RSP_HANDLE          rsp_handle;
-    DAT_PSP_HANDLE          psp_handle;
+    struct dat_sp *         rsp;
+    struct dat_sp *         psp;
 
 } Ep_Context_t;
 
@@ -75,7 +75,7 @@ typedef struct
     boolean_t             is_server;
     boolean_t             remote_is_little_endian;
     Per_Test_Data_t         *pt_ptr;
-    DAT_IA_HANDLE           ia_handle;
+    struct dat_ia          *ia;
     Transaction_Cmd_t       *cmd;
     struct sockaddr *     remote_ia_addr;
     DAT_CONN_QUAL           base_port;
@@ -84,11 +84,11 @@ typedef struct
     Thread                  *thread;
 
     /* This group set up by each thread in DT_Transaction_Main() */
-    DAT_PZ_HANDLE           pz_handle;
-    DAT_EVD_HANDLE          recv_evd_hdl;   /* receive	    */
-    DAT_EVD_HANDLE          reqt_evd_hdl;   /* request+rmr  */
-    DAT_EVD_HANDLE          conn_evd_hdl;   /* connect	    */
-    DAT_EVD_HANDLE          creq_evd_hdl;   /* "" request   */
+    struct dat_pz *          pz;
+    struct dat_evd *         recv_evd_hdl;   /* receive	    */
+    struct dat_evd *         reqt_evd_hdl;   /* request+rmr  */
+    struct dat_evd *         conn_evd_hdl;   /* connect	    */
+    struct dat_evd *         creq_evd_hdl;   /* "" request   */
     Ep_Context_t            *ep_context;
 
     /* Statistics set by DT_Transaction_Run() */
Index: linux-kernel/test/dapltest/kdapl/kdapl_tdep_evd.c
===================================================================
--- linux-kernel/test/dapltest/kdapl/kdapl_tdep_evd.c	(revision 2572)
+++ linux-kernel/test/dapltest/kdapl/kdapl_tdep_evd.c	(working copy)
@@ -39,7 +39,7 @@ typedef struct Tdep_Evd_Tag
     struct Tdep_Evd_Tag		*evd_next;
     struct Tdep_Event_Tag	*event_next;
     struct Tdep_Event_Tag	*event_last;
-    DAT_EVD_HANDLE     		evd_handle;
+    struct dat_evd *    		evd;
     DT_WAIT_OBJECT     		wait_object;
 } Tdep_Evd;
 
@@ -94,11 +94,11 @@ KDT_Evd_Destroy(void)
 }
 
 u32
-DT_Tdep_evd_create (DAT_IA_HANDLE		ia_handle,
+DT_Tdep_evd_create (struct dat_ia *		ia,
 		    int			evd_min_qlen,
 		    DAT_CNO_HANDLE		cno_handle,
 		    enum dat_evd_flags		evd_flags,
-		    DAT_EVD_HANDLE		*evd_handle_ptr)
+		    struct dat_evd		**evd_ptr_ptr)
 
 {
     u32 		dat_status;
@@ -120,12 +120,12 @@ DT_Tdep_evd_create (DAT_IA_HANDLE		ia_ha
     upcall.upcall_func = DT_Tdep_Event_Callback;
     upcall.instance_data = evd_ptr;
 
-    dat_status = dat_evd_kcreate (ia_handle,
+    dat_status = dat_evd_kcreate (ia,
 				  evd_min_qlen,
 				  DAT_UPCALL_SINGLE_INSTANCE,
 				  &upcall,
 				  evd_flags,
-				  evd_handle_ptr);
+				  evd_ptr_ptr);
     if (dat_status != DAT_SUCCESS)
     {
 	goto error;
@@ -134,7 +134,7 @@ DT_Tdep_evd_create (DAT_IA_HANDLE		ia_ha
     /* initialize evd_ptr */
     evd_ptr->event_next = NULL;
     evd_ptr->event_last = NULL;
-    evd_ptr->evd_handle = *evd_handle_ptr;
+    evd_ptr->evd = *evd_ptr_ptr;
     DT_Mdep_wait_object_init (&evd_ptr->wait_object);
 
     /* add evd_ptr to front of evd list */
@@ -154,7 +154,7 @@ error:
     return (dat_status);
 }
 u32
-DT_Tdep_evd_dequeue (DAT_EVD_HANDLE evd_handle,
+DT_Tdep_evd_dequeue (struct dat_evd *evd,
 		     struct dat_event *dat_event)
 {
     u32 dat_status;
@@ -163,11 +163,11 @@ DT_Tdep_evd_dequeue (DAT_EVD_HANDLE evd_
     unsigned long flags;
     dat_status = DAT_SUCCESS;
 
-    /* find the evd_ptr associated with evd_handle */
+    /* find the evd_ptr associated with evd */
     evd_ptr = DT_Evd_List;
     while (evd_ptr)
     {
-        if (evd_ptr->evd_handle == evd_handle)
+        if (evd_ptr->evd == evd)
         {
             break;
         }
@@ -181,7 +181,7 @@ DT_Tdep_evd_dequeue (DAT_EVD_HANDLE evd_
     }
     /* Get event */
     spin_lock_irqsave (&DT_Evd_Lock, flags);
-    event = evd_ptr->event_next; /* event present in evd_ptr corresponding to the given evd_handle */
+    event = evd_ptr->event_next; /* event present in evd_ptr corresponding to the given evd */
     if (event)
     {
         evd_ptr->event_next = event->event_next; /* point to next event */
@@ -212,7 +212,7 @@ DT_Tdep_evd_dequeue (DAT_EVD_HANDLE evd_
 }
 
 u32
-DT_Tdep_evd_wait (DAT_EVD_HANDLE evd_handle,
+DT_Tdep_evd_wait (struct dat_evd *evd,
 		  unsigned long   timeout,
 		  struct dat_event      *dat_event)
 {
@@ -223,11 +223,11 @@ DT_Tdep_evd_wait (DAT_EVD_HANDLE evd_han
 
     dat_status = DAT_CLASS_ERROR | DAT_INTERNAL_ERROR;
 
-    /* find the evd_ptr associated with evd_handle */
+    /* find the evd_ptr associated with evd */
     evd_ptr = DT_Evd_List;
     while (evd_ptr)
     {
-	if (evd_ptr->evd_handle == evd_handle)
+	if (evd_ptr->evd == evd)
 	{
 	    break;
 	}
@@ -290,7 +290,7 @@ DT_Tdep_evd_wait (DAT_EVD_HANDLE evd_han
 }
 
 u32
-DT_Tdep_evd_free (DAT_EVD_HANDLE evd_handle)
+DT_Tdep_evd_free (struct dat_evd *evd)
 {
     Tdep_Evd	*next;
     Tdep_Evd	*last;
@@ -298,13 +298,13 @@ DT_Tdep_evd_free (DAT_EVD_HANDLE evd_han
     last = NULL;
     spin_lock_irq (&DT_Evd_Lock);
     next = DT_Evd_List;
-    if (next->evd_handle == evd_handle)
+    if (next->evd == evd)
     {
 	DT_Evd_List = next->evd_next;
     }
     else
     {
-	while (next && next->evd_handle != evd_handle)
+	while (next && next->evd != evd)
 	{
 	    last = next;
 	    next = next->evd_next;
@@ -317,7 +317,7 @@ DT_Tdep_evd_free (DAT_EVD_HANDLE evd_han
     spin_unlock_irq (&DT_Evd_Lock);
 
     DT_Mdep_Free (next);
-    return dat_evd_free(evd_handle);
+    return dat_evd_free(evd);
 }
 
 static void DT_Tdep_Event_Callback (
Index: linux-kernel/dat-provider/dapl_cr_reject.c
===================================================================
--- linux-kernel/dat-provider/dapl_cr_reject.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_cr_reject.c	(working copy)
@@ -40,36 +40,36 @@
  * Reject a connection request from the active remote side requesting
  * an Endpoint.
  */
-u32 dapl_cr_reject(DAT_CR_HANDLE cr_handle)
+u32 dapl_cr_reject(struct dat_cr *cr)
 {
 	struct dapl_cr *cr_ptr;
 	struct dapl_ep *ep_ptr;
 	enum dat_ep_state entry_ep_state;
-	DAT_EP_HANDLE entry_ep_handle;
+	struct dat_ep *entry_ep;
 	struct dapl_sp *sp_ptr;
 	u32 dat_status;
 
-	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_cr_reject (%p)\n", cr_handle);
+	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_cr_reject (%p)\n", cr);
 
-	if (DAPL_BAD_HANDLE(cr_handle, DAPL_MAGIC_CR)) {
+	if (!cr) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CR);
 		goto bail;
 	}
 
-	cr_ptr = (struct dapl_cr *)cr_handle;
+	cr_ptr = (struct dapl_cr *)cr;
 
 	/*
 	 * Clean up provider created EP if there is one: only if
 	 * DAT_PSP_PROVIDER_FLAG was set on the PSP
 	 */
-	ep_ptr = (struct dapl_ep *)cr_ptr->param.local_ep_handle;
-	entry_ep_handle = cr_ptr->param.local_ep_handle;
+	ep_ptr = (struct dapl_ep *)cr_ptr->param.local_ep;
+	entry_ep = cr_ptr->param.local_ep;
 	entry_ep_state = 0;
 	if (ep_ptr) {
 		entry_ep_state = ep_ptr->param.ep_state;
 		ep_ptr->param.ep_state = DAT_EP_STATE_UNCONNECTED;
-		cr_ptr->param.local_ep_handle = NULL;
+		cr_ptr->param.local_ep = NULL;
 	}
 
 	dat_status = dapl_ib_reject_connection(cr_ptr->ib_cm_handle);
@@ -77,8 +77,8 @@ u32 dapl_cr_reject(DAT_CR_HANDLE cr_hand
 		if (ep_ptr != NULL) {
 			/* Revert our state to the beginning */
 			ep_ptr->param.ep_state = entry_ep_state;
-			cr_ptr->param.local_ep_handle = entry_ep_handle;
-			cr_ptr->param.local_ep_handle = (DAT_EP_HANDLE) ep_ptr;
+			cr_ptr->param.local_ep = entry_ep;
+			cr_ptr->param.local_ep = (struct dat_ep *)ep_ptr;
 		}
 	} else {
 		/* 
@@ -88,13 +88,13 @@ u32 dapl_cr_reject(DAT_CR_HANDLE cr_hand
 		 */
 		sp_ptr = cr_ptr->sp_ptr;
 		if (ep_ptr && sp_ptr->psp_flags == DAT_PSP_PROVIDER_FLAG)
-			(void)dapl_ep_free(ep_ptr);
+			(void)dapl_ep_free((struct dat_ep *)ep_ptr);
 
 		/* Remove the CR from the queue, then free it */
-		spin_lock_irqsave(&sp_ptr->header.lock, sp_ptr->header.flags);
+		spin_lock_irqsave(&sp_ptr->common.lock, sp_ptr->common.flags);
 		dapl_sp_remove_cr(sp_ptr, cr_ptr);
-		spin_unlock_irqrestore(&sp_ptr->header.lock,
-				       sp_ptr->header.flags);
+		spin_unlock_irqrestore(&sp_ptr->common.lock,
+				       sp_ptr->common.flags);
 
 		dapl_cr_free(cr_ptr);
 	}
Index: linux-kernel/dat-provider/dapl_srq.c
===================================================================
--- linux-kernel/dat-provider/dapl_srq.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_srq.c	(working copy)
@@ -51,13 +51,9 @@
  */
 static void dapl_srq_dealloc(struct dapl_srq *srq_ptr)
 {
-	dapl_os_assert(srq_ptr->header.magic == DAPL_MAGIC_SRQ);
-
-	/* reset magic to prevent reuse */
-	srq_ptr->header.magic = DAPL_MAGIC_INVALID;
-	dapl_ia_unlink_srq(srq_ptr->header.owner_ia, srq_ptr);
+	dapl_ia_unlink_srq(srq_ptr->common.owner_ia, srq_ptr);
 	dapl_cb_free(&srq_ptr->recv_buffer);
-	/* no need to destroy srq_ptr->header.lock */
+	/* no need to destroy srq_ptr->common.lock */
 
 	kfree(srq_ptr);
 }
@@ -91,19 +87,14 @@ static struct dapl_srq *dapl_srq_alloc(s
 	/* zero the structure */
 	memset(srq_ptr, 0, sizeof *srq_ptr);
 
-	/*
-	 * initialize the header
-	 */
-	srq_ptr->header.provider = ia_ptr->header.provider;
-	srq_ptr->header.magic = DAPL_MAGIC_SRQ;
-	srq_ptr->header.handle_type = DAT_HANDLE_TYPE_SRQ;
-	srq_ptr->header.owner_ia = ia_ptr;
-	srq_ptr->header.user_context.as_64 = 0;
-	srq_ptr->header.user_context.as_ptr = NULL;
+	srq_ptr->srq.provider = ia_ptr->ia.provider;
+	srq_ptr->common.owner_ia = ia_ptr;
+	srq_ptr->common.user_context.as_64 = 0;
+	srq_ptr->common.user_context.as_ptr = NULL;
 	atomic_set(&srq_ptr->srq_ref_count, 0);
 
-	dapl_llist_init_entry(&srq_ptr->header.ia_list_entry);
-	spin_lock_init(&srq_ptr->header.lock);
+	dapl_llist_init_entry(&srq_ptr->common.ia_list_entry);
+	spin_lock_init(&srq_ptr->common.lock);
 
 	/*
 	 * Initialize the body. 
@@ -130,15 +121,15 @@ bail:
  * dapl_srq_create
  *
  * Create an instance of a Shared Receive Queue that is provided to the
- * consumer at srq_handle.
+ * consumer at srq.
  *
  * Input:
- *	ia_handle
- *	pz_handle
+ *	ia
+ *	pz
  *	srq_attr
  *
  * Output:
- *	srq_handle
+ *	srq
  *
  * Returns:
  *	DAT_SUCCESS
@@ -148,8 +139,8 @@ bail:
  *	?DAT_INVALID_ATTRIBUTE??
  *	DAT_MODEL_NOT_SUPPORTED
  */
-u32 dapl_srq_create(DAT_IA_HANDLE ia_handle, DAT_PZ_HANDLE pz_handle,
-		    struct dat_srq_attr *srq_attr, DAT_SRQ_HANDLE *srq_handle)
+u32 dapl_srq_create(struct dat_ia *ia, struct dat_pz *pz,
+		    struct dat_srq_attr *srq_attr, struct dat_srq **srq)
 {
 	struct dapl_ia *ia_ptr;
 	struct dapl_srq *srq_ptr;
@@ -157,14 +148,14 @@ u32 dapl_srq_create(DAT_IA_HANDLE ia_han
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API,
 		     "dapl_srq_create (%p, %p, %p, %p)\n",
-		     ia_handle, pz_handle, srq_attr, srq_handle);
+		     ia, pz, srq_attr, srq);
 
-	ia_ptr = (struct dapl_ia *)ia_handle;
+	ia_ptr = (struct dapl_ia *)ia;
 
 	/*
 	 * Verify parameters
 	 */
-	if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
+	if (!ia_ptr) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
 		goto bail;
 	}
@@ -175,12 +166,7 @@ u32 dapl_srq_create(DAT_IA_HANDLE ia_han
 	 *      modified by dat_ep_modify() is not strictly
 	 *      required when the EP is created
 	 */
-	if (pz_handle != NULL && DAPL_BAD_HANDLE(pz_handle, DAPL_MAGIC_PZ)) {
-		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ);
-		goto bail;
-	}
-
-	if (srq_handle == NULL) {
+	if (srq == NULL) {
 		status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG4);
 		goto bail;
 	}
@@ -197,9 +183,9 @@ u32 dapl_srq_create(DAT_IA_HANDLE ia_han
 		goto bail;
 	}
 
-	srq_ptr->param.ia_handle = (DAT_IA_HANDLE) ia_ptr;
+	srq_ptr->param.ia = (struct dat_ia *) ia_ptr;
 	srq_ptr->param.srq_state = DAT_SRQ_STATE_OPERATIONAL;
-	srq_ptr->param.pz_handle = pz_handle;
+	srq_ptr->param.pz = pz;
 
 	/*
 	 * XXX Allocate provider resource here!!!
@@ -211,7 +197,7 @@ u32 dapl_srq_create(DAT_IA_HANDLE ia_han
 	/* Link it onto the IA */
 	dapl_ia_link_srq(ia_ptr, srq_ptr);
 
-	*srq_handle = srq_ptr;
+	*srq = (struct dat_srq *)srq_ptr;
 
 bail:
 	return status;
@@ -223,7 +209,7 @@ bail:
  * Destroy an instance of an SRQ
  *
  * Input:
- *	srq_handle
+ *	srq
  *
  * Output:
  *	none
@@ -233,22 +219,22 @@ bail:
  *	DAT_INVALID_PARAMETER
  *	DAT_INVALID_STATE
  */
-u32 dapl_srq_free(DAT_SRQ_HANDLE srq_handle)
+u32 dapl_srq_free(struct dat_srq *srq)
 {
 	struct dapl_srq *srq_ptr;
 	struct dapl_ia *ia_ptr;
 	struct dat_srq_param *param;
 	u32 status = DAT_SUCCESS;
 
-	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_srq_free (%p)\n", srq_handle);
+	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_srq_free (%p)\n", srq);
 
-	srq_ptr = (struct dapl_srq *)srq_handle;
+	srq_ptr = (struct dapl_srq *)srq;
 	param = &srq_ptr->param;
 
 	/*
 	 * Verify parameter & state
 	 */
-	if (DAPL_BAD_HANDLE(srq_ptr, DAPL_MAGIC_SRQ)) {
+	if (!srq_ptr) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ);
 		goto bail;
 	}
@@ -263,17 +249,17 @@ u32 dapl_srq_free(DAT_SRQ_HANDLE srq_han
 		goto bail;
 	}
 
-	ia_ptr = srq_ptr->header.owner_ia;
+	ia_ptr = srq_ptr->common.owner_ia;
 
 	/*
 	 * Do verification of parameters and the state change atomically.
 	 */
-	spin_lock_irqsave(&srq_ptr->header.lock, srq_ptr->header.flags);
+	spin_lock_irqsave(&srq_ptr->common.lock, srq_ptr->common.flags);
 
 	/* Remove the SRQ from the IA */
 	dapl_ia_unlink_srq(ia_ptr, srq_ptr);
 
-	spin_unlock_irqrestore(&srq_ptr->header.lock, srq_ptr->header.flags);
+	spin_unlock_irqrestore(&srq_ptr->common.lock, srq_ptr->common.flags);
 
 	/*
 	 * Finish tearing everything down.
@@ -301,7 +287,7 @@ bail:
  * over a connection of any ep handle into local_iov
  *
  * Input:
- * 	srq_handle
+ * 	srq
  * 	num_segments
  * 	local_iov
  * 	user_cookie
@@ -318,7 +304,7 @@ bail:
  * 	DAT_PROTECTION_VIOLATION
  * 	DAT_PROVILEGES_VIOLATION
  */
-u32 dapl_srq_post_recv(DAT_SRQ_HANDLE srq_handle, int num_segments,
+u32 dapl_srq_post_recv(struct dat_srq *srq, int num_segments,
 		       struct dat_lmr_triplet *local_iov,
 		       DAT_DTO_COOKIE user_cookie)
 {
@@ -328,14 +314,14 @@ u32 dapl_srq_post_recv(DAT_SRQ_HANDLE sr
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API,
 		     "dapl_srq_post_recv (%p, %d, %p, %P)\n",
-		     srq_handle, num_segments, local_iov, user_cookie.as_64);
+		     srq, num_segments, local_iov, user_cookie.as_64);
 
-	if (DAPL_BAD_HANDLE(srq_handle, DAPL_MAGIC_SRQ)) {
+	if (!srq) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ);
 		goto bail;
 	}
 
-	srq_ptr = (struct dapl_srq *)srq_handle;
+	srq_ptr = (struct dapl_srq *)srq;
 
 	/*
 	 * Synchronization ok since this buffer is only used for receive
@@ -369,16 +355,15 @@ bail:
 	return status;
 }
 
-u32 dapl_srq_query(DAT_SRQ_HANDLE srq_handle, struct dat_srq_param *srq_param)
+u32 dapl_srq_query(struct dat_srq *srq, struct dat_srq_param *srq_param)
 {
 	struct dapl_srq *srq_ptr;
 	u32 status = DAT_SUCCESS;
 
-	dapl_dbg_log(DAPL_DBG_TYPE_API,
-		     "dapl_srq_query (%p, %x, %p)\n",
-		     srq_handle, srq_param);
+	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_srq_query (%p, %x, %p)\n", srq,
+		     srq_param);
 
-	if (DAPL_BAD_HANDLE(srq_handle, DAPL_MAGIC_SRQ)) {
+	if (!srq) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ);
 		goto bail;
 	}
@@ -387,7 +372,7 @@ u32 dapl_srq_query(DAT_SRQ_HANDLE srq_ha
 		goto bail;
 	}
 
-	srq_ptr = (struct dapl_srq *)srq_handle;
+	srq_ptr = (struct dapl_srq *)srq;
 
 	/*
 	 * XXX Need to calculate available_dto_count and outstanding_dto_count
@@ -407,7 +392,7 @@ bail:
  * Modify the size fo the event queue of a Shared Recieve Queue
  *
  * Input:
- * 	srq_handle
+ * 	srq
  * 	srq_max_recv_dto
  *
  * Output:
@@ -421,22 +406,22 @@ bail:
  * 	DAT_INVALID_STATE
  */
 
-u32 dapl_srq_resize(DAT_SRQ_HANDLE srq_handle, int srq_max_recv_dto)
+u32 dapl_srq_resize(struct dat_srq *srq, int srq_max_recv_dto)
 {
 	struct dapl_ia *ia_ptr;
 	struct dapl_srq *srq_ptr;
 	u32 status = DAT_SUCCESS;
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_srq_resize (%p, %d)\n",
-		     srq_handle, srq_max_recv_dto);
+		     srq, srq_max_recv_dto);
 
-	if (DAPL_BAD_HANDLE(srq_handle, DAPL_MAGIC_SRQ)) {
+	if (!srq) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ);
 		goto bail;
 	}
 
-	srq_ptr = (struct dapl_srq *)srq_handle;
-	ia_ptr = srq_ptr->header.owner_ia;
+	srq_ptr = (struct dapl_srq *)srq;
+	ia_ptr = srq_ptr->common.owner_ia;
 
 	/*
 	 * Check for nonsense requests per the spec
@@ -463,7 +448,7 @@ bail:
  * event if it is reached.
  *
  * Input:
- * 	srq_handle
+ * 	srq
  * 	srq_max_recv_dto
  *
  * Output:
@@ -476,20 +461,20 @@ bail:
  * 	DAT_MODEL_NOT_SUPPORTED
  */
 
-u32 dapl_srq_set_lw(DAT_SRQ_HANDLE srq_handle, int low_watermark)
+u32 dapl_srq_set_lw(struct dat_srq *srq, int low_watermark)
 {
 	struct dapl_srq *srq_ptr;
 	u32 status = DAT_SUCCESS;
 
-	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_srq_set_lw (%p, %d)\n",
-		     srq_handle, low_watermark);
+	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_srq_set_lw (%p, %d)\n", srq,
+		     low_watermark);
 
-	if (DAPL_BAD_HANDLE(srq_handle, DAPL_MAGIC_SRQ)) {
+	if (!srq) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ);
 		goto bail;
 	}
 
-	srq_ptr = (struct dapl_srq *)srq_handle;
+	srq_ptr = (struct dapl_srq *)srq;
 
 	/* XXX Put implementation here XXX */
 
Index: linux-kernel/dat-provider/dapl_openib_util.c
===================================================================
--- linux-kernel/dat-provider/dapl_openib_util.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_openib_util.c	(working copy)
@@ -171,7 +171,7 @@ u32 dapl_ib_close_hca(struct dapl_hca *h
  * Alloc a CQ
  *
  * Input:
- *	ia_handle		IA handle
+ *	ia		IA handle
  *	evd_ptr 		pointer to EVD struct
  *	cqlen			minimum QLen
  *
@@ -227,7 +227,7 @@ u32 dapl_ib_cq_resize(struct dapl_ia *ia
  * Set up CQ completion notifications
  *
  * Input:
- *	ia_handle		IA handle
+ *	ia		IA handle
  *	evd_ptr 		pointer to EVD struct
  *
  * Output:
@@ -253,7 +253,7 @@ u32 dapl_set_cq_notify(struct dapl_ia *i
  * Register a virtual memory region
  *
  * Input:
- *	ia_handle		IA handle
+ *	ia		IA handle
  *	lmr			pointer to dapl_lmr struct
  *	virt_addr		virtual address of beginning of mem region
  *	length			length of memory region
@@ -300,7 +300,7 @@ u32 dapl_ib_mr_register_physical(struct 
 	iova = buf_list[0].addr;
 	acl = dapl_ib_convert_mem_privileges(privileges);
 	acl |= IB_ACCESS_MW_BIND;
-	mr = ib_reg_phys_mr(((struct dapl_pz *)lmr->param.pz_handle)->pd,
+	mr = ib_reg_phys_mr(((struct dapl_pz *)lmr->param.pz)->pd,
 			    buf_list, length, acl, &iova);
 	kfree(buf_list);
 	if (IS_ERR(mr)) {
@@ -393,7 +393,7 @@ u32 dapl_ib_mw_alloc(struct dapl_rmr *rm
 	int ib_status;
 	struct ib_mw *mw;
 
-	mw = ib_alloc_mw(((struct dapl_pz *)rmr->param.pz_handle)->pd);
+	mw = ib_alloc_mw(((struct dapl_pz *)rmr->param.pz)->pd);
 	if (IS_ERR(mw)) {
 		ib_status = PTR_ERR(mw);
 		dapl_dbg_log(DAPL_DBG_TYPE_ERR,
@@ -540,7 +540,7 @@ u32 dapl_ib_mw_unbind(struct dapl_rmr *r
  * Set up an asynchronous callbacks of various kinds
  *
  * Input:
- *	ia_handle		IA handle
+ *	ia		IA handle
  *	handler_type		type of handler to set up
  *	callback_handle 	handle param for completion callbacks
  *	callback		callback routine pointer
Index: linux-kernel/dat-provider/dapl_ia_memtype_hint.c
===================================================================
--- linux-kernel/dat-provider/dapl_ia_memtype_hint.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_ia_memtype_hint.c	(working copy)
@@ -37,7 +37,7 @@
  * Provide a hint about optimal memory alignment and size
  *
  * Input:
- *	ia_handle,
+ *	ia,
  *	mem_type,
  *	length,
  *	mem_optimization,
@@ -53,7 +53,7 @@
  * 	DAT_INVALID_HANDLE
  * 	DAT_MODEL_NOT_SUPPORTED
  */
-u32 dapl_ia_memtype_hint(DAT_IA_HANDLE ia_handle, enum dat_mem_type mem_type,
+u32 dapl_ia_memtype_hint(struct dat_ia *ia, enum dat_mem_type mem_type,
 			 u64 length,
 			 enum dat_mem_optimize_flags mem_optimization,
 			 u64 *suggested_length,
@@ -63,11 +63,11 @@ u32 dapl_ia_memtype_hint(DAT_IA_HANDLE i
 	u32 dat_status = DAT_SUCCESS;
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_ia_memtype_hint (%p)\n",
-		     ia_handle);
+		     ia);
 
-	ia_ptr = (struct dapl_ia *)ia_handle;
+	ia_ptr = (struct dapl_ia *)ia;
 
-	if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
+	if (!ia_ptr) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
 		goto bail;
Index: linux-kernel/dat-provider/dapl_openib_qp.c
===================================================================
--- linux-kernel/dat-provider/dapl_openib_qp.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_openib_qp.c	(working copy)
@@ -74,17 +74,17 @@ u32 dapl_ib_qp_alloc(struct dapl_ia *ia_
 
 	attr = &ep_ptr->param.ep_attr;
 
-	dapl_os_assert(ep_ptr->param.pz_handle != NULL);
-	ib_pd_handle = ((struct dapl_pz *)ep_ptr->param.pz_handle)->pd;
+	dapl_os_assert(ep_ptr->param.pz != NULL);
+	ib_pd_handle = ((struct dapl_pz *)ep_ptr->param.pz)->pd;
 	ib_hca_handle = ia_ptr->hca_ptr->ib_hca_handle;
 
 	cq_recv = NULL;
 	cq_send = NULL;
 	cq_recv = dapl_get_dto_cq(ia_ptr,
-				  (struct dapl_evd *)ep_ptr->param.recv_evd_handle);
+				  (struct dapl_evd *)ep_ptr->param.recv_evd);
 	cq_send = dapl_get_dto_cq(ia_ptr,
 				  (struct dapl_evd *)ep_ptr->param.
-				  request_evd_handle);
+				  request_evd);
 
 	qp_attr.send_cq = cq_send;
 	qp_attr.recv_cq = cq_recv;
@@ -160,7 +160,7 @@ struct ib_cq *dapl_get_dto_cq(struct dap
 	int cq_entries;
 	int status;
 
-	if (evd_ptr != DAT_HANDLE_NULL)
+	if (evd_ptr != NULL)
 		cq = evd_ptr->cq;
 	else if (ia_ptr->hca_ptr->null_cq != NULL)
 		cq = ia_ptr->hca_ptr->null_cq;
Index: linux-kernel/dat-provider/dapl_openib_util.h
===================================================================
--- linux-kernel/dat-provider/dapl_openib_util.h	(revision 2572)
+++ linux-kernel/dat-provider/dapl_openib_util.h	(working copy)
@@ -59,7 +59,7 @@ u32 dapl_ib_qp_free(struct dapl_ep *ep_p
 u32 dapl_ib_qp_modify(struct dapl_ia *ia_ptr, struct dapl_ep *ep_ptr,
 		      struct dat_ep_attr *ep_attr);
 
-u32 dapl_ib_connect(DAT_EP_HANDLE ep_handle,
+u32 dapl_ib_connect(struct dat_ep *ep,
 		    struct sockaddr *remote_ia_address,
 		    DAT_CONN_QUAL remote_conn_qual, unsigned long timeout,
 		    int private_data_size, void *private_data);
@@ -70,12 +70,12 @@ u32 dapl_ib_setup_conn_listener(struct d
 
 u32 dapl_ib_remove_conn_listener(struct dapl_ia *ia_ptr, struct dapl_sp *sp_ptr);
 
-u32 dapl_ib_accept_connection(DAT_CR_HANDLE cr_handle,
-			      DAT_EP_HANDLE ep_handle,
+u32 dapl_ib_accept_connection(struct dat_cr *cr,
+			      struct dat_ep *ep,
 			      int private_data_size,
 			      const void *private_data);
 
-u32 dapl_ib_reject_connection(struct dapl_cm_id *cm_handle);
+u32 dapl_ib_reject_connection(struct dapl_cm_id *cm);
 
 u32 dapl_ib_setup_async_callback(struct dapl_ia *ia_ptr,
 				 DAPL_ASYNC_HANDLER_TYPE handler_type,
@@ -126,14 +126,14 @@ u32 dapl_ib_completion_notify(struct dap
 
 enum dat_dto_completion_status dapl_ib_get_dto_status(struct ib_wc *cqe_ptr);
 
-void dapl_ib_reinit_ep(struct dapl_ep * ep_ptr);
+void dapl_ib_reinit_ep(struct dapl_ep *ep_ptr);
 
-void dapl_ib_disconnect_clean(struct dapl_ep * ep_ptr, boolean_t passive);
+void dapl_ib_disconnect_clean(struct dapl_ep *ep_ptr, boolean_t passive);
 
 u32 dapl_ib_get_async_event(struct ib_event *cause_ptr,
 			    enum dat_event_number *async_event);
 
-u32 dapl_ib_cm_remote_addr(DAT_HANDLE dat_handle,
+u32 dapl_ib_cm_remote_addr(void *dat_handle,
 			   struct sockaddr_in6 *remote_ia_address);
 
 static inline u32 dapl_ib_status_convert(int32_t ib_status)
Index: linux-kernel/dat-provider/dapl_ia_close.c
===================================================================
--- linux-kernel/dat-provider/dapl_ia_close.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_ia_close.c	(working copy)
@@ -40,7 +40,7 @@
  * Close a provider, clean up resources, etc.
  *
  * Input:
- *	ia_handle
+ *	ia
  *
  * Output:
  *	none
@@ -50,30 +50,29 @@
  * 	DAT_INSUFFICIENT_RESOURCES
  * 	DAT_INVALID_PARAMETER
  */
-u32 dapl_ia_close(DAT_IA_HANDLE ia_handle, enum dat_close_flags ia_flags)
+u32 dapl_ia_close(struct dat_ia *ia, enum dat_close_flags ia_flags)
 {
 	struct dapl_ia *ia_ptr;
 	u32 dat_status;
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API,
-		     "dapl_ia_close (%p, %d)\n", ia_handle, ia_flags);
+		     "dapl_ia_close (%p, %d)\n", ia, ia_flags);
 
-	ia_ptr = (struct dapl_ia *)ia_handle;
+	ia_ptr = (struct dapl_ia *)ia;
 
-	if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
+	if (!ia_ptr) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
 		goto bail;
 	}
 
-	if (DAT_CLOSE_ABRUPT_FLAG == ia_flags) {
+	if (DAT_CLOSE_ABRUPT_FLAG == ia_flags)
 		dat_status = dapl_ia_abrupt_close(ia_ptr);
-	} else if (DAT_CLOSE_GRACEFUL_FLAG == ia_flags) {
+	else if (DAT_CLOSE_GRACEFUL_FLAG == ia_flags)
 		dat_status = dapl_ia_graceful_close(ia_ptr);
-	} else {
+	else
 		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG2);
-	}
 
-      bail:
+bail:
 	return dat_status;
 }
Index: linux-kernel/dat-provider/dapl_cr_callback.c
===================================================================
--- linux-kernel/dat-provider/dapl_cr_callback.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_cr_callback.c	(working copy)
@@ -50,9 +50,9 @@ static u32 dapl_connection_request(struc
 	struct dapl_cr *cr_ptr;
 	struct dapl_ep *ep_ptr;
 	struct dapl_ia *ia_ptr;
-	DAT_SP_HANDLE sp_handle;
+	struct dat_sp *sp;
 
-	cr_ptr = dapl_cr_alloc(sp_ptr->header.owner_ia);
+	cr_ptr = dapl_cr_alloc(sp_ptr->common.owner_ia);
 	if (cr_ptr == NULL) {
 		/* Invoking function will call dapl_ib_cm_reject() */
 		return DAT_INSUFFICIENT_RESOURCES;
@@ -79,7 +79,7 @@ static u32 dapl_connection_request(struc
 	}
 
 	/* EP will be NULL unless RSP service point */
-	ep_ptr = (struct dapl_ep *)sp_ptr->ep_handle;
+	ep_ptr = (struct dapl_ep *)sp_ptr->ep;
 
 	if (sp_ptr->psp_flags == DAT_PSP_PROVIDER_FLAG) {
 		/*
@@ -89,7 +89,7 @@ static u32 dapl_connection_request(struc
 		 * EP we are out of resources and need to tell the
 		 * requestor that we cant help them.
 		 */
-		ia_ptr = sp_ptr->header.owner_ia;
+		ia_ptr = sp_ptr->common.owner_ia;
 		ep_ptr = dapl_ep_alloc(ia_ptr, NULL);
 		if (ep_ptr == NULL) {
 			dapl_cr_free(cr_ptr);
@@ -100,7 +100,7 @@ static u32 dapl_connection_request(struc
 		dapl_ia_link_ep(ia_ptr, ep_ptr);
 	}
 
-	cr_ptr->param.local_ep_handle = ep_ptr;
+	cr_ptr->param.local_ep = (struct dat_ep *)ep_ptr;
 
 	if (ep_ptr != NULL) {
 		/* Assign valid EP fields: RSP and PSP_PROVIDER_FLAG only */
@@ -109,12 +109,11 @@ static u32 dapl_connection_request(struc
 			    DAT_EP_STATE_TENTATIVE_CONNECTION_PENDING;
 		} else {
 			/* RSP */
-			dapl_os_assert(sp_ptr->header.handle_type ==
-				       DAT_HANDLE_TYPE_RSP);
+			dapl_os_assert(sp_ptr->sp.type == DAT_SP_TYPE_RSP);
 			ep_ptr->param.ep_state =
 			    DAT_EP_STATE_PASSIVE_CONNECTION_PENDING;
 		}
-		ep_ptr->cm_handle = ib_cm_handle;
+		ep_ptr->cm = ib_cm_handle;
 	}
 
 	/* link the CR onto the SP so we can pick it up later */
@@ -122,16 +121,16 @@ static u32 dapl_connection_request(struc
 
 	/* Post the event.  */
 	/* assign sp_ptr to union to avoid typecast errors from some compilers */
-	sp_handle.psp_handle = (DAT_PSP_HANDLE) sp_ptr;
-	dat_status = dapl_evd_post_cr_arrival_event(evd_ptr, sp_handle,
-		(struct sockaddr *) &sp_ptr->header.owner_ia->hca_ptr->hca_address,
-		sp_ptr->conn_qual, (DAT_CR_HANDLE) cr_ptr);
+	sp = (struct dat_sp *)sp_ptr;
+	dat_status = dapl_evd_post_cr_arrival_event(evd_ptr, sp,
+		(struct sockaddr *)&sp_ptr->common.owner_ia->hca_ptr->hca_address,
+		sp_ptr->conn_qual, (struct dat_cr *)cr_ptr);
 	if (dat_status != DAT_SUCCESS) {
 		/* Take the CR off the list, we can't use it */
-		spin_lock_irqsave(&sp_ptr->header.lock, sp_ptr->header.flags);
+		spin_lock_irqsave(&sp_ptr->common.lock, sp_ptr->common.flags);
 		dapl_sp_remove_cr(sp_ptr, cr_ptr);
-		spin_unlock_irqrestore(&sp_ptr->header.lock, 
-				       sp_ptr->header.flags);
+		spin_unlock_irqrestore(&sp_ptr->common.lock, 
+				       sp_ptr->common.flags);
 
 		dapl_cr_free(cr_ptr);
 		(void)dapl_ib_reject_connection(ib_cm_handle);
@@ -157,13 +156,7 @@ struct dapl_ep *dapl_get_sp_ep(struct da
 	/*
 	 * acquire the lock, we may be racing with other threads here
 	 */
-	spin_lock_irqsave(&sp_ptr->header.lock, sp_ptr->header.flags);
-	/* Verify under lock that the SP is still valid */
-	if (sp_ptr->header.magic == DAPL_MAGIC_INVALID) {
-		spin_unlock_irqrestore(&sp_ptr->header.lock, 
-				       sp_ptr->header.flags);
-		return NULL;
-	}
+	spin_lock_irqsave(&sp_ptr->common.lock, sp_ptr->common.flags);
 	/*
 	 * There are potentially multiple connections in progress. Need to
 	 * go through the list and find the one we are interested
@@ -172,16 +165,12 @@ struct dapl_ep *dapl_get_sp_ep(struct da
 	 */
 	cr_ptr = dapl_sp_search_cr(sp_ptr, ib_cm_handle);
 	if (cr_ptr == NULL) {
-		spin_unlock_irqrestore(&sp_ptr->header.lock,
-				       sp_ptr->header.flags);
+		spin_unlock_irqrestore(&sp_ptr->common.lock,
+				       sp_ptr->common.flags);
 		return NULL;
 	}
 
-	ep_ptr = (struct dapl_ep *)cr_ptr->param.local_ep_handle;
-
-	/* Quick check to ensure our EP is still valid */
-	if (DAPL_BAD_HANDLE(ep_ptr, DAPL_MAGIC_EP))
-		ep_ptr = NULL;
+	ep_ptr = (struct dapl_ep *)cr_ptr->param.local_ep;
 
 	/* The CR record is discarded in all except for the CONNECTED case,
 	 * as it will have no further relevance.
@@ -211,31 +200,31 @@ struct dapl_ep *dapl_get_sp_ep(struct da
 				     "dapl_get_sp_ep disconnect dump sp: %p \n",
 				     sp_ptr);
 			/* Decrement the ref count on the EVD */
-			if (sp_ptr->evd_handle) {
+			if (sp_ptr->evd) {
 				atomic_dec(&((struct dapl_evd *)sp_ptr->
-						    evd_handle)->evd_ref_count);
-				sp_ptr->evd_handle = NULL;
+						    evd)->evd_ref_count);
+				sp_ptr->evd = NULL;
 			}
 			sp_ptr->state = DAPL_SP_STATE_FREE;
-			spin_unlock_irqrestore(&sp_ptr->header.lock,
-					       sp_ptr->header.flags);
-			(void)dapl_ib_remove_conn_listener(sp_ptr->header.
+			spin_unlock_irqrestore(&sp_ptr->common.lock,
+					       sp_ptr->common.flags);
+			(void)dapl_ib_remove_conn_listener(sp_ptr->common.
 							   owner_ia, sp_ptr);
 			dapl_ia_unlink_sp((struct dapl_ia *)
-						sp_ptr->header.owner_ia,
+						sp_ptr->common.owner_ia,
 					  sp_ptr);
 			dapl_sp_dealloc(sp_ptr);
 			dapl_cr_free(cr_ptr);
 			goto skip_unlock;
 		}
 
-		spin_unlock_irqrestore(&sp_ptr->header.lock,
-				       sp_ptr->header.flags);
+		spin_unlock_irqrestore(&sp_ptr->common.lock,
+				       sp_ptr->common.flags);
 		/* free memory outside of the lock */
 		dapl_cr_free(cr_ptr);
 	} else 
-		spin_unlock_irqrestore(&sp_ptr->header.lock,
-				       sp_ptr->header.flags);
+		spin_unlock_irqrestore(&sp_ptr->common.lock,
+				       sp_ptr->common.flags);
 
 skip_unlock:
 	return ep_ptr;
@@ -255,16 +244,6 @@ void dapl_cr_callback(struct dapl_cm_id 
 		     ib_cm_handle, event, sp_ptr);
 
 	/*
-	 * The SP pointer could have been cleaned up in a racing
-	 * CM callback, check to see if we should just exit here
-	 */
-	if (sp_ptr->header.magic == DAPL_MAGIC_INVALID) {
-		return;
-	}
-	dapl_os_assert(sp_ptr->header.magic == DAPL_MAGIC_PSP ||
-		       sp_ptr->header.magic == DAPL_MAGIC_RSP);
-
-	/*
 	 * CONNECT_REQUEST events create an event on the PSP
 	 * EVD, which will trigger connection processing. The
 	 * sequence is:
@@ -277,7 +256,7 @@ void dapl_cr_callback(struct dapl_cm_id 
 	 */
 	if (event == DAT_CONNECTION_REQUEST_EVENT) {
 		ep_ptr = NULL;
-		evd_ptr = sp_ptr->evd_handle;
+		evd_ptr = (struct dapl_evd *)sp_ptr->evd;
 	} else {
 		/* see if there is an EP connected with this CM handle */
 		ep_ptr = dapl_get_sp_ep(ib_cm_handle, sp_ptr, event);
@@ -286,7 +265,7 @@ void dapl_cr_callback(struct dapl_cm_id 
 		if (ep_ptr == NULL)
 			return;
 
-		evd_ptr = (struct dapl_evd *)ep_ptr->param.connect_evd_handle;
+		evd_ptr = (struct dapl_evd *)ep_ptr->param.connect_evd;
 		/* if something has happened to our EVD, bail. */
 		if (evd_ptr == NULL)
 			return;
@@ -296,30 +275,29 @@ void dapl_cr_callback(struct dapl_cm_id 
 
 	switch (event) {
 	case DAT_CONNECTION_REQUEST_EVENT:
-	{
 		/*
 		 * Requests arriving on a disabled SP are immediately rejected
 		 */
 
-		spin_lock_irqsave(&sp_ptr->header.lock, sp_ptr->header.flags);
+		spin_lock_irqsave(&sp_ptr->common.lock, sp_ptr->common.flags);
 		if (sp_ptr->listening == FALSE) {
-			spin_unlock_irqrestore(&sp_ptr->header.lock,
-					       sp_ptr->header.flags);
+			spin_unlock_irqrestore(&sp_ptr->common.lock,
+					       sp_ptr->common.flags);
 			dapl_dbg_log(DAPL_DBG_TYPE_CM,
 				     "---> dapl_cr_callback: conn event on down SP\n");
 			(void)dapl_ib_reject_connection(ib_cm_handle);
 			return;
 		}
 
-		if (sp_ptr->header.handle_type == DAT_HANDLE_TYPE_RSP) {
+		if (sp_ptr->sp.type == DAT_SP_TYPE_RSP) {
 			/*
 			 * RSP connections only allow a single connection. Close
 			 * it down NOW so we reject any further connections.
 			 */
 			sp_ptr->listening = FALSE;
 		}
-		spin_unlock_irqrestore(&sp_ptr->header.lock, 
-				       sp_ptr->header.flags);
+		spin_unlock_irqrestore(&sp_ptr->common.lock, 
+				       sp_ptr->common.flags);
 
 		/*
 		 * Only occurs on the passive side of a connection
@@ -332,24 +310,20 @@ void dapl_cr_callback(struct dapl_cm_id 
 		evd_ptr = NULL;
 
 		break;
-	}
 	case DAT_CONNECTION_EVENT_ESTABLISHED:
-	{
 		/* This is just a notification the connection is now
 		 * established, there isn't any private data to deal with.
 		 *
 		 * Update the EP state and cache a copy of the cm handle,
 		 * then let the user know we are ready to go.
 		 */
-		spin_lock_irqsave(&ep_ptr->header.lock, ep_ptr->header.flags);
-		if (ep_ptr->header.magic != DAPL_MAGIC_EP ||
-		    ep_ptr->param.ep_state !=
-		    DAT_EP_STATE_COMPLETION_PENDING) {
+		spin_lock_irqsave(&ep_ptr->common.lock, ep_ptr->common.flags);
+		if (ep_ptr->param.ep_state != DAT_EP_STATE_COMPLETION_PENDING) {
 			/* If someone pulled the plug on the EP or connection,
 			 * just exit
 			 */
-			spin_unlock_irqrestore(&ep_ptr->header.lock, 
-					       ep_ptr->header.flags);
+			spin_unlock_irqrestore(&ep_ptr->common.lock, 
+					       ep_ptr->common.flags);
 			dat_status = DAT_SUCCESS;
 			/* Set evd_ptr = NULL so we don't generate an event below */
 			evd_ptr = NULL;
@@ -358,72 +332,63 @@ void dapl_cr_callback(struct dapl_cm_id 
 		}
 
 		ep_ptr->param.ep_state = DAT_EP_STATE_CONNECTED;
-		ep_ptr->cm_handle = ib_cm_handle;
-		spin_unlock_irqrestore(&ep_ptr->header.lock, 
-				       ep_ptr->header.flags);
+		ep_ptr->cm = ib_cm_handle;
+		spin_unlock_irqrestore(&ep_ptr->common.lock, 
+				       ep_ptr->common.flags);
 
 		break;
-	}
 	case DAT_CONNECTION_EVENT_DISCONNECTED:
-	{
 		/*
 		 * EP is now fully disconnected; initiate any post processing
 		 * to reset the underlying QP and get the EP ready for
 		 * another connection
 		 */
-		spin_lock_irqsave(&ep_ptr->header.lock, ep_ptr->header.flags);
+		spin_lock_irqsave(&ep_ptr->common.lock, ep_ptr->common.flags);
 		if (ep_ptr->param.ep_state == DAT_EP_STATE_DISCONNECTED) {
 			/* The disconnect has already occurred, we are now
 			 * cleaned up and ready to exit
 			 */
-			spin_unlock_irqrestore(&ep_ptr->header.lock, 
-					       ep_ptr->header.flags);
+			spin_unlock_irqrestore(&ep_ptr->common.lock, 
+					       ep_ptr->common.flags);
 			return;
 		}
 		ep_ptr->param.ep_state = DAT_EP_STATE_DISCONNECTED;
 		dapl_ib_disconnect_clean(ep_ptr, FALSE);
-		spin_unlock_irqrestore(&ep_ptr->header.lock, 
-				       ep_ptr->header.flags);
+		spin_unlock_irqrestore(&ep_ptr->common.lock, 
+				       ep_ptr->common.flags);
 
 		break;
-	}
 	case DAT_CONNECTION_EVENT_NON_PEER_REJECTED:
 	case DAT_CONNECTION_EVENT_PEER_REJECTED:
 	case DAT_CONNECTION_EVENT_UNREACHABLE:
-	{
 		/*
 		 * After posting an accept the requesting node has
 		 * stopped talking.
 		 */
-		spin_lock_irqsave(&ep_ptr->header.lock, ep_ptr->header.flags);
+		spin_lock_irqsave(&ep_ptr->common.lock, ep_ptr->common.flags);
 		ep_ptr->param.ep_state = DAT_EP_STATE_DISCONNECTED;
 		dapl_ib_disconnect_clean(ep_ptr, FALSE);
-		spin_unlock_irqrestore(&ep_ptr->header.lock,
-				       ep_ptr->header.flags);
+		spin_unlock_irqrestore(&ep_ptr->common.lock,
+				       ep_ptr->common.flags);
 
 		break;
-	}
 	case DAT_CONNECTION_EVENT_BROKEN:
-	{
-		spin_lock_irqsave(&ep_ptr->header.lock, ep_ptr->header.flags);
+		spin_lock_irqsave(&ep_ptr->common.lock, ep_ptr->common.flags);
 		ep_ptr->param.ep_state = DAT_EP_STATE_DISCONNECTED;
 		dapl_ib_disconnect_clean(ep_ptr, FALSE);
-		spin_unlock_irqrestore(&ep_ptr->header.lock,
-				       ep_ptr->header.flags);
+		spin_unlock_irqrestore(&ep_ptr->common.lock,
+				       ep_ptr->common.flags);
 
 		break;
-	}
 	default:
-	{
 		evd_ptr = NULL;
 		dapl_os_assert(0);	/* shouldn't happen */
 		break;
 	}
-	}
 
 	if (evd_ptr != NULL) 
 		dat_status = dapl_evd_post_connection_event(evd_ptr, event,
-							    (DAT_HANDLE) ep_ptr,
+							    (struct dat_ep *)ep_ptr,
 							    0, NULL);
 
 	if (dat_status != DAT_SUCCESS) {
Index: linux-kernel/dat-provider/dapl_cr_accept.c
===================================================================
--- linux-kernel/dat-provider/dapl_cr_accept.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_cr_accept.c	(working copy)
@@ -39,42 +39,39 @@
  * Establish a connection between active side (remote endpoint)
  * and passive side (local endpoint).
  */
-u32 dapl_cr_accept(DAT_CR_HANDLE cr_handle, DAT_EP_HANDLE ep_handle,
-		   int private_data_size, const void *private_data)
+u32 dapl_cr_accept(struct dat_cr *cr, struct dat_ep *ep, int private_data_size,
+		   const void *private_data)
 {
 	struct dapl_ep *ep_ptr;
 	u32 dat_status;
 	struct dapl_cr *cr_ptr;
 	enum dat_ep_state entry_ep_state;
-	DAT_EP_HANDLE entry_ep_handle;
+	struct dat_ep *entry_ep;
 
-	dapl_dbg_log(DAPL_DBG_TYPE_API,
-		     "dapl_cr_accept (%p, %p, %d, %p)\n",
-		     cr_handle, ep_handle, private_data_size, private_data);
+	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_cr_accept (%p, %p, %d, %p)\n",
+		     cr, ep, private_data_size, private_data);
 
-	if (DAPL_BAD_HANDLE(cr_handle, DAPL_MAGIC_CR)) {
+	if (!cr) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CR);
 		goto bail;
 	}
 
-	cr_ptr = (struct dapl_cr *)cr_handle;
+	cr_ptr = (struct dapl_cr *)cr;
 
 	/*
-	 * Return an error if we have an ep_handle and the CR already has an
+	 * Return an error if we have an ep and the CR already has an
 	 * EP, indicating this is an RSP connection or PSP_PROVIDER_FLAG was
 	 * specified.
 	 */
-	if (ep_handle != NULL &&
-	    (DAPL_BAD_HANDLE(ep_handle, DAPL_MAGIC_EP) ||
-	     cr_ptr->param.local_ep_handle != NULL)) {
+	if (ep != NULL && cr_ptr->param.local_ep != NULL) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 		goto bail;
 	}
 
 	/* Make sure we have an EP handle in one place or another */
-	if (ep_handle == NULL && cr_ptr->param.local_ep_handle == NULL) {
+	if (ep == NULL && cr_ptr->param.local_ep == NULL) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 		goto bail;
@@ -86,84 +83,71 @@ u32 dapl_cr_accept(DAT_CR_HANDLE cr_hand
 	}
 
 	/*
-	 * ep_handle is NULL if the user specified DAT_PSP_PROVIDER_FLAG
+	 * ep is NULL if the user specified DAT_PSP_PROVIDER_FLAG
 	 * OR this is an RSP connection; retrieve it from the cr.
 	 */
-	if (ep_handle == NULL) {
-		ep_handle = cr_ptr->param.local_ep_handle;
-		if ((((struct dapl_ep *)ep_handle)->param.ep_state !=
+	if (ep == NULL) {
+		ep = cr_ptr->param.local_ep;
+		if ((((struct dapl_ep *)ep)->param.ep_state !=
 		     DAT_EP_STATE_TENTATIVE_CONNECTION_PENDING)
-		    && (((struct dapl_ep *)ep_handle)->param.ep_state !=
+		    && (((struct dapl_ep *)ep)->param.ep_state !=
 			DAT_EP_STATE_PASSIVE_CONNECTION_PENDING)) {
 			return DAT_INVALID_STATE;
 		}
 	} else {
 		/* ensure this EP isn't connected or in use */
-		if (((struct dapl_ep *)ep_handle)->param.ep_state !=
+		if (((struct dapl_ep *)ep)->param.ep_state !=
 		    DAT_EP_STATE_UNCONNECTED) {
 			return DAT_INVALID_STATE;
 		}
 	}
 
-	ep_ptr = (struct dapl_ep *)ep_handle;
+	ep_ptr = (struct dapl_ep *)ep;
 
 	/*
 	 * Verify the attributes of the EP handle before we connect it. Test
 	 * all of the handles to make sure they are currently valid.
 	 * Specifically:
-	 *   pz_handle              required
-	 *   recv_evd_handle        optional, but must be valid
-	 *   request_evd_handle     optional, but must be valid
-	 *   connect_evd_handle     required
+	 *   pz              required
+	 *   recv_evd        optional, but must be valid
+	 *   request_evd     optional, but must be valid
+	 *   connect_evd     required
 	 * We do all verification and state change under lock, at which
 	 * point the EP state should protect us from most races.
 	 */
-	spin_lock_irqsave(&ep_ptr->header.lock, ep_ptr->header.flags);
-	if (ep_ptr->param.pz_handle == NULL
-	    || DAPL_BAD_HANDLE(ep_ptr->param.pz_handle, DAPL_MAGIC_PZ)
-	    /* test connect handle */
-	    || ep_ptr->param.connect_evd_handle == NULL
-	    || DAPL_BAD_HANDLE(ep_ptr->param.connect_evd_handle, DAPL_MAGIC_EVD)
-	    || !(((struct dapl_evd *)ep_ptr->param.connect_evd_handle)->
-		 evd_flags & DAT_EVD_CONNECTION_FLAG)
-	    /* test optional completion handles */
-	    || (ep_ptr->param.recv_evd_handle != DAT_HANDLE_NULL &&
-		(DAPL_BAD_HANDLE
-		 (ep_ptr->param.recv_evd_handle, DAPL_MAGIC_EVD)))
-
-	    || (ep_ptr->param.request_evd_handle != DAT_HANDLE_NULL &&
-		(DAPL_BAD_HANDLE
-		 (ep_ptr->param.request_evd_handle, DAPL_MAGIC_EVD)))) {
-		spin_unlock_irqrestore(&ep_ptr->header.lock, 
-				       ep_ptr->header.flags);
+	spin_lock_irqsave(&ep_ptr->common.lock, ep_ptr->common.flags);
+	if (ep_ptr->param.pz == NULL || ep_ptr->param.connect_evd == NULL
+	    || !(((struct dapl_evd *)ep_ptr->param.connect_evd)->
+		 evd_flags & DAT_EVD_CONNECTION_FLAG)) {
+		spin_unlock_irqrestore(&ep_ptr->common.lock, 
+				       ep_ptr->common.flags);
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 		goto bail;
 	}
 
 	/* The qp must be attached by this point! */
-	if ( ep_ptr->qp_state == DAPL_QP_STATE_UNATTACHED )
-	{
-		spin_unlock_irqrestore(&ep_ptr->header.lock, 
-				       ep_ptr->header.flags);
+	if (ep_ptr->qp_state == DAPL_QP_STATE_UNATTACHED) {
+		spin_unlock_irqrestore(&ep_ptr->common.lock, 
+				       ep_ptr->common.flags);
 		dat_status = DAT_ERROR(DAT_INVALID_HANDLE, 
 				       DAT_INVALID_HANDLE_EP);
 		goto bail;
 	}
 
 	entry_ep_state = ep_ptr->param.ep_state;
-	entry_ep_handle = cr_ptr->param.local_ep_handle;
+	entry_ep = cr_ptr->param.local_ep;
 	ep_ptr->param.ep_state = DAT_EP_STATE_COMPLETION_PENDING;
-	ep_ptr->cm_handle = cr_ptr->ib_cm_handle;
+	ep_ptr->cm = cr_ptr->ib_cm_handle;
 	ep_ptr->cr_ptr = cr_ptr;
 	ep_ptr->param.remote_ia_address_ptr =
 	    cr_ptr->param.remote_ia_address_ptr;
-	cr_ptr->param.local_ep_handle = ep_handle;
+	cr_ptr->param.local_ep = ep;
 
-	spin_unlock_irqrestore(&ep_ptr->header.lock, ep_ptr->header.flags);
+	spin_unlock_irqrestore(&ep_ptr->common.lock, ep_ptr->common.flags);
 
-	dat_status = dapl_ib_accept_connection(cr_handle,
-					       ep_handle,
+	dat_status = dapl_ib_accept_connection(cr,
+					       ep,
 					       private_data_size, private_data);
 
 	/*
@@ -176,16 +160,14 @@ u32 dapl_cr_accept(DAT_CR_HANDLE cr_hand
 			 * system error, app termination, perhaps other reasons.
 			 */
 			dat_status =
-			    dapl_evd_post_connection_event(ep_ptr->param.
-							   request_evd_handle,
+			    dapl_evd_post_connection_event((struct dapl_evd *)ep_ptr->param.
+							   request_evd,
 							   DAT_CONNECTION_EVENT_ACCEPT_COMPLETION_ERROR,
-							   (DAT_HANDLE) ep_ptr,
+							   (void *) ep_ptr,
 							   0, NULL);
-
-			cr_ptr->header.magic = DAPL_MAGIC_CR_DESTROYED;
 		} else {
 			ep_ptr->param.ep_state = entry_ep_state;
-			cr_ptr->param.local_ep_handle = entry_ep_handle;
+			cr_ptr->param.local_ep = entry_ep;
 			ep_ptr->cr_ptr = NULL;
 			ep_ptr->param.remote_ia_address_ptr = NULL;
 		}
@@ -199,14 +181,8 @@ u32 dapl_cr_accept(DAT_CR_HANDLE cr_hand
 			    DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3);
 		}
 
-	} else {
-		/* Make this CR invalid. We need to hang on to it until
-		 * the connection terminates, but it's destroyed from
-		 * the app point of view.
-		 */
-		cr_ptr->header.magic = DAPL_MAGIC_CR_DESTROYED;
 	}
 
-      bail:
+bail:
 	return dat_status;
 }
Index: linux-kernel/dat-provider/dapl_cr_handoff.c
===================================================================
--- linux-kernel/dat-provider/dapl_cr_handoff.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_cr_handoff.c	(working copy)
@@ -37,7 +37,7 @@
  * Hand the connection request to another Sevice pont specified by the
  * Connectin Qualifier.
  */
-u32 dapl_cr_handoff(DAT_CR_HANDLE cr_handle, DAT_CONN_QUAL cr_handoff)
+u32 dapl_cr_handoff(struct dat_cr *cr, DAT_CONN_QUAL cr_handoff)
 {				/* handoff */
 	return DAT_ERROR(DAT_NOT_IMPLEMENTED, 0);
 }
Index: linux-kernel/dat-provider/dapl_pz.c
===================================================================
--- linux-kernel/dat-provider/dapl_pz.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_pz.c	(working copy)
@@ -44,18 +44,13 @@ static struct dapl_pz *dapl_pz_alloc(str
 	/* zero the structure */
 	memset(pz, 0, sizeof *pz);
 
-	/*
-	 * initialize the header
-	 */
-	pz->header.provider = ia->header.provider;
-	pz->header.magic = DAPL_MAGIC_PZ;
-	pz->header.handle_type = DAT_HANDLE_TYPE_PZ;
-	pz->header.owner_ia = ia;
-	pz->header.user_context.as_64 = 0;
-	pz->header.user_context.as_ptr = NULL;
-	dapl_llist_init_entry(&pz->header.ia_list_entry);
+	pz->pz.provider = ia->ia.provider;
+	pz->common.owner_ia = ia;
+	pz->common.user_context.as_64 = 0;
+	pz->common.user_context.as_ptr = NULL;
+	dapl_llist_init_entry(&pz->common.ia_list_entry);
 	dapl_ia_link_pz(ia, pz);
-	spin_lock_init(&pz->header.lock);
+	spin_lock_init(&pz->common.lock);
 
 	/* 
 	 * initialize the body 
@@ -67,83 +62,81 @@ static struct dapl_pz *dapl_pz_alloc(str
 
 static void dapl_pz_dealloc(struct dapl_pz *pz)
 {
-	/* reset magic to prevent reuse */
-	pz->header.magic = DAPL_MAGIC_INVALID;
-	dapl_ia_unlink_pz(pz->header.owner_ia, pz);
+	dapl_ia_unlink_pz(pz->common.owner_ia, pz);
 
 	kfree(pz);
 }
 
-u32 dapl_pz_create(DAT_IA_HANDLE ia_handle, DAT_PZ_HANDLE *pz_handle)
+u32 dapl_pz_create(struct dat_ia *ia, struct dat_pz **pz)
 {
-	struct dapl_ia *ia;
-	struct dapl_pz *pz;
+	struct dapl_ia *dapl_ia;
+	struct dapl_pz *dapl_pz;
 	u32 status;
 	int ib_status;
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_pz_create(%p, %p)\n", 
-		     ia_handle, pz_handle);
+		     ia, pz);
 
-	if (DAPL_BAD_HANDLE(ia_handle, DAPL_MAGIC_IA)) {
+	if (!ia) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
 		goto error1;
 	}
-	if (NULL == pz_handle) {
+	if (NULL == pz) {
 		status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG2);
 		goto error1;
 	}
 	
-	ia = (struct dapl_ia *)ia_handle;
+	dapl_ia = (struct dapl_ia *)ia;
 
-	pz = dapl_pz_alloc(ia);
-	if (NULL == pz) {
+	dapl_pz = dapl_pz_alloc(dapl_ia);
+	if (!dapl_pz) {
 		status = 
 		    DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY);
 		goto error1;
 	}
 
-	pz->pd = ib_alloc_pd(ia->hca_ptr->ib_hca_handle);
-	if (IS_ERR(pz->pd)) {
-		ib_status = PTR_ERR(pz->pd);
+	dapl_pz->pd = ib_alloc_pd(dapl_ia->hca_ptr->ib_hca_handle);
+	if (IS_ERR(dapl_pz->pd)) {
+		ib_status = PTR_ERR(dapl_pz->pd);
 		dapl_dbg_log(DAPL_DBG_TYPE_ERR, "ib_alloc_pd failed: %X\n",
 			     ib_status);
 		status = dapl_ib_status_convert(ib_status);
 		goto error2;
 	}
 	
-	*pz_handle = pz;
+	*pz = (struct dat_pz *)dapl_pz;
 	return DAT_SUCCESS;
 
 error2:
-	dapl_pz_dealloc(pz);
+	dapl_pz_dealloc(dapl_pz);
 	
 error1:
-	*pz_handle = NULL;
+	*pz = NULL;
 	return status;
 }
 
-u32 dapl_pz_free(DAT_PZ_HANDLE pz_handle)
+u32 dapl_pz_free(struct dat_pz *pz)
 {
-	struct dapl_pz *pz;
+	struct dapl_pz *dapl_pz;
 	u32 status;
 	int ib_status;
 
-	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_pz_free(%p)\n", pz_handle);
+	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_pz_free(%p)\n", pz);
 
-	if (DAPL_BAD_HANDLE(pz_handle, DAPL_MAGIC_PZ)) {
+	if (!pz) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ);
 		goto error;
 	}
 
-	pz = (struct dapl_pz *)pz_handle;
+	dapl_pz = (struct dapl_pz *)pz;
 
-	if (0 != atomic_read(&pz->pz_ref_count)) {
+	if (0 != atomic_read(&dapl_pz->pz_ref_count)) {
 		status =
 		    DAT_ERROR(DAT_INVALID_STATE, DAT_INVALID_STATE_PZ_IN_USE);
 		goto error;
 	}
 	
-	ib_status = ib_dealloc_pd(pz->pd);
+	ib_status = ib_dealloc_pd(dapl_pz->pd);
 	if (ib_status) {
 		dapl_dbg_log(DAPL_DBG_TYPE_ERR, "ib_dealloc_pd failed: %X\n",
 			     ib_status);
@@ -151,22 +144,22 @@ u32 dapl_pz_free(DAT_PZ_HANDLE pz_handle
 		goto error;
 	}
 		
-	dapl_pz_dealloc(pz);
+	dapl_pz_dealloc(dapl_pz);
 	return DAT_SUCCESS;
 
 error:
 	return status;
 }
 
-u32 dapl_pz_query(DAT_PZ_HANDLE pz_handle, struct dat_pz_param *pz_param)
+u32 dapl_pz_query(struct dat_pz *pz, struct dat_pz_param *pz_param)
 {
-	struct dapl_pz *pz;
+	struct dapl_pz *dapl_pz;
 	u32 status;
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_pz_query(%p, %x, %p)\n", 
-		     pz_handle, pz_param);
+		     pz, pz_param);
 
-	if (DAPL_BAD_HANDLE(pz_handle, DAPL_MAGIC_PZ)) {
+	if (!pz) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ);
 		goto error;
 	}
@@ -175,8 +168,8 @@ u32 dapl_pz_query(DAT_PZ_HANDLE pz_handl
 		goto error;
 	}
 
-	pz = (struct dapl_pz *)pz_handle;
-	pz_param->ia_handle = (DAT_IA_HANDLE)pz->header.owner_ia;
+	dapl_pz = (struct dapl_pz *)pz;
+	pz_param->ia = (struct dat_ia *)dapl_pz->common.owner_ia;
 	return DAT_SUCCESS;
 
 error:
Index: linux-kernel/dat-provider/dapl_lmr.c
===================================================================
--- linux-kernel/dat-provider/dapl_lmr.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_lmr.c	(working copy)
@@ -36,7 +36,7 @@
 static struct dapl_lmr *dapl_lmr_alloc(struct dapl_ia *ia,
 				       enum dat_mem_type mem_type,
 				       DAT_REGION_DESCRIPTION region_desc,
-				       u64 length, DAT_PZ_HANDLE pz_handle,
+				       u64 length, struct dat_pz *pz,
 				       enum dat_mem_priv_flags mem_priv)
 {
 	struct dapl_lmr *lmr;
@@ -49,27 +49,22 @@ static struct dapl_lmr *dapl_lmr_alloc(s
 	/* zero the structure */
 	memset(lmr, 0, sizeof *lmr);
 
-	/*
-	 * initialize the header
-	 */
-	lmr->header.provider = ia->header.provider;
-	lmr->header.magic = DAPL_MAGIC_LMR;
-	lmr->header.handle_type = DAT_HANDLE_TYPE_LMR;
-	lmr->header.owner_ia = ia;
-	lmr->header.user_context.as_64 = 0;
-	lmr->header.user_context.as_ptr = NULL;
-	dapl_llist_init_entry(&lmr->header.ia_list_entry);
+	lmr->lmr.provider = ia->ia.provider;
+	lmr->common.owner_ia = ia;
+	lmr->common.user_context.as_64 = 0;
+	lmr->common.user_context.as_ptr = NULL;
+	dapl_llist_init_entry(&lmr->common.ia_list_entry);
 	dapl_ia_link_lmr(ia, lmr);
-	spin_lock_init(&lmr->header.lock);
+	spin_lock_init(&lmr->common.lock);
 
 	/* 
 	 * initialize the body 
 	 */
-	lmr->param.ia_handle = (DAT_IA_HANDLE) ia;
+	lmr->param.ia = (struct dat_ia *)ia;
 	lmr->param.mem_type = mem_type;
 	lmr->param.region_desc = region_desc;
 	lmr->param.length = length;
-	lmr->param.pz_handle = pz_handle;
+	lmr->param.pz = pz;
 	lmr->param.mem_priv = mem_priv;
 	atomic_set(&lmr->lmr_ref_count, 0);
 
@@ -78,9 +73,7 @@ static struct dapl_lmr *dapl_lmr_alloc(s
 
 static void dapl_lmr_dealloc(struct dapl_lmr *lmr)
 {
-	/* reset magic to prevent reuse */
-	lmr->header.magic = DAPL_MAGIC_INVALID;
-	dapl_ia_unlink_lmr(lmr->header.owner_ia, lmr);
+	dapl_ia_unlink_lmr(lmr->common.owner_ia, lmr);
 
 	kfree(lmr);
 }
@@ -88,49 +81,50 @@ static void dapl_lmr_dealloc(struct dapl
 static inline u32 dapl_lmr_create_virtual(struct dapl_ia *ia, void *virt_addr,
 					  u64 length, struct dapl_pz *pz,
 					  enum dat_mem_priv_flags privileges,
-					  DAT_LMR_HANDLE *lmr_handle,
+					  struct dat_lmr **lmr,
 					  DAT_LMR_CONTEXT *lmr_context,
 					  DAT_RMR_CONTEXT *rmr_context,
 					  u64 *registered_length,
 					  u64 *registered_address)
 {
-	struct dapl_lmr *lmr;
+	struct dapl_lmr *new_lmr;
 	DAT_REGION_DESCRIPTION reg_desc;
 	u32 status;
 
 	reg_desc.for_va = virt_addr;
 
-	lmr = dapl_lmr_alloc(ia, DAT_MEM_TYPE_VIRTUAL, reg_desc, length, 
-			     (DAT_PZ_HANDLE) pz, privileges);
-	if (NULL == lmr) {
+	new_lmr = dapl_lmr_alloc(ia, DAT_MEM_TYPE_VIRTUAL, reg_desc, length,
+				 (struct dat_pz *)pz, privileges);
+	if (!new_lmr) {
 		status =
 		    DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY);
 		goto error1;
 	}
 
-	status = dapl_ib_mr_register(ia, lmr, virt_addr, length, privileges);
+	status = dapl_ib_mr_register(ia, new_lmr, virt_addr, length,
+				     privileges);
 	if (DAT_SUCCESS != status)
 		goto error2;
 
 	/* if the LMR context is already in the hash table */
 	status = dapl_hash_search(ia->hca_ptr->lmr_hash_table,
-				  lmr->param.lmr_context, NULL);
+				  new_lmr->param.lmr_context, NULL);
 	if (status == DAT_SUCCESS)
 		goto error3;
 
 	status = dapl_hash_insert(ia->hca_ptr->lmr_hash_table,
-				  lmr->param.lmr_context, lmr);
+				  new_lmr->param.lmr_context, lmr);
 	if (status != DAT_SUCCESS)
 		goto error3;
 
 	atomic_inc(&pz->pz_ref_count);
 
-	if (lmr_handle)
-		*lmr_handle = (DAT_LMR_HANDLE) lmr;
+	if (lmr)
+		*lmr = (struct dat_lmr *)new_lmr;
 	if (lmr_context)
-		*lmr_context = (DAT_LMR_CONTEXT) lmr->param.lmr_context;
+		*lmr_context = (DAT_LMR_CONTEXT)new_lmr->param.lmr_context;
 	if (rmr_context)
-		*rmr_context = (DAT_LMR_CONTEXT) lmr->param.rmr_context;
+		*rmr_context = (DAT_LMR_CONTEXT)new_lmr->param.rmr_context;
 	if (registered_address)
 		*registered_address = (u64)(unsigned long) virt_addr;
 	if (registered_length)
@@ -139,9 +133,9 @@ static inline u32 dapl_lmr_create_virtua
 	return DAT_SUCCESS;
 	
 error3:
-	(void)dapl_ib_mr_deregister(lmr);
+	(void)dapl_ib_mr_deregister(new_lmr);
 error2:
-	dapl_lmr_dealloc(lmr);	
+	dapl_lmr_dealloc(new_lmr);	
 error1:
 	return status;
 
@@ -151,26 +145,26 @@ static inline u32 dapl_lmr_create_physic
 					   DAT_REGION_DESCRIPTION phys_addr,
 					   u64 page_count, struct dapl_pz *pz,
 					   enum dat_mem_priv_flags privileges,
-					   DAT_LMR_HANDLE *lmr_handle,
+					   struct dat_lmr **lmr,
 					   DAT_LMR_CONTEXT *lmr_context,
 					   DAT_RMR_CONTEXT *rmr_context,
 					   u64 *registered_length,
 					   u64 *registered_address)
 {
-	struct dapl_lmr *lmr;
+	struct dapl_lmr *new_lmr;
 	u64 *array = phys_addr.for_array;
 	u32 status;
 
-	lmr = dapl_lmr_alloc(ia, DAT_MEM_TYPE_PHYSICAL, phys_addr, page_count, 
-			     (DAT_PZ_HANDLE) pz, privileges);
+	new_lmr = dapl_lmr_alloc(ia, DAT_MEM_TYPE_PHYSICAL, phys_addr,
+				 page_count, (struct dat_pz *) pz, privileges);
 
-	if (NULL == lmr) {
+	if (NULL == new_lmr) {
 		status =
 		    DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY);
 		goto error1;
 	}
 
-	status = dapl_ib_mr_register_physical(ia, lmr, phys_addr.for_array,
+	status = dapl_ib_mr_register_physical(ia, new_lmr, phys_addr.for_array,
 					      page_count, privileges);
 
 	if (DAT_SUCCESS != status)
@@ -178,23 +172,23 @@ static inline u32 dapl_lmr_create_physic
 
 	/* if the LMR context is already in the hash table */
 	status = dapl_hash_search(ia->hca_ptr->lmr_hash_table,
-				  lmr->param.lmr_context, NULL);
+				  new_lmr->param.lmr_context, NULL);
 	if (status == DAT_SUCCESS)
 		goto error3;
 
 	status = dapl_hash_insert(ia->hca_ptr->lmr_hash_table,
-				  lmr->param.lmr_context, lmr);
+				  new_lmr->param.lmr_context, lmr);
 	if (status != DAT_SUCCESS)
 		goto error3;
 
 	atomic_inc(&pz->pz_ref_count);
 
-	if (lmr_handle)
-		*lmr_handle = (DAT_LMR_HANDLE) lmr;
+	if (lmr)
+		*lmr = (struct dat_lmr *)new_lmr;
 	if (lmr_context)
-		*lmr_context = (DAT_LMR_CONTEXT) lmr->param.lmr_context;
+		*lmr_context = (DAT_LMR_CONTEXT)new_lmr->param.lmr_context;
 	if (rmr_context)
-		*rmr_context = (DAT_LMR_CONTEXT) lmr->param.rmr_context;
+		*rmr_context = (DAT_LMR_CONTEXT)new_lmr->param.rmr_context;
 	if (registered_address)
 		*registered_address = array[0];
 	if (registered_length)
@@ -203,9 +197,9 @@ static inline u32 dapl_lmr_create_physic
 	return DAT_SUCCESS;
 
 error3:
-	(void)dapl_ib_mr_deregister(lmr);
+	(void)dapl_ib_mr_deregister(new_lmr);
 error2:
-	dapl_lmr_dealloc(lmr);
+	dapl_lmr_dealloc(new_lmr);
 error1:
 	return status;
 }
@@ -214,13 +208,13 @@ static inline u32 dapl_lmr_create_lmr(st
 				      struct dapl_lmr *original_lmr,
 				      struct dapl_pz *pz,
 				      enum dat_mem_priv_flags privileges,
-				      DAT_LMR_HANDLE *lmr_handle,
+				      struct dat_lmr **lmr,
 				      DAT_LMR_CONTEXT *lmr_context,
 				      DAT_RMR_CONTEXT *rmr_context,
 				      u64 *registered_length,
 				      u64 *registered_address)
 {
-	struct dapl_lmr *lmr;
+	struct dapl_lmr *new_lmr;
 	DAT_REGION_DESCRIPTION reg_desc;
 	u32 status;
 	
@@ -230,39 +224,39 @@ static inline u32 dapl_lmr_create_lmr(st
 	if (status != DAT_SUCCESS)
 		goto error1;
 	
-	reg_desc.for_lmr_handle = (DAT_LMR_HANDLE) original_lmr;
+	reg_desc.for_lmr = (struct dat_lmr *) original_lmr;
 	
-	lmr = dapl_lmr_alloc(ia, DAT_MEM_TYPE_LMR, reg_desc, 0,
-			     (DAT_PZ_HANDLE) pz, privileges);
-	if (NULL == lmr) {
+	new_lmr = dapl_lmr_alloc(ia, DAT_MEM_TYPE_LMR, reg_desc, 0,
+				 (struct dat_pz *) pz, privileges);
+	if (!new_lmr) {
 		status =
 		    DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY);
 		goto error1;
 	}
 
-	status = dapl_ib_mr_register_shared(ia, lmr, privileges);
+	status = dapl_ib_mr_register_shared(ia, new_lmr, privileges);
 	if (DAT_SUCCESS != status)
 		goto error2;
 
 	/* if the LMR context is already in the hash table */
 	status = dapl_hash_search(ia->hca_ptr->lmr_hash_table,
-				  lmr->param.lmr_context, NULL);
+				  new_lmr->param.lmr_context, NULL);
 	if (status == DAT_SUCCESS)
 		goto error3;
 
 	status = dapl_hash_insert(ia->hca_ptr->lmr_hash_table,
-				  lmr->param.lmr_context, lmr);
+				  new_lmr->param.lmr_context, lmr);
 	if (status != DAT_SUCCESS)
 		goto error3;
 
 	atomic_inc(&pz->pz_ref_count);
 
-	if (lmr_handle)
-		*lmr_handle = (DAT_LMR_HANDLE) lmr;
+	if (lmr)
+		*lmr = (struct dat_lmr *)new_lmr;
 	if (lmr_context)
-		*lmr_context = (DAT_LMR_CONTEXT) lmr->param.lmr_context;
+		*lmr_context = (DAT_LMR_CONTEXT)new_lmr->param.lmr_context;
 	if (rmr_context)
-		*rmr_context = (DAT_LMR_CONTEXT) lmr->param.rmr_context;
+		*rmr_context = (DAT_LMR_CONTEXT)new_lmr->param.rmr_context;
 	if (registered_address)
 		*registered_address = (u64) (unsigned long) 
 			original_lmr->param.region_desc.for_va;
@@ -272,73 +266,72 @@ static inline u32 dapl_lmr_create_lmr(st
 	return DAT_SUCCESS;
 
 error3:
-	dapl_ib_mr_deregister(lmr);
+	dapl_ib_mr_deregister(new_lmr);
 error2:
-	dapl_lmr_dealloc(lmr);
+	dapl_lmr_dealloc(new_lmr);
 error1:
 	return status;
 }
 
-u32 dapl_lmr_kcreate(DAT_IA_HANDLE ia_handle, enum dat_mem_type mem_type,
+u32 dapl_lmr_kcreate(struct dat_ia *ia, enum dat_mem_type mem_type,
 		     DAT_REGION_DESCRIPTION region_description, u64 length,
-		     DAT_PZ_HANDLE pz_handle,
-		     enum dat_mem_priv_flags privileges,
+		     struct dat_pz *pz, enum dat_mem_priv_flags privileges,
 		     enum dat_mem_optimize_flags optimization,
-		     DAT_LMR_HANDLE *lmr_handle,
-		     DAT_LMR_CONTEXT *lmr_context, DAT_RMR_CONTEXT *rmr_context,
-		     u64 *registered_length, u64 *registered_address)
+		     struct dat_lmr **lmr, DAT_LMR_CONTEXT *lmr_context,
+		     DAT_RMR_CONTEXT *rmr_context, u64 *registered_length,
+		     u64 *registered_address)
 {
-	struct dapl_ia *ia;
-	struct dapl_pz *pz;
+	struct dapl_ia *dapl_ia;
+	struct dapl_pz *dapl_pz;
 	u32 status;
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API,
 		     "dapl_lmr_kcreate(ia:%p, mem_type:%x, ...)\n",
-		     ia_handle, mem_type);
+		     ia, mem_type);
 
-	if (DAPL_BAD_HANDLE(ia_handle, DAPL_MAGIC_IA)) {
+	if (!ia) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
 		goto bail;
 	}
-	if (DAPL_BAD_HANDLE(pz_handle, DAPL_MAGIC_PZ)) {
+	if (!pz) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ);
 		goto bail;
 	}
 
-	ia = (struct dapl_ia *)ia_handle;
-	pz = (struct dapl_pz *)pz_handle;
+	dapl_ia = (struct dapl_ia *)ia;
+	dapl_pz = (struct dapl_pz *)pz;
 
 	switch (mem_type) {
 	case DAT_MEM_TYPE_VIRTUAL:
-		status = dapl_lmr_create_virtual(ia, region_description.for_va, 
-						 length, pz, privileges,
-						 lmr_handle, lmr_context, 
+		status = dapl_lmr_create_virtual(dapl_ia,
+						 region_description.for_va, 
+						 length, dapl_pz, privileges,
+						 lmr, lmr_context, 
 						 rmr_context, registered_length,
 						 registered_address);
 		break;
 	case DAT_MEM_TYPE_PHYSICAL:
-		status = dapl_lmr_create_physical(ia, region_description,
-						  length, pz, privileges,
-						  lmr_handle, lmr_context,
+		status = dapl_lmr_create_physical(dapl_ia, region_description,
+						  length, dapl_pz, privileges,
+						  lmr, lmr_context,
 						  rmr_context,
 						  registered_length,
 						  registered_address);
 		break;
 	case DAT_MEM_TYPE_LMR:
 	{
-		struct dapl_lmr *lmr;
+		struct dapl_lmr *dapl_lmr;
 		
-		if (DAPL_BAD_HANDLE(region_description.for_lmr_handle,
-				    DAPL_MAGIC_LMR)) {
+		if (!region_description.for_lmr) {
 			status = DAT_ERROR(DAT_INVALID_HANDLE,
 					   DAT_INVALID_HANDLE_LMR);
 			goto bail;
 		}
 		
-		lmr = (struct dapl_lmr *)region_description.for_lmr_handle;
+		dapl_lmr = (struct dapl_lmr *)region_description.for_lmr;
 		
-		status = dapl_lmr_create_lmr(ia, lmr, pz, privileges,
-					     lmr_handle, lmr_context,
+		status = dapl_lmr_create_lmr(dapl_ia, dapl_lmr, dapl_pz,
+					     privileges, lmr, lmr_context,
 					     rmr_context, registered_length,
 					     registered_address);
 		break;
@@ -357,45 +350,45 @@ bail:
 	return status;
 }
 
-u32 dapl_lmr_free(DAT_LMR_HANDLE lmr_handle)
+u32 dapl_lmr_free(struct dat_lmr *lmr)
 {
-	struct dapl_lmr *lmr;
+	struct dapl_lmr *dapl_lmr;
 	u32 status;
 
-	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_lmr_free (%p)\n", lmr_handle);
+	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_lmr_free (%p)\n", lmr);
 
-	if (DAPL_BAD_HANDLE(lmr_handle, DAPL_MAGIC_LMR)) {
+	if (!lmr) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_LMR);
 		goto error;
 	}
 
-	lmr = (struct dapl_lmr *)lmr_handle;
+	dapl_lmr = (struct dapl_lmr *)lmr;
 
-	switch (lmr->param.mem_type) {
+	switch (dapl_lmr->param.mem_type) {
 	case DAT_MEM_TYPE_PHYSICAL:
 	case DAT_MEM_TYPE_VIRTUAL:
 	case DAT_MEM_TYPE_LMR:
 	{
 		struct dapl_pz *pz;
 		
-		if (0 != atomic_read(&lmr->lmr_ref_count))
+		if (0 != atomic_read(&dapl_lmr->lmr_ref_count))
 			return DAT_INVALID_STATE;
 		
 		status = dapl_hash_remove(
-			lmr->header.owner_ia->hca_ptr->lmr_hash_table,
-			lmr->param.lmr_context, NULL);
+			dapl_lmr->common.owner_ia->hca_ptr->lmr_hash_table,
+			dapl_lmr->param.lmr_context, NULL);
 		if (status != DAT_SUCCESS)
 			goto error;
 		
-		status = dapl_ib_mr_deregister(lmr);
+		status = dapl_ib_mr_deregister(dapl_lmr);
 		if (status == DAT_SUCCESS) {
-			pz = (struct dapl_pz *)lmr->param.pz_handle;
+			pz = (struct dapl_pz *)dapl_lmr->param.pz;
 			atomic_dec(&pz->pz_ref_count);
-			dapl_lmr_dealloc(lmr);
-		} else /* failure; put lmr back in hash table */
-			dapl_hash_insert(lmr->header.owner_ia->
+			dapl_lmr_dealloc(dapl_lmr);
+		} else /* failure; put dapl_lmr back in hash table */
+			dapl_hash_insert(dapl_lmr->common.owner_ia->
 					 hca_ptr->lmr_hash_table,
-					 lmr->param.lmr_context, lmr);
+					 dapl_lmr->param.lmr_context, dapl_lmr);
 		
 		break;
 	}
@@ -412,15 +405,15 @@ error:
 	return status;
 }
 
-u32 dapl_lmr_query(DAT_LMR_HANDLE lmr_handle, struct dat_lmr_param *lmr_param)
+u32 dapl_lmr_query(struct dat_lmr *lmr, struct dat_lmr_param *lmr_param)
 {
-	struct dapl_lmr *lmr;
+	struct dapl_lmr *dapl_lmr;
 	u32 status;
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_lmr_query (%p, %p)\n",
-		     lmr_handle, lmr_param);
+		     lmr, lmr_param);
 
-	if (DAPL_BAD_HANDLE(lmr_handle, DAPL_MAGIC_LMR)) {
+	if (!lmr) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_LMR);
 		goto error;
 	}
@@ -429,8 +422,8 @@ u32 dapl_lmr_query(DAT_LMR_HANDLE lmr_ha
 		goto error;
 	}
 	
-	lmr = (struct dapl_lmr *)lmr_handle;
-	memcpy(lmr_param, &lmr->param, sizeof *lmr_param);
+	dapl_lmr = (struct dapl_lmr *)lmr;
+	memcpy(lmr_param, &dapl_lmr->param, sizeof *lmr_param);
 	status = DAT_SUCCESS;
 error:
 	return status;
@@ -441,7 +434,7 @@ error:
  * will sync the cache with memory.
  */
 
-u32 dapl_lmr_sync_rdma_read(DAT_IA_HANDLE ia_handle,
+u32 dapl_lmr_sync_rdma_read(struct dat_ia *ia,
 			    const struct dat_lmr_triplet *local_segments,
 			    u64 num_segments)
 {
@@ -449,11 +442,11 @@ u32 dapl_lmr_sync_rdma_read(DAT_IA_HANDL
 	u32 status = DAT_SUCCESS;
 	
 	dapl_dbg_log(DAPL_DBG_TYPE_API, "dat_lmr_sync_rdma_read(%p, %p, %ld)\n",
-		     ia_handle, local_segments, num_segments);
+		     ia, local_segments, num_segments);
 
-	ia_ptr = (struct dapl_ia *)ia_handle;
+	ia_ptr = (struct dapl_ia *)ia;
 
-	if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
+	if (!ia_ptr) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
 		goto error;
 	}
@@ -462,7 +455,7 @@ error:
 	return status;
 }
 
-u32 dapl_lmr_sync_rdma_write(DAT_IA_HANDLE ia_handle,
+u32 dapl_lmr_sync_rdma_write(struct dat_ia *ia,
 			     const struct dat_lmr_triplet *local_segments,
 			     u64 num_segments)
 {
@@ -470,11 +463,11 @@ u32 dapl_lmr_sync_rdma_write(DAT_IA_HAND
 	u32 status = DAT_SUCCESS;
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API, "dat_lmr_sync_rdma_write(%p, %p, %ld)\n",
-		     ia_handle, local_segments, num_segments);
+		     ia, local_segments, num_segments);
 
-	ia_ptr = (struct dapl_ia *)ia_handle;
+	ia_ptr = (struct dapl_ia *)ia;
 	
-	if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
+	if (!ia_ptr) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
 		goto error;
 	}
Index: linux-kernel/dat-provider/dapl_get_handle_type.c
===================================================================
--- linux-kernel/dat-provider/dapl_get_handle_type.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_get_handle_type.c	(working copy)
@@ -1,74 +0,0 @@
-/*
- * 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
- *    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
- *    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 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.
- */
-
-/*
- * $Id$
- */
-
-#include "dapl.h"
-
-/*
- * dapl_get_handle_type
- *
- * Gets the handle type for the given dat_handle
- *
- * Input:
- * 	dat_handle
- *
- * Output:
- * 	handle_type
- *
- * Returns:
- * 	DAT_SUCCESS
- * 	DAT_INVALID_PARAMETER
- */
-
-u32 dapl_get_handle_type(DAT_HANDLE dat_handle, enum dat_handle_type *type)
-{
-	u32 dat_status = DAT_SUCCESS;
-	struct dapl_header *header;
-
-	header = (struct dapl_header *)dat_handle;
-	if (((header) == NULL) ||
-	    ((unsigned long)(header) & 3) ||
-	    (header->magic != DAPL_MAGIC_IA &&
-	     header->magic != DAPL_MAGIC_EVD &&
-	     header->magic != DAPL_MAGIC_EP &&
-	     header->magic != DAPL_MAGIC_LMR &&
-	     header->magic != DAPL_MAGIC_RMR &&
-	     header->magic != DAPL_MAGIC_PZ &&
-	     header->magic != DAPL_MAGIC_PSP &&
-	     header->magic != DAPL_MAGIC_RSP &&
-	     header->magic != DAPL_MAGIC_CR)) {
-		dat_status = DAT_ERROR(DAT_INVALID_HANDLE, 0);
-		goto bail;
-	}
-	*type = header->handle_type;
-
-bail:
-	return dat_status;
-}
Index: linux-kernel/dat-provider/dapl_get_consumer_context.c
===================================================================
--- linux-kernel/dat-provider/dapl_get_consumer_context.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_get_consumer_context.c	(working copy)
@@ -1,80 +0,0 @@
-/*
- * 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
- *    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
- *    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 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.
- */
-
-/*
- * $Id$
- */
-
-#include "dapl.h"
-
-/*
- * dapl_get_consumer_context
- *
- * DAPL Requirements Version xxx, 6.2.2.2
- *
- * Gets the consumer context from the specified dat_object
- *
- * Input:
- *	dat_handle
- *
- * Output:
- *	context
- *
- * Returns:
- * 	DAT_SUCCESS
- * 	DAT_INVALID_PARAMETER
- */
-u32 dapl_get_consumer_context(DAT_HANDLE dat_handle, union dat_context *context)
-{
-	u32 dat_status = DAT_SUCCESS;
-	struct dapl_header *header;
-
-	header = (struct dapl_header *)dat_handle;
-	if (((header) == NULL) ||
-	    ((unsigned long)(header) & 3) ||
-	    (header->magic != DAPL_MAGIC_IA &&
-	     header->magic != DAPL_MAGIC_EVD &&
-	     header->magic != DAPL_MAGIC_EP &&
-	     header->magic != DAPL_MAGIC_LMR &&
-	     header->magic != DAPL_MAGIC_RMR &&
-	     header->magic != DAPL_MAGIC_PZ &&
-	     header->magic != DAPL_MAGIC_PSP &&
-	     header->magic != DAPL_MAGIC_RSP &&
-	     header->magic != DAPL_MAGIC_CR)) {
-		dat_status = DAT_ERROR(DAT_INVALID_HANDLE, 0);
-		goto bail;
-	}
-	if (context == NULL || ((unsigned long)(header) & 3)) {
-		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG2);
-		goto bail;
-	}
-
-	*context = header->user_context;
-
-      bail:
-	return dat_status;
-}
Index: linux-kernel/dat-provider/dapl_rmr.c
===================================================================
--- linux-kernel/dat-provider/dapl_rmr.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_rmr.c	(working copy)
@@ -61,24 +61,19 @@ static struct dapl_rmr *dapl_rmr_alloc(s
 	/* zero the structure */
 	memset(rmr, 0, sizeof *rmr);
 
-	/*
-	 * initialize the header
-	 */
-	rmr->header.provider = pz->header.provider;
-	rmr->header.magic = DAPL_MAGIC_RMR;
-	rmr->header.handle_type = DAT_HANDLE_TYPE_RMR;
-	rmr->header.owner_ia = pz->header.owner_ia;
-	rmr->header.user_context.as_64 = 0;
-	rmr->header.user_context.as_ptr = NULL;
-	dapl_llist_init_entry(&rmr->header.ia_list_entry);
-	dapl_ia_link_rmr(rmr->header.owner_ia, rmr);
-	spin_lock_init(&rmr->header.lock);
+	rmr->rmr.provider = pz->pz.provider;
+	rmr->common.owner_ia = pz->common.owner_ia;
+	rmr->common.user_context.as_64 = 0;
+	rmr->common.user_context.as_ptr = NULL;
+	dapl_llist_init_entry(&rmr->common.ia_list_entry);
+	dapl_ia_link_rmr(rmr->common.owner_ia, rmr);
+	spin_lock_init(&rmr->common.lock);
 
 	/* 
 	 * initialize the body 
 	 */
-	rmr->param.ia_handle = (DAT_IA_HANDLE)pz->header.owner_ia;
-	rmr->param.pz_handle = (DAT_PZ_HANDLE)pz;
+	rmr->param.ia = (struct dat_ia *)pz->common.owner_ia;
+	rmr->param.pz = (struct dat_pz *)pz;
 	rmr->param.lmr_triplet.lmr_context = 0;
 	rmr->param.lmr_triplet.pad = 0;
 	rmr->param.lmr_triplet.virtual_address = 0;
@@ -93,11 +88,8 @@ static struct dapl_rmr *dapl_rmr_alloc(s
 
 static void dapl_rmr_dealloc(struct dapl_rmr *rmr)
 {
-	/* reset magic to prevent reuse */
-	rmr->header.magic = DAPL_MAGIC_INVALID;
-
-	dapl_ia_unlink_rmr(rmr->header.owner_ia, rmr);
-	/* no need to destroy rmr->header.lock */
+	dapl_ia_unlink_rmr(rmr->common.owner_ia, rmr);
+	/* no need to destroy rmr->common.lock */
 
 	kfree(rmr);
 }
@@ -115,7 +107,7 @@ static inline u32 dapl_rmr_bind_fuse(str
 	u32 status;
 	boolean_t is_signaled;
 
-	status = dapl_hash_search(rmr->header.owner_ia->hca_ptr->lmr_hash_table,
+	status = dapl_hash_search(rmr->common.owner_ia->hca_ptr->lmr_hash_table,
                                   lmr_triplet->lmr_context,
                                   (DAPL_HASH_DATA *) &lmr);
 	if (DAT_SUCCESS != status) {
@@ -150,8 +142,8 @@ static inline u32 dapl_rmr_bind_fuse(str
 	}
 
 	/* If the LMR, RMR, and EP are not in the same PZ, there is an error */
-	if ((ep_ptr->param.pz_handle != lmr->param.pz_handle) ||
-	    (ep_ptr->param.pz_handle != rmr->param.pz_handle)) {
+	if ((ep_ptr->param.pz != lmr->param.pz) ||
+	    (ep_ptr->param.pz != rmr->param.pz)) {
 		status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG4);
 		goto bail;
 	}
@@ -240,7 +232,7 @@ static inline u32 dapl_rmr_bind_unfuse(s
 	}
 
 	/* If the RMR and EP are not in the same PZ, there is an error */
-	if (ep_ptr->param.pz_handle != rmr->param.pz_handle) {
+	if (ep_ptr->param.pz != rmr->param.pz) {
 		status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG2);
 		goto bail1;
 	}
@@ -306,9 +298,9 @@ bail1:
  * Input:
  * Output:
  */
-u32 dapl_rmr_bind(DAT_RMR_HANDLE rmr_handle,
+u32 dapl_rmr_bind(struct dat_rmr *rmr_handle,
 		  const struct dat_lmr_triplet *lmr_triplet,
-		  enum dat_mem_priv_flags mem_priv, DAT_EP_HANDLE ep_handle,
+		  enum dat_mem_priv_flags mem_priv, struct dat_ep *ep,
 		  DAT_RMR_COOKIE user_cookie,
 		  enum dat_completion_flags completion_flags,
 		  DAT_RMR_CONTEXT *rmr_context)
@@ -316,14 +308,14 @@ u32 dapl_rmr_bind(DAT_RMR_HANDLE rmr_han
 	struct dapl_rmr *rmr;
 	struct dapl_ep *ep_ptr;
 
-	if (DAPL_BAD_HANDLE(rmr_handle, DAPL_MAGIC_RMR))
+	if (!rmr_handle)
 		return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RMR);
 
-	if (DAPL_BAD_HANDLE(ep_handle, DAPL_MAGIC_EP))
+	if (!ep)
 		return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 
 	rmr = (struct dapl_rmr *)rmr_handle;
-	ep_ptr = (struct dapl_ep *)ep_handle;
+	ep_ptr = (struct dapl_ep *)ep;
 
 	/* if the rmr should be bound */
 	if (0 != lmr_triplet->segment_length)
@@ -341,7 +333,7 @@ u32 dapl_rmr_bind(DAT_RMR_HANDLE rmr_han
  * Create a remote memory region for the specified protection zone
  *
  * Input:
- * 	pz_handle
+ * 	pz
  *
  * Output:
  * 	rmr_handle
@@ -351,20 +343,20 @@ u32 dapl_rmr_bind(DAT_RMR_HANDLE rmr_han
  * 	DAT_INSUFFICIENT_RESOURCES
  * 	DAT_INVALID_PARAMETER
  */
-u32 dapl_rmr_create(DAT_PZ_HANDLE pz_handle, DAT_RMR_HANDLE *rmr_handle)
+u32 dapl_rmr_create(struct dat_pz *pz, struct dat_rmr **rmr)
 {
-	struct dapl_pz *pz;
-	struct dapl_rmr *rmr;
+	struct dapl_pz *dapl_pz;
+	struct dapl_rmr *dapl_rmr;
 	u32 status = DAT_SUCCESS;
 
-	if (DAPL_BAD_HANDLE(pz_handle, DAPL_MAGIC_PZ)) {
+	if (!pz) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ);
 		goto bail;
 	}
 
-	pz = (struct dapl_pz *)pz_handle;
+	dapl_pz = (struct dapl_pz *)pz;
 
-	rmr = dapl_rmr_alloc(pz);
+	dapl_rmr = dapl_rmr_alloc(dapl_pz);
 
 	if (rmr == NULL) {
 		status = DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,
@@ -372,18 +364,18 @@ u32 dapl_rmr_create(DAT_PZ_HANDLE pz_han
 		goto bail;
 	}
 
-	status = dapl_ib_mw_alloc(rmr);
+	status = dapl_ib_mw_alloc(dapl_rmr);
 
 	if (status != DAT_SUCCESS) {
-		dapl_rmr_dealloc(rmr);
+		dapl_rmr_dealloc(dapl_rmr);
 		status = DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,
 				   DAT_RESOURCE_MEMORY_REGION);
 		goto bail;
 	}
 
-	atomic_inc(&pz->pz_ref_count);
+	atomic_inc(&dapl_pz->pz_ref_count);
 
-	*rmr_handle = rmr;
+	*rmr = (struct dat_rmr *)dapl_rmr;
 
 bail:
 	return status;
@@ -404,12 +396,12 @@ bail:
  * 	DAT_SUCCESS
  * 	DAT_INVALID_PARAMETER
  */
-u32 dapl_rmr_free(DAT_RMR_HANDLE rmr_handle)
+u32 dapl_rmr_free(struct dat_rmr *rmr_handle)
 {
 	struct dapl_rmr *rmr;
 	u32 status = DAT_SUCCESS;
 
-	if (DAPL_BAD_HANDLE(rmr_handle, DAPL_MAGIC_RMR)) {
+	if (!rmr_handle) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RMR);
 		goto bail;
 	}
@@ -438,12 +430,12 @@ bail:
 	return status;
 }
 
-u32 dapl_rmr_query(DAT_RMR_HANDLE rmr_handle, struct dat_rmr_param *rmr_param)
+u32 dapl_rmr_query(struct dat_rmr *rmr_handle, struct dat_rmr_param *rmr_param)
 {
 	struct dapl_rmr *rmr;
 	u32 status = DAT_SUCCESS;
 
-	if (DAPL_BAD_HANDLE(rmr_handle, DAPL_MAGIC_RMR)) {
+	if (!rmr_handle) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RMR);
 		goto bail;
 	}
Index: linux-kernel/dat-provider/dapl_cr_util.c
===================================================================
--- linux-kernel/dat-provider/dapl_cr_util.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_cr_util.c	(working copy)
@@ -49,17 +49,12 @@ struct dapl_cr *dapl_cr_alloc(struct dap
 	/* zero the structure */
 	memset(cr_ptr, 0, sizeof *cr_ptr);
 
-	/*
-	 * initialize the header
-	 */
-	cr_ptr->header.provider = ia_ptr->header.provider;
-	cr_ptr->header.magic = DAPL_MAGIC_CR;
-	cr_ptr->header.handle_type = DAT_HANDLE_TYPE_CR;
-	cr_ptr->header.owner_ia = ia_ptr;
-	cr_ptr->header.user_context.as_64 = 0;
-	cr_ptr->header.user_context.as_ptr = NULL;
-	dapl_llist_init_entry(&cr_ptr->header.ia_list_entry);
-	spin_lock_init(&cr_ptr->header.lock);
+	cr_ptr->cr.provider = ia_ptr->ia.provider;
+	cr_ptr->common.owner_ia = ia_ptr;
+	cr_ptr->common.user_context.as_64 = 0;
+	cr_ptr->common.user_context.as_ptr = NULL;
+	dapl_llist_init_entry(&cr_ptr->common.ia_list_entry);
+	spin_lock_init(&cr_ptr->common.lock);
 
 	return cr_ptr;
 }
@@ -69,9 +64,5 @@ struct dapl_cr *dapl_cr_alloc(struct dap
  */
 void dapl_cr_free(struct dapl_cr *cr_ptr)
 {
-	dapl_os_assert(cr_ptr->header.magic == DAPL_MAGIC_CR ||
-		       cr_ptr->header.magic == DAPL_MAGIC_CR_DESTROYED);
-	/* reset magic to prevent reuse */
-	cr_ptr->header.magic = DAPL_MAGIC_INVALID;
 	kfree(cr_ptr);
 }
Index: linux-kernel/dat-provider/dapl_psp.c
===================================================================
--- linux-kernel/dat-provider/dapl_psp.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_psp.c	(working copy)
@@ -45,13 +45,13 @@
  * the user.
  *
  * Input:
- * 	ia_handle
- * 	evd_handle
+ * 	ia
+ * 	evd
  * 	psp_flags
  *
  * Output:
  * 	conn_qual
- * 	psp_handle
+ * 	psp
  *
  * Returns:
  * 	DAT_SUCCESS
@@ -61,9 +61,9 @@
  * 	DAT_CONN_QUAL_IN_USE
  * 	DAT_MODEL_NOT_SUPPORTED
  */
-u32 dapl_psp_create_any(DAT_IA_HANDLE ia_handle, DAT_CONN_QUAL *conn_qual,
-			DAT_EVD_HANDLE evd_handle, enum dat_psp_flags psp_flags,
-			DAT_PSP_HANDLE *psp_handle)
+u32 dapl_psp_create_any(struct dat_ia *ia, DAT_CONN_QUAL *conn_qual,
+			struct dat_evd *evd, enum dat_psp_flags psp_flags,
+			struct dat_sp **psp)
 {
 	static DAT_CONN_QUAL hint_conn_qual = 1000;	/* seed value */
 	struct dapl_ia *ia_ptr;
@@ -72,19 +72,19 @@ u32 dapl_psp_create_any(DAT_IA_HANDLE ia
 	u32 status = DAT_SUCCESS;
 	int i;
 
-	ia_ptr = (struct dapl_ia *)ia_handle;
+	ia_ptr = (struct dapl_ia *)ia;
 
-	if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
+	if (!ia_ptr) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
 		goto bail;
 	}
-	if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) {
+	if (!evd) {
 		status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_CR);
 		goto bail;
 	}
 
-	if (psp_handle == NULL) {
+	if (psp == NULL) {
 		status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG5);
 		goto bail;
 	}
@@ -93,7 +93,7 @@ u32 dapl_psp_create_any(DAT_IA_HANDLE ia
 		goto bail;
 	}
 
-	evd_ptr = (struct dapl_evd *)evd_handle;
+	evd_ptr = (struct dapl_evd *)evd;
 	if (!(evd_ptr->evd_flags & DAT_EVD_CR_FLAG)) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE,
 				   DAT_INVALID_HANDLE_EVD_CR);
@@ -117,10 +117,10 @@ u32 dapl_psp_create_any(DAT_IA_HANDLE ia
 	/*
 	 * Fill out the args for a PSP
 	 */
-	sp_ptr->ia_handle = ia_handle;
-	sp_ptr->evd_handle = evd_handle;
+	sp_ptr->ia = ia;
+	sp_ptr->evd = evd;
 	sp_ptr->psp_flags = psp_flags;
-	sp_ptr->ep_handle = NULL;
+	sp_ptr->ep = NULL;
 
 	/*
 	 * Take a reference on the EVD handle
@@ -153,7 +153,7 @@ u32 dapl_psp_create_any(DAT_IA_HANDLE ia
 
 	if (status != DAT_SUCCESS) {
 		atomic_dec(&evd_ptr->evd_ref_count);
-		sp_ptr->evd_handle = NULL;
+		sp_ptr->evd = NULL;
 		dapl_ia_unlink_sp(ia_ptr, sp_ptr);
 		dapl_sp_dealloc(sp_ptr);
 
@@ -168,7 +168,7 @@ u32 dapl_psp_create_any(DAT_IA_HANDLE ia
 	 * Return handle to the user
 	 */
 	*conn_qual = sp_ptr->conn_qual;
-	*psp_handle = (DAT_PSP_HANDLE) sp_ptr;
+	*psp = (struct dat_sp *) sp_ptr;
 
 bail:
 	return status;
@@ -183,13 +183,13 @@ bail:
  * in a notification event.
  *
  * Input:
- * 	ia_handle
+ * 	ia
  * 	conn_qual
- * 	evd_handle
+ * 	evd
  * 	psp_flags
  *
  * Output:
- * 	psp_handle
+ * 	psp
  *
  * Returns:
  * 	DAT_SUCCESS
@@ -198,9 +198,9 @@ bail:
  * 	DAT_CONN_QUAL_IN_USE
  * 	DAT_MODEL_NOT_SUPPORTED
  */
-u32 dapl_psp_create(DAT_IA_HANDLE ia_handle, DAT_CONN_QUAL conn_qual,
-		    DAT_EVD_HANDLE evd_handle, enum dat_psp_flags psp_flags,
-		    DAT_PSP_HANDLE *psp_handle)
+u32 dapl_psp_create(struct dat_ia *ia, DAT_CONN_QUAL conn_qual,
+		    struct dat_evd *evd, enum dat_psp_flags psp_flags,
+		    struct dat_sp **psp)
 {
 	struct dapl_ia *ia_ptr;
 	struct dapl_sp *sp_ptr;
@@ -208,24 +208,24 @@ u32 dapl_psp_create(DAT_IA_HANDLE ia_han
 	boolean_t sp_found;
 	u32 status = DAT_SUCCESS;
 
-	ia_ptr = (struct dapl_ia *)ia_handle;
+	ia_ptr = (struct dapl_ia *)ia;
 
-	if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
+	if (!ia_ptr) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
 		goto bail;
 	}
-	if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) {
+	if (!evd) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE,
 				   DAT_INVALID_HANDLE_EVD_CR);
 		goto bail;
 	}
 
-	if (psp_handle == NULL) {
+	if (psp == NULL) {
 		status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG5);
 		goto bail;
 	}
 
-	evd_ptr = (struct dapl_evd *)evd_handle;
+	evd_ptr = (struct dapl_evd *)evd;
 	if (!(evd_ptr->evd_flags & DAT_EVD_CR_FLAG)) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE,
 				   DAT_INVALID_HANDLE_EVD_CR);
@@ -261,11 +261,11 @@ u32 dapl_psp_create(DAT_IA_HANDLE ia_han
 	/*
 	 * Fill out the args for a PSP
 	 */
-	sp_ptr->ia_handle = ia_handle;
+	sp_ptr->ia = ia;
 	sp_ptr->conn_qual = conn_qual;
-	sp_ptr->evd_handle = evd_handle;
+	sp_ptr->evd = evd;
 	sp_ptr->psp_flags = psp_flags;
-	sp_ptr->ep_handle = NULL;
+	sp_ptr->ep = NULL;
 
 	/*
 	 * Take a reference on the EVD handle
@@ -298,7 +298,7 @@ u32 dapl_psp_create(DAT_IA_HANDLE ia_han
 			 * wrong!  Decrements the EVD refcount & release it.
 			 */
 			atomic_dec(&evd_ptr->evd_ref_count);
-			sp_ptr->evd_handle = NULL;
+			sp_ptr->evd = NULL;
 			dapl_ia_unlink_sp(ia_ptr, sp_ptr);
 			dapl_sp_dealloc(sp_ptr);
 
@@ -313,7 +313,7 @@ u32 dapl_psp_create(DAT_IA_HANDLE ia_han
 	/*
 	 * Return handle to the user
 	 */
-	*psp_handle = (DAT_PSP_HANDLE) sp_ptr;
+	*psp = (struct dat_sp *) sp_ptr;
 
 bail:
 	return status;
@@ -325,7 +325,7 @@ bail:
  * Destroy a specific instance of a Service Point.
  *
  * Input:
- * 	psp_handle
+ * 	psp
  *
  * Output:
  * 	none
@@ -334,26 +334,25 @@ bail:
  * 	DAT_SUCCESS
  * 	DAT_INVALID_PARAMETER
  */
-u32 dapl_psp_free(DAT_PSP_HANDLE psp_handle)
+u32 dapl_psp_free(struct dat_sp *psp)
 {
 	struct dapl_ia *ia_ptr;
 	struct dapl_sp *sp_ptr;
 	DAPL_SP_STATE save_state;
 	u32 status = DAT_SUCCESS;
 
-	sp_ptr = (struct dapl_sp *)psp_handle;
+	sp_ptr = (struct dapl_sp *)psp;
 	/*
 	 * Verify handle
 	 */
-	dapl_dbg_log(DAPL_DBG_TYPE_CM, ">>> dapl_psp_free %p\n", psp_handle);
+	dapl_dbg_log(DAPL_DBG_TYPE_CM, ">>> dapl_psp_free %p\n", psp);
 
-	if (DAPL_BAD_HANDLE(sp_ptr, DAPL_MAGIC_PSP)) {
+	if (!sp_ptr) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PSP);
 		goto bail;
 	}
 
-	/* ia_ptr = (struct dapl_ia *)sp_ptr->header.owner_ia; */
-	ia_ptr = sp_ptr->header.owner_ia;
+	ia_ptr = sp_ptr->common.owner_ia;
 	/* 
 	 * Remove the connection listener if it has been established
 	 * and there are no current connections in progress.
@@ -361,18 +360,18 @@ u32 dapl_psp_free(DAT_PSP_HANDLE psp_han
 	 * container until the last connection is disconnected, after
 	 * which it will be cleaned up.
 	 */
-	spin_lock_irqsave(&sp_ptr->header.lock, sp_ptr->header.flags);
+	spin_lock_irqsave(&sp_ptr->common.lock, sp_ptr->common.flags);
 
 	sp_ptr->listening = FALSE;
 
 	/*
 	 * Release reference on EVD. If an error was encountered in a previous
-	 * free the evd_handle will be NULL
+	 * free the evd will be NULL
 	 */
-	if (sp_ptr->evd_handle) {
-		atomic_dec(&((struct dapl_evd *)sp_ptr->evd_handle)->
+	if (sp_ptr->evd) {
+		atomic_dec(&((struct dapl_evd *)sp_ptr->evd)->
 				   evd_ref_count);
-		sp_ptr->evd_handle = NULL;
+		sp_ptr->evd = NULL;
 	}
 
 	/*
@@ -389,8 +388,8 @@ u32 dapl_psp_free(DAT_PSP_HANDLE psp_han
 	    sp_ptr->cr_list_count == 0) {
 		save_state = sp_ptr->state;
 		sp_ptr->state = DAPL_SP_STATE_FREE;
-		spin_unlock_irqrestore(&sp_ptr->header.lock,
-				       sp_ptr->header.flags);
+		spin_unlock_irqrestore(&sp_ptr->common.lock,
+				       sp_ptr->common.flags);
 
 		status = dapl_ib_remove_conn_listener(ia_ptr, sp_ptr);
 		if (status != DAT_SUCCESS) {
@@ -407,7 +406,8 @@ u32 dapl_psp_free(DAT_PSP_HANDLE psp_han
 		 * ServiceID again, which will reactivate it.
 		 */
 		sp_ptr->state = DAPL_SP_STATE_PSP_PENDING;
-		spin_unlock_irqrestore(&sp_ptr->header.lock, sp_ptr->header.flags);
+		spin_unlock_irqrestore(&sp_ptr->common.lock,
+				       sp_ptr->common.flags);
 		dapl_dbg_log(DAPL_DBG_TYPE_CM,
 			     ">>> dapl_psp_free: PSP PENDING\n");
 	}
@@ -416,13 +416,12 @@ bail:
 	return status;
 }
 
-u32 dapl_psp_query(DAT_PSP_HANDLE psp_handle, struct dat_psp_param *psp_param)
+u32 dapl_psp_query(struct dat_sp *psp, struct dat_psp_param *psp_param)
 {
 	struct dapl_sp *sp_ptr;
 	u32 status;
 
-	if (DAPL_BAD_HANDLE(psp_handle, DAPL_MAGIC_PSP) ||
-	    ((struct dapl_sp *)psp_handle)->listening != TRUE) {
+	if (!psp || ((struct dapl_sp *)psp)->listening != TRUE) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PSP);
 		goto bail;
 	}
@@ -432,11 +431,11 @@ u32 dapl_psp_query(DAT_PSP_HANDLE psp_ha
 		goto bail;
 	}
 
-	sp_ptr = (struct dapl_sp *)psp_handle;
+	sp_ptr = (struct dapl_sp *)psp;
 
-	psp_param->ia_handle = sp_ptr->ia_handle;
+	psp_param->ia = sp_ptr->ia;
 	psp_param->conn_qual = sp_ptr->conn_qual;
-	psp_param->evd_handle = sp_ptr->evd_handle;
+	psp_param->evd = sp_ptr->evd;
 	psp_param->psp_flags = sp_ptr->psp_flags;
 
 	status = DAT_SUCCESS;
Index: linux-kernel/dat-provider/dapl_ep.c
===================================================================
--- linux-kernel/dat-provider/dapl_ep.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_ep.c	(working copy)
@@ -43,11 +43,6 @@
 
 static void dapl_ep_dealloc(struct dapl_ep *ep_ptr)
 {
-	dapl_os_assert(ep_ptr->header.magic == DAPL_MAGIC_EP);
-
-	/* reset magic to prevent reuse */
-	ep_ptr->header.magic = DAPL_MAGIC_INVALID;
-
 	dapl_cb_free(&ep_ptr->req_buffer);
 	dapl_cb_free(&ep_ptr->recv_buffer);
 
@@ -73,18 +68,12 @@ struct dapl_ep *dapl_ep_alloc(struct dap
 	/* zero the structure */
 	memset(ep_ptr, 0, sizeof *ep_ptr + sizeof (struct sockaddr));
 
-	/*
-	 * initialize the header
-	 */
-	ep_ptr->header.provider = ia_ptr->header.provider;
-	ep_ptr->header.magic = DAPL_MAGIC_EP;
-	ep_ptr->header.handle_type = DAT_HANDLE_TYPE_EP;
-	ep_ptr->header.owner_ia = ia_ptr;
-	ep_ptr->header.user_context.as_64 = 0;
-	ep_ptr->header.user_context.as_ptr = NULL;
-
-	dapl_llist_init_entry(&ep_ptr->header.ia_list_entry);
-	spin_lock_init(&ep_ptr->header.lock);
+	ep_ptr->ep.provider = ia_ptr->ia.provider;
+	ep_ptr->common.owner_ia = ia_ptr;
+	ep_ptr->common.user_context.as_64 = 0;
+	ep_ptr->common.user_context.as_ptr = NULL;
+	dapl_llist_init_entry(&ep_ptr->common.ia_list_entry);
+	spin_lock_init(&ep_ptr->common.lock);
 
 	/*
 	 * Initialize the body
@@ -105,7 +94,7 @@ struct dapl_ep *dapl_ep_alloc(struct dap
 
 	ep_ptr->qp = NULL;
 	ep_ptr->qp_state = DAPL_QP_STATE_UNATTACHED;
-	ep_ptr->cm_handle = NULL;
+	ep_ptr->cm = NULL;
 
 	atomic_set(&ep_ptr->req_count, 0);
 	atomic_set(&ep_ptr->recv_count, 0);
@@ -176,7 +165,7 @@ static u32 dapl_ep_check_recv_completion
 	return DAT_SUCCESS;
 }
 
-static u32 dapl_ep_post_send_req(DAT_EP_HANDLE ep_handle, int num_segments,
+static u32 dapl_ep_post_send_req(struct dat_ep *ep, int num_segments,
 				 struct dat_lmr_triplet *local_iov,
 				 DAT_DTO_COOKIE user_cookie,
 				 const struct dat_rmr_triplet *remote_iov,
@@ -188,13 +177,13 @@ static u32 dapl_ep_post_send_req(DAT_EP_
 	struct dapl_cookie *cookie;
 	u32 dat_status;
 
-	if (DAPL_BAD_HANDLE(ep_handle, DAPL_MAGIC_EP)) {
+	if (!ep) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 		goto bail;
 	}
 
-	ep_ptr = (struct dapl_ep *)ep_handle;
+	ep_ptr = (struct dapl_ep *)ep;
 
 	/*
 	 * Synchronization ok since this buffer is only used for send
@@ -292,11 +281,11 @@ enum dat_return_subtype dapl_ep_state_su
 	return dat_status;
 }
 
-u32 dapl_ep_create(DAT_IA_HANDLE ia_handle, DAT_PZ_HANDLE pz_handle,
-		   DAT_EVD_HANDLE recv_evd_handle,
-		   DAT_EVD_HANDLE request_evd_handle,
-		   DAT_EVD_HANDLE connect_evd_handle,
-		   const struct dat_ep_attr *ep_attr, DAT_EP_HANDLE *ep_handle)
+u32 dapl_ep_create(struct dat_ia *ia, struct dat_pz *pz,
+		   struct dat_evd *recv_evd,
+		   struct dat_evd *request_evd,
+		   struct dat_evd *connect_evd,
+		   const struct dat_ep_attr *ep_attr, struct dat_ep **ep)
 {
 	struct dapl_ia *ia_ptr;
 	struct dapl_ep *ep_ptr;
@@ -305,18 +294,18 @@ u32 dapl_ep_create(DAT_IA_HANDLE ia_hand
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API,
 		     "dapl_ep_create (%p, %p, %p, %p, %p, %p, %p)\n",
-		     ia_handle,
-		     pz_handle,
-		     recv_evd_handle,
-		     request_evd_handle,
-		     connect_evd_handle, ep_attr, ep_handle);
+		     ia,
+		     pz,
+		     recv_evd,
+		     request_evd,
+		     connect_evd, ep_attr, ep);
 
-	ia_ptr = (struct dapl_ia *)ia_handle;
+	ia_ptr = (struct dapl_ia *)ia;
 
 	/*
 	 * Verify parameters
 	 */
-	if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
+	if (!ia_ptr) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
 		goto bail;
@@ -328,44 +317,34 @@ u32 dapl_ep_create(DAT_IA_HANDLE ia_hand
 	 *      modified by dat_ep_modify() is not strictly
 	 *      required when the EP is created
 	 */
-	if (pz_handle != DAT_HANDLE_NULL &&
-	    DAPL_BAD_HANDLE(pz_handle, DAPL_MAGIC_PZ)) {
-		dat_status =
-		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ);
-		goto bail;
-	}
 
 	/* If connect handle is !NULL verify handle is good  */
-	if (connect_evd_handle != DAT_HANDLE_NULL &&
-	    (DAPL_BAD_HANDLE(connect_evd_handle, DAPL_MAGIC_EVD) ||
-	     !(((struct dapl_evd *)connect_evd_handle)->
-	       evd_flags & DAT_EVD_CONNECTION_FLAG))) {
+	if (connect_evd != NULL &&
+	    !(((struct dapl_evd *)connect_evd)->
+	      evd_flags & DAT_EVD_CONNECTION_FLAG)) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_CONN);
 		goto bail;
 	}
 
 	/* If recv_evd is !NULL, verify handle is good and flags are valid */
-	if (recv_evd_handle != DAT_HANDLE_NULL &&
-	    (DAPL_BAD_HANDLE(recv_evd_handle, DAPL_MAGIC_EVD) ||
-	     !(((struct dapl_evd *)recv_evd_handle)->evd_flags & DAT_EVD_DTO_FLAG))) {
+	if (recv_evd != NULL &&
+	    !(((struct dapl_evd *)recv_evd)->evd_flags & DAT_EVD_DTO_FLAG)) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_RECV);
 		goto bail;
 	}
 
 	/* If req_evd is !NULL, verify handle is good and flags are valid */
-	if (request_evd_handle != DAT_HANDLE_NULL &&
-	    (DAPL_BAD_HANDLE(request_evd_handle, DAPL_MAGIC_EVD) ||
-	     !(((struct dapl_evd *)request_evd_handle)->
-	       evd_flags & DAT_EVD_DTO_FLAG))) {
+	if (request_evd != NULL &&
+	    !(((struct dapl_evd *)request_evd)->evd_flags & DAT_EVD_DTO_FLAG)) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE,
 			      DAT_INVALID_HANDLE_EVD_REQUEST);
 		goto bail;
 	}
 
-	if (ep_handle == NULL) {
+	if (ep == NULL) {
 		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG7);
 		goto bail;
 	}
@@ -381,12 +360,12 @@ u32 dapl_ep_create(DAT_IA_HANDLE ia_hand
 	 * the respective queue.
 	 */
 	if (ep_attr != NULL &&
-	    ((recv_evd_handle == DAT_HANDLE_NULL && ep_attr->max_recv_dtos != 0)
-	     || (recv_evd_handle != DAT_HANDLE_NULL
+	    ((recv_evd == NULL && ep_attr->max_recv_dtos != 0)
+	     || (recv_evd != NULL
 		 && ep_attr->max_recv_dtos == 0)
-	     || (request_evd_handle == DAT_HANDLE_NULL
+	     || (request_evd == NULL
 		 && ep_attr->max_request_dtos != 0)
-	     || (request_evd_handle != DAT_HANDLE_NULL
+	     || (request_evd != NULL
 		 && ep_attr->max_request_dtos == 0)
 	     || ep_attr->max_recv_iov == 0 || ep_attr->max_request_iov == 0
 	     || (DAT_SUCCESS !=
@@ -424,25 +403,25 @@ u32 dapl_ep_create(DAT_IA_HANDLE ia_hand
 	/*
 	 * Fill in the EP
 	 */
-	ep_ptr->param.ia_handle = ia_handle;
+	ep_ptr->param.ia = ia;
 	ep_ptr->param.ep_state = DAT_EP_STATE_UNCONNECTED;
 	ep_ptr->param.local_ia_address_ptr =
 	    (struct sockaddr *)&ia_ptr->hca_ptr->hca_address;
 	/* Set the remote address pointer to the end of the EP struct */
 	ep_ptr->param.remote_ia_address_ptr = (struct sockaddr *) (ep_ptr + 1);
 
-	ep_ptr->param.pz_handle = pz_handle;
-	ep_ptr->param.recv_evd_handle = recv_evd_handle;
-	ep_ptr->param.request_evd_handle = request_evd_handle;
-	ep_ptr->param.connect_evd_handle = connect_evd_handle;
+	ep_ptr->param.pz = pz;
+	ep_ptr->param.recv_evd = recv_evd;
+	ep_ptr->param.request_evd = request_evd;
+	ep_ptr->param.connect_evd = connect_evd;
 
 	/*
 	 * Make sure we handle the NULL DTO EVDs
 	 */
-	if (recv_evd_handle == DAT_HANDLE_NULL && ep_attr == NULL)
+	if (recv_evd == NULL && ep_attr == NULL)
 		ep_ptr->param.ep_attr.max_recv_dtos = 0;
 
-	if (request_evd_handle == DAT_HANDLE_NULL && ep_attr == NULL)
+	if (request_evd == NULL && ep_attr == NULL)
 		ep_ptr->param.ep_attr.max_request_dtos = 0;
 
 	/*
@@ -451,9 +430,9 @@ u32 dapl_ep_create(DAT_IA_HANDLE ia_hand
 	 * As much as possible we try to keep QP creation out of the
 	 * connect path to avoid resource errors in strange places.
 	 */
-	if (pz_handle != DAT_HANDLE_NULL) {
+	if (pz != NULL) {
 		/* Take a reference on the PZ handle */
-		atomic_inc(&((struct dapl_pz *)pz_handle)->pz_ref_count);
+		atomic_inc(&((struct dapl_pz *)pz)->pz_ref_count);
 
 		/*
 		 * Get a QP from the IB provider
@@ -461,7 +440,7 @@ u32 dapl_ep_create(DAT_IA_HANDLE ia_hand
 		dat_status = dapl_ib_qp_alloc(ia_ptr, ep_ptr, ep_ptr);
 
 		if (dat_status != DAT_SUCCESS) {
-			atomic_dec(&((struct dapl_pz *)pz_handle)->pz_ref_count);
+			atomic_dec(&((struct dapl_pz *)pz)->pz_ref_count);
 			dapl_ep_dealloc(ep_ptr);
 			goto bail;
 		}
@@ -471,36 +450,36 @@ u32 dapl_ep_create(DAT_IA_HANDLE ia_hand
 	/*
 	 * Update ref counts. See the spec where the endpoint marks
 	 * a data object as 'in use'
-	 *   pz_handle: dat_pz_free
-	 *   evd_handles:
+	 *   pz: dat_pz_free
+	 *   evds:
 	 *
 	 * N.B. This should really be done by a util routine.
 	 */
-	atomic_inc(&((struct dapl_evd *)connect_evd_handle)->evd_ref_count);
+	atomic_inc(&((struct dapl_evd *)connect_evd)->evd_ref_count);
 	/* Optional handles */
-	if (recv_evd_handle != DAT_HANDLE_NULL)
-		atomic_inc(&((struct dapl_evd *)recv_evd_handle)->
+	if (recv_evd != NULL)
+		atomic_inc(&((struct dapl_evd *)recv_evd)->
 				   evd_ref_count);
-	if (request_evd_handle != DAT_HANDLE_NULL)
-		atomic_inc(&((struct dapl_evd *)request_evd_handle)->
+	if (request_evd != NULL)
+		atomic_inc(&((struct dapl_evd *)request_evd)->
 				   evd_ref_count);
 
 	/* Link it onto the IA */
 	dapl_ia_link_ep(ia_ptr, ep_ptr);
 
-	*ep_handle = ep_ptr;
+	*ep = (struct dat_ep *)ep_ptr;
 
 bail:
 	return dat_status;
 }
 
-u32 dapl_ep_create_with_srq(DAT_IA_HANDLE ia_handle, DAT_PZ_HANDLE pz_handle,
-			    DAT_EVD_HANDLE recv_evd_handle,
-			    DAT_EVD_HANDLE request_evd_handle,
-			    DAT_EVD_HANDLE connect_evd_handle,
-			    DAT_SRQ_HANDLE srq_handle,
+u32 dapl_ep_create_with_srq(struct dat_ia *ia, struct dat_pz *pz,
+			    struct dat_evd *recv_evd,
+			    struct dat_evd *request_evd,
+			    struct dat_evd *connect_evd,
+			    struct dat_srq *srq,
 			    const struct dat_ep_attr *ep_attr,
-			    DAT_EP_HANDLE *ep_handle)
+			    struct dat_ep **ep)
 {
 	struct dapl_ia *ia_ptr;
 	struct dapl_ep *ep_ptr;
@@ -509,18 +488,18 @@ u32 dapl_ep_create_with_srq(DAT_IA_HANDL
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API,
 		     "dapl_ep_create_with_srq (%p, %p, %p, %p, %p, %p, %p %p)\n",
-		     ia_handle,
-		     pz_handle,
-		     recv_evd_handle,
-		     request_evd_handle,
-		     connect_evd_handle, srq_handle, ep_attr, ep_handle);
+		     ia,
+		     pz,
+		     recv_evd,
+		     request_evd,
+		     connect_evd, srq, ep_attr, ep);
 
-	ia_ptr = (struct dapl_ia *)ia_handle;
+	ia_ptr = (struct dapl_ia *)ia;
 
 	/*
 	 * Verify parameters
 	 */
-	if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
+	if (!ia_ptr) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
 		goto bail;
@@ -532,35 +511,27 @@ u32 dapl_ep_create_with_srq(DAT_IA_HANDL
 	 *      modified by dat_ep_modify() is not strictly
 	 *      required when the EP is created
 	 */
-	if (pz_handle != NULL && DAPL_BAD_HANDLE(pz_handle, DAPL_MAGIC_PZ)) {
-		dat_status =
-		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PZ);
-		goto bail;
-	}
 
 	/* If connect handle is !NULL verify handle is good  */
-	if (connect_evd_handle != DAT_HANDLE_NULL &&
-	    (DAPL_BAD_HANDLE(connect_evd_handle, DAPL_MAGIC_EVD) ||
-	     !(((struct dapl_evd *)connect_evd_handle)->
-	       evd_flags & DAT_EVD_CONNECTION_FLAG))) {
+	if (connect_evd != NULL &&
+	    !(((struct dapl_evd *)connect_evd)->
+	       evd_flags & DAT_EVD_CONNECTION_FLAG)) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_CONN);
 		goto bail;
 	}
 	/* If recv_evd is !NULL, verify handle is good and flags are valid */
-	if (recv_evd_handle != DAT_HANDLE_NULL &&
-	    (DAPL_BAD_HANDLE(recv_evd_handle, DAPL_MAGIC_EVD) ||
-	     !(((struct dapl_evd *)recv_evd_handle)->evd_flags & DAT_EVD_DTO_FLAG))) {
+	if (recv_evd != NULL &&
+	    !(((struct dapl_evd *)recv_evd)->evd_flags & DAT_EVD_DTO_FLAG)) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_RECV);
 		goto bail;
 	}
 
 	/* If req_evd is !NULL, verify handle is good and flags are valid */
-	if (request_evd_handle != DAT_HANDLE_NULL &&
-	    (DAPL_BAD_HANDLE(request_evd_handle, DAPL_MAGIC_EVD) ||
-	     !(((struct dapl_evd *)request_evd_handle)->
-	       evd_flags & DAT_EVD_DTO_FLAG))) {
+	if (request_evd != NULL &&
+	    !(((struct dapl_evd *)request_evd)->
+	      evd_flags & DAT_EVD_DTO_FLAG)) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE,
 			      DAT_INVALID_HANDLE_EVD_REQUEST);
@@ -571,13 +542,13 @@ u32 dapl_ep_create_with_srq(DAT_IA_HANDL
 	 * Verify the SRQ handle. It is an error to invoke this call with
 	 * a NULL handle
 	 */
-	if (DAPL_BAD_HANDLE(srq_handle, DAPL_MAGIC_SRQ)) {
+	if (!srq) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_SRQ);
 		goto bail;
 	}
 
-	if (ep_handle == NULL) {
+	if (ep == NULL) {
 		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG7);
 		goto bail;
 	}
@@ -593,12 +564,12 @@ u32 dapl_ep_create_with_srq(DAT_IA_HANDL
 	 * the respective queue.
 	 */
 	if (ep_attr != NULL &&
-	    ((recv_evd_handle == DAT_HANDLE_NULL && ep_attr->max_recv_dtos != 0)
-	     || (recv_evd_handle != DAT_HANDLE_NULL
+	    ((recv_evd == NULL && ep_attr->max_recv_dtos != 0)
+	     || (recv_evd != NULL
 		 && ep_attr->max_recv_dtos == 0)
-	     || (request_evd_handle == DAT_HANDLE_NULL
+	     || (request_evd == NULL
 		 && ep_attr->max_request_dtos != 0)
-	     || (request_evd_handle != DAT_HANDLE_NULL
+	     || (request_evd != NULL
 		 && ep_attr->max_request_dtos == 0)
 	     || ep_attr->max_recv_iov == 0 || ep_attr->max_request_iov == 0
 	     || (DAT_SUCCESS !=
@@ -647,26 +618,26 @@ u32 dapl_ep_create_with_srq(DAT_IA_HANDL
 	/*
 	 * Fill in the EP
 	 */
-	ep_ptr->param.ia_handle = ia_handle;
+	ep_ptr->param.ia = ia;
 	ep_ptr->param.ep_state = DAT_EP_STATE_UNCONNECTED;
 	ep_ptr->param.local_ia_address_ptr =
 	    (struct sockaddr *)&ia_ptr->hca_ptr->hca_address;
 	/* Set the remote address pointer to the end of the EP struct */
 	ep_ptr->param.remote_ia_address_ptr = (struct sockaddr *) (ep_ptr + 1);
 
-	ep_ptr->param.pz_handle = pz_handle;
-	ep_ptr->param.recv_evd_handle = recv_evd_handle;
-	ep_ptr->param.request_evd_handle = request_evd_handle;
-	ep_ptr->param.connect_evd_handle = connect_evd_handle;
+	ep_ptr->param.pz = pz;
+	ep_ptr->param.recv_evd = recv_evd;
+	ep_ptr->param.request_evd = request_evd;
+	ep_ptr->param.connect_evd = connect_evd;
 
 	/*
 	 * Make sure we handle the NULL DTO EVDs
 	 */
-	if (recv_evd_handle == DAT_HANDLE_NULL && ep_attr == NULL) {
+	if (recv_evd == NULL && ep_attr == NULL) {
 		ep_ptr->param.ep_attr.max_recv_dtos = 0;
 	}
 
-	if (request_evd_handle == DAT_HANDLE_NULL && ep_attr == NULL) {
+	if (request_evd == NULL && ep_attr == NULL) {
 		ep_ptr->param.ep_attr.max_request_dtos = 0;
 	}
 
@@ -676,9 +647,9 @@ u32 dapl_ep_create_with_srq(DAT_IA_HANDL
 	 * As much as possible we try to keep QP creation out of the
 	 * connect path to avoid resource errors in strange places.
 	 */
-	if (pz_handle != DAT_HANDLE_NULL) {
+	if (pz != NULL) {
 		/* Take a reference on the PZ handle */
-		atomic_inc(&((struct dapl_pz *)pz_handle)->pz_ref_count);
+		atomic_inc(&((struct dapl_pz *)pz)->pz_ref_count);
 
 		/*
 		 * Get a QP from the IB provider
@@ -686,7 +657,7 @@ u32 dapl_ep_create_with_srq(DAT_IA_HANDL
 		dat_status = dapl_ib_qp_alloc(ia_ptr, ep_ptr, ep_ptr);
 
 		if (dat_status != DAT_SUCCESS) {
-			atomic_dec(&((struct dapl_pz *)pz_handle)->pz_ref_count);
+			atomic_dec(&((struct dapl_pz *)pz)->pz_ref_count);
 			dapl_ep_dealloc(ep_ptr);
 			goto bail;
 		}
@@ -696,24 +667,24 @@ u32 dapl_ep_create_with_srq(DAT_IA_HANDL
 	/*
 	 * Update ref counts. See the spec where the endpoint marks
 	 * a data object as 'in use'
-	 *   pz_handle: dat_pz_free, 
-	 *   evd_handles:
+	 *   pz: dat_pz_free, 
+	 *   evds:
 	 *
 	 * N.B. This should really be done by a util routine.
 	 */
-	atomic_inc(&((struct dapl_evd *)connect_evd_handle)->evd_ref_count);
+	atomic_inc(&((struct dapl_evd *)connect_evd)->evd_ref_count);
 	/* Optional handles */
-	if (recv_evd_handle != DAT_HANDLE_NULL)
-		atomic_inc(&((struct dapl_evd *)recv_evd_handle)->
+	if (recv_evd != NULL)
+		atomic_inc(&((struct dapl_evd *)recv_evd)->
 				   evd_ref_count);
-	if (request_evd_handle != DAT_HANDLE_NULL)
-		atomic_inc(&((struct dapl_evd *)request_evd_handle)->
+	if (request_evd != NULL)
+		atomic_inc(&((struct dapl_evd *)request_evd)->
 				   evd_ref_count);
 
 	/* Link it onto the IA */
 	dapl_ia_link_ep(ia_ptr, ep_ptr);
 
-	*ep_handle = ep_ptr;
+	*ep = ep_ptr;
 
 #endif				/* notdef */
 
@@ -721,7 +692,7 @@ bail:
 	return dat_status;
 }
 
-u32 dapl_ep_free(DAT_EP_HANDLE ep_handle)
+u32 dapl_ep_free(struct dat_ep *ep)
 {
 	struct dapl_ep *ep_ptr;
 	struct dapl_ia *ia_ptr;
@@ -729,15 +700,15 @@ u32 dapl_ep_free(DAT_EP_HANDLE ep_handle
 	enum ib_qp_state save_qp_state;
 	u32 dat_status = DAT_SUCCESS;
 
-	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_ep_free (%p)\n", ep_handle);
+	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_ep_free (%p)\n", ep);
 
-	ep_ptr = (struct dapl_ep *)ep_handle;
+	ep_ptr = (struct dapl_ep *)ep;
 	param = &ep_ptr->param;
 
 	/*
 	 * Verify parameter & state
 	 */
-	if (DAPL_BAD_HANDLE(ep_ptr, DAPL_MAGIC_EP)) {
+	if (!ep_ptr) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 		goto bail;
@@ -755,7 +726,7 @@ u32 dapl_ep_free(DAT_EP_HANDLE ep_handle
 		goto bail;
 	}
 
-	ia_ptr = ep_ptr->header.owner_ia;
+	ia_ptr = ep_ptr->common.owner_ia;
 
 	/* If we are connected, issue a disconnect. If we are in the
 	 * disconnect_pending state, disconnect with the ABRUPT flag
@@ -765,14 +736,15 @@ u32 dapl_ep_free(DAT_EP_HANDLE ep_handle
 	/*
 	 * Invoke ep_disconnect to clean up outstanding connections
 	 */
-	(void)dapl_ep_disconnect(ep_ptr, DAT_CLOSE_ABRUPT_FLAG);
+	(void)dapl_ep_disconnect((struct dat_ep *)ep_ptr,
+				 DAT_CLOSE_ABRUPT_FLAG);
 	dapl_os_assert(ep_ptr->param.ep_state == DAT_EP_STATE_DISCONNECTED ||
 		       ep_ptr->param.ep_state == DAT_EP_STATE_UNCONNECTED);
 
 	/*
 	 * Do verification of parameters and the state change atomically.
 	 */
-	spin_lock_irqsave(&ep_ptr->header.lock, ep_ptr->header.flags);
+	spin_lock_irqsave(&ep_ptr->common.lock, ep_ptr->common.flags);
 
 	/* Remove the EP from the IA */
 	dapl_ia_unlink_ep(ia_ptr, ep_ptr);
@@ -782,24 +754,24 @@ u32 dapl_ep_free(DAT_EP_HANDLE ep_handle
 	 * to set handles to NULL. Set handles to NULL so this routine
 	 * is idempotent.
 	 */
-	if (param->pz_handle != NULL) {
-		atomic_dec(&((struct dapl_pz *)param->pz_handle)->pz_ref_count);
-		param->pz_handle = NULL;
+	if (param->pz != NULL) {
+		atomic_dec(&((struct dapl_pz *)param->pz)->pz_ref_count);
+		param->pz = NULL;
 	}
-	if (param->recv_evd_handle != NULL) {
-		atomic_dec(&((struct dapl_evd *)param->recv_evd_handle)->
+	if (param->recv_evd != NULL) {
+		atomic_dec(&((struct dapl_evd *)param->recv_evd)->
 				   evd_ref_count);
-		param->recv_evd_handle = NULL;
+		param->recv_evd = NULL;
 	}
-	if (param->request_evd_handle != NULL) {
-		atomic_dec(&((struct dapl_evd *)param->request_evd_handle)->
+	if (param->request_evd != NULL) {
+		atomic_dec(&((struct dapl_evd *)param->request_evd)->
 				   evd_ref_count);
-		param->request_evd_handle = NULL;
+		param->request_evd = NULL;
 	}
-	if (param->connect_evd_handle != NULL) {
-		atomic_dec(&((struct dapl_evd *)param->connect_evd_handle)->
+	if (param->connect_evd != NULL) {
+		atomic_dec(&((struct dapl_evd *)param->connect_evd)->
 				   evd_ref_count);
-		param->connect_evd_handle = NULL;
+		param->connect_evd = NULL;
 	}
 
 	/*
@@ -815,7 +787,7 @@ u32 dapl_ep_free(DAT_EP_HANDLE ep_handle
 	 */
 	save_qp_state = ep_ptr->qp_state;
 	ep_ptr->qp_state = DAPL_QP_STATE_UNATTACHED;
-	spin_unlock_irqrestore(&ep_ptr->header.lock, ep_ptr->header.flags);
+	spin_unlock_irqrestore(&ep_ptr->common.lock, ep_ptr->common.flags);
 
 	/* Free the QP. If the EP has never been used, the QP is invalid */
 	if (save_qp_state != DAPL_QP_STATE_UNATTACHED) {
@@ -839,7 +811,7 @@ bail:
 
 }
 
-u32 dapl_ep_connect(DAT_EP_HANDLE ep_handle,
+u32 dapl_ep_connect(struct dat_ep *ep,
 		    struct sockaddr *remote_ia_address,
 		    DAT_CONN_QUAL remote_conn_qual, unsigned long timeout,
 		    int private_data_size, const void *private_data,
@@ -850,7 +822,7 @@ u32 dapl_ep_connect(DAT_EP_HANDLE ep_han
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API | DAPL_DBG_TYPE_CM,
 		     "dapl_ep_connect(%p, {%u.%u.%u.%u}, %X, %d, %d, %p, %x, %x)\n",
-		     ep_handle,
+		     ep,
 		     remote_ia_address->sa_data[2],
 		     remote_ia_address->sa_data[3],
 		     remote_ia_address->sa_data[4],
@@ -858,19 +830,19 @@ u32 dapl_ep_connect(DAT_EP_HANDLE ep_han
 		     remote_conn_qual, timeout, private_data_size, private_data,
 		     qos, connect_flags);
 
-	ep_ptr = (struct dapl_ep *)ep_handle;
+	ep_ptr = (struct dapl_ep *)ep;
 
 	/*
 	 * Verify parameter & state. The connection handle must be good
 	 * at this point.
 	 */
-	if (DAPL_BAD_HANDLE(ep_ptr, DAPL_MAGIC_EP)) {
+	if (!ep_ptr) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 		goto bail;
 	}
 
-	if (DAPL_BAD_HANDLE(ep_ptr->param.connect_evd_handle, DAPL_MAGIC_EVD)) {
+	if (!ep_ptr->param.connect_evd) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_CONN);
 		goto bail;
@@ -900,9 +872,7 @@ u32 dapl_ep_connect(DAT_EP_HANDLE ep_han
 	 *  * Assign the QP and release the lock.
 	 */
 	if (ep_ptr->qp_state == DAPL_QP_STATE_UNATTACHED) {
-		if (ep_ptr->param.pz_handle == NULL
-		    || DAPL_BAD_HANDLE(ep_ptr->param.pz_handle, DAPL_MAGIC_PZ))
-		{
+		if (ep_ptr->param.pz == NULL) {
 			dat_status =
 			    DAT_ERROR(DAT_INVALID_STATE,
 				      DAT_INVALID_STATE_EP_NOTREADY);
@@ -910,7 +880,7 @@ u32 dapl_ep_connect(DAT_EP_HANDLE ep_han
 		}
 		alloc_ep = *ep_ptr;
 
-		dat_status = dapl_ib_qp_alloc(ep_ptr->header.owner_ia,
+		dat_status = dapl_ib_qp_alloc(ep_ptr->common.owner_ia,
 					      &alloc_ep, ep_ptr);
 		if (dat_status != DAT_SUCCESS) {
 			dat_status =
@@ -919,15 +889,15 @@ u32 dapl_ep_connect(DAT_EP_HANDLE ep_han
 			goto bail;
 		}
 
-		spin_lock_irqsave(&ep_ptr->header.lock, ep_ptr->header.flags);
+		spin_lock_irqsave(&ep_ptr->common.lock, ep_ptr->common.flags);
 		/*
 		 * PZ shouldn't have changed since we're only racing with
 		 * dapl_cr_accept()
 		 */
 		if (ep_ptr->qp_state != DAPL_QP_STATE_UNATTACHED) {
 			/* Bail, cleaning up.  */
-			spin_unlock_irqrestore(&ep_ptr->header.lock, 
-					       ep_ptr->header.flags);
+			spin_unlock_irqrestore(&ep_ptr->common.lock, 
+					       ep_ptr->common.flags);
 			dat_status = dapl_ib_qp_free(&alloc_ep);
 			if (dat_status != DAT_SUCCESS) {
 				dapl_dbg_log(DAPL_DBG_TYPE_WARN,
@@ -943,42 +913,30 @@ u32 dapl_ep_connect(DAT_EP_HANDLE ep_han
 		ep_ptr->qp = alloc_ep.qp;
 		ep_ptr->qp_state = alloc_ep.qp_state;
 
-		spin_unlock_irqrestore(&ep_ptr->header.lock, 
-				       ep_ptr->header.flags);
+		spin_unlock_irqrestore(&ep_ptr->common.lock, 
+				       ep_ptr->common.flags);
 	}
 
 	/*
 	 * We do state checks and transitions under lock.
 	 * The only code we're racing against is dapl_cr_accept.
 	 */
-	spin_lock_irqsave(&ep_ptr->header.lock, ep_ptr->header.flags);
+	spin_lock_irqsave(&ep_ptr->common.lock, ep_ptr->common.flags);
 
 	/*
 	 * Verify the attributes of the EP handle before we connect it. Test
 	 * all of the handles to make sure they are currently valid.
 	 * Specifically:
-	 *   pz_handle              required
-	 *   recv_evd_handle        optional, but must be valid
-	 *   request_evd_handle     optional, but must be valid
-	 *   connect_evd_handle     required
-	 */
-	if (ep_ptr->param.pz_handle == NULL
-	    || DAPL_BAD_HANDLE(ep_ptr->param.pz_handle, DAPL_MAGIC_PZ)
-	    /* test connect handle */
-	    || ep_ptr->param.connect_evd_handle == NULL
-	    || DAPL_BAD_HANDLE(ep_ptr->param.connect_evd_handle, DAPL_MAGIC_EVD)
-	    || !(((struct dapl_evd *)ep_ptr->param.connect_evd_handle)->
-		 evd_flags & DAT_EVD_CONNECTION_FLAG)
-	    /* test optional completion handles */
-	    || (ep_ptr->param.recv_evd_handle != DAT_HANDLE_NULL &&
-		(DAPL_BAD_HANDLE
-		 (ep_ptr->param.recv_evd_handle, DAPL_MAGIC_EVD)))
-	    || (ep_ptr->param.request_evd_handle != DAT_HANDLE_NULL
-		&&
-		(DAPL_BAD_HANDLE
-		 (ep_ptr->param.request_evd_handle, DAPL_MAGIC_EVD)))) {
-		spin_unlock_irqrestore(&ep_ptr->header.lock, 
-				       ep_ptr->header.flags);
+	 *   pz              required
+	 *   recv_evd        optional, but must be valid
+	 *   request_evd     optional, but must be valid
+	 *   connect_evd     required
+	 */
+	if (ep_ptr->param.pz == NULL || ep_ptr->param.connect_evd == NULL
+	    || !(((struct dapl_evd *)ep_ptr->param.connect_evd)->
+		 evd_flags & DAT_EVD_CONNECTION_FLAG)) {
+		spin_unlock_irqrestore(&ep_ptr->common.lock, 
+				       ep_ptr->common.flags);
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_STATE, DAT_INVALID_STATE_EP_NOTREADY);
 		goto bail;
@@ -988,12 +946,12 @@ u32 dapl_ep_connect(DAT_EP_HANDLE ep_han
 	 *  we need to attach one now.
 	 */
 	if (ep_ptr->qp_state == DAPL_QP_STATE_UNATTACHED) {
-		dat_status = dapl_ib_qp_alloc(ep_ptr->header.owner_ia,
+		dat_status = dapl_ib_qp_alloc(ep_ptr->common.owner_ia,
 					      ep_ptr, ep_ptr);
 
 		if (dat_status != DAT_SUCCESS) {
-			spin_unlock_irqrestore(&ep_ptr->header.lock,
-					       ep_ptr->header.flags);
+			spin_unlock_irqrestore(&ep_ptr->common.lock,
+					       ep_ptr->common.flags);
 			dat_status =
 			    DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,
 				      DAT_RESOURCE_TEP);
@@ -1002,8 +960,8 @@ u32 dapl_ep_connect(DAT_EP_HANDLE ep_han
 	}
 
 	if (ep_ptr->param.ep_state != DAT_EP_STATE_UNCONNECTED) {
-		spin_unlock_irqrestore(&ep_ptr->header.lock,
-				       ep_ptr->header.flags);
+		spin_unlock_irqrestore(&ep_ptr->common.lock,
+				       ep_ptr->common.flags);
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_STATE, dapl_ep_state_subtype(ep_ptr));
 		goto bail;
@@ -1014,8 +972,8 @@ u32 dapl_ep_connect(DAT_EP_HANDLE ep_han
 		/*
 		 * At this point we only support one QOS level
 		 */
-		spin_unlock_irqrestore(&ep_ptr->header.lock,
-				       ep_ptr->header.flags);
+		spin_unlock_irqrestore(&ep_ptr->common.lock,
+				       ep_ptr->common.flags);
 		dat_status = DAT_ERROR(DAT_MODEL_NOT_SUPPORTED, 0);
 		goto bail;
 	}
@@ -1029,7 +987,7 @@ u32 dapl_ep_connect(DAT_EP_HANDLE ep_han
 	 * At this point we're committed, and done with the endpoint
 	 * except for the connect, so we can drop the lock.
 	 */
-	spin_unlock_irqrestore(&ep_ptr->header.lock, ep_ptr->header.flags);
+	spin_unlock_irqrestore(&ep_ptr->common.lock, ep_ptr->common.flags);
 
 	/* Copy the connection qualifiers */
 	memcpy(ep_ptr->param.remote_ia_address_ptr, remote_ia_address,
@@ -1037,7 +995,7 @@ u32 dapl_ep_connect(DAT_EP_HANDLE ep_han
 	ep_ptr->param.remote_port_qual = remote_conn_qual;
 	memcpy(ep_ptr->private_data,private_data,private_data_size);
 
-	dat_status = dapl_ib_connect(ep_ptr, remote_ia_address,
+	dat_status = dapl_ib_connect((struct dat_ep *)ep_ptr, remote_ia_address,
 				     remote_conn_qual, timeout, 
 				     private_data_size, ep_ptr->private_data);
 
@@ -1054,10 +1012,10 @@ u32 dapl_ep_connect(DAT_EP_HANDLE ep_han
 		if (dat_status == DAT_ERROR(DAT_INTERNAL_ERROR, 1)) {
 			dapl_evd_post_connection_event((struct dapl_evd *)
 						       ep_ptr->param.
-						       connect_evd_handle,
+						       connect_evd,
 						       DAT_CONNECTION_EVENT_UNREACHABLE,
-						       (DAT_HANDLE) ep_ptr, 0,
-						       NULL);
+						       (struct dat_ep *)ep_ptr,
+						       0, NULL);
 			dat_status = DAT_SUCCESS;
 		}
 	} 
@@ -1069,7 +1027,7 @@ bail:
 	return dat_status;
 }
 
-u32 dapl_ep_dup_connect(DAT_EP_HANDLE ep_handle, DAT_EP_HANDLE ep_dup_handle,
+u32 dapl_ep_dup_connect(struct dat_ep *ep, struct dat_ep *ep_dup,
 			unsigned long timeout, int private_data_size,
 			const void *private_data, enum dat_qos qos)
 {
@@ -1078,13 +1036,13 @@ u32 dapl_ep_dup_connect(DAT_EP_HANDLE ep
 	DAT_CONN_QUAL remote_conn_qual;
 	u32 dat_status;
 
-	ep_dup_ptr = (struct dapl_ep *)ep_dup_handle;
+	ep_dup_ptr = (struct dapl_ep *)ep_dup;
 
 	/*
 	 * Verify the dup handle, which must be connected. All other
 	 * parameters will be verified by dapl_ep_connect
 	 */
-	if (DAPL_BAD_HANDLE(ep_dup_handle, DAPL_MAGIC_EP)) {
+	if (!ep_dup) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 		goto bail;
@@ -1100,10 +1058,10 @@ u32 dapl_ep_dup_connect(DAT_EP_HANDLE ep
 	 *  there is a problem.  Do this under a lock and pull out
 	 * the connection parameters for atomicity.
 	 */
-	spin_lock_irqsave(&ep_dup_ptr->header.lock, ep_dup_ptr->header.flags);
+	spin_lock_irqsave(&ep_dup_ptr->common.lock, ep_dup_ptr->common.flags);
 	if (ep_dup_ptr->param.ep_state != DAT_EP_STATE_CONNECTED) {
-		spin_unlock_irqrestore(&ep_dup_ptr->header.lock,
-				       ep_dup_ptr->header.flags);
+		spin_unlock_irqrestore(&ep_dup_ptr->common.lock,
+				       ep_dup_ptr->common.flags);
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_STATE,
 			      dapl_ep_state_subtype(ep_dup_ptr));
@@ -1111,10 +1069,10 @@ u32 dapl_ep_dup_connect(DAT_EP_HANDLE ep
 	}
 	remote_ia_address_ptr = ep_dup_ptr->param.remote_ia_address_ptr;
 	remote_conn_qual = ep_dup_ptr->param.remote_port_qual;
-	spin_unlock_irqrestore(&ep_dup_ptr->header.lock, 
-			       ep_dup_ptr->header.flags);
+	spin_unlock_irqrestore(&ep_dup_ptr->common.lock, 
+			       ep_dup_ptr->common.flags);
 
-	dat_status = dapl_ep_connect(ep_handle,
+	dat_status = dapl_ep_connect(ep,
 				     remote_ia_address_ptr,
 				     remote_conn_qual,
 				     timeout,
@@ -1125,7 +1083,7 @@ bail:
 	return dat_status;
 }
 
-u32 dapl_ep_disconnect(DAT_EP_HANDLE ep_handle,
+u32 dapl_ep_disconnect(struct dat_ep *ep,
 		       enum dat_close_flags disconnect_flags)
 {
 	struct dapl_ep *ep_ptr;
@@ -1135,14 +1093,14 @@ u32 dapl_ep_disconnect(DAT_EP_HANDLE ep_
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API | DAPL_DBG_TYPE_CM,
 		     "dapl_ep_disconnect (%p, %x)\n",
-		     ep_handle, disconnect_flags);
+		     ep, disconnect_flags);
 
-	ep_ptr = (struct dapl_ep *)ep_handle;
+	ep_ptr = (struct dapl_ep *)ep;
 
 	/*
 	 * Verify parameter & state
 	 */
-	if (DAPL_BAD_HANDLE(ep_ptr, DAPL_MAGIC_EP)) {
+	if (!ep_ptr) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 		goto bail;
@@ -1152,12 +1110,12 @@ u32 dapl_ep_disconnect(DAT_EP_HANDLE ep_
 	 * Do the verification of parameters and the state change
 	 * atomically.
 	 */
-	spin_lock_irqsave(&ep_ptr->header.lock, ep_ptr->header.flags);
+	spin_lock_irqsave(&ep_ptr->common.lock, ep_ptr->common.flags);
 
 	/* Disconnecting a disconnected EP is a no-op. */
 	if (ep_ptr->param.ep_state == DAT_EP_STATE_DISCONNECTED) {
-		spin_unlock_irqrestore(&ep_ptr->header.lock, 
-				       ep_ptr->header.flags);
+		spin_unlock_irqrestore(&ep_ptr->common.lock, 
+				       ep_ptr->common.flags);
 		dat_status = DAT_SUCCESS;
 		goto bail;
 	}
@@ -1171,8 +1129,8 @@ u32 dapl_ep_disconnect(DAT_EP_HANDLE ep_
 	    ep_ptr->param.ep_state != DAT_EP_STATE_ACTIVE_CONNECTION_PENDING &&
 	    ep_ptr->param.ep_state != DAT_EP_STATE_COMPLETION_PENDING &&
 	    ep_ptr->param.ep_state != DAT_EP_STATE_DISCONNECT_PENDING) {
-		spin_unlock_irqrestore(&ep_ptr->header.lock,
-				       ep_ptr->header.flags);
+		spin_unlock_irqrestore(&ep_ptr->common.lock,
+				       ep_ptr->common.flags);
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_STATE, dapl_ep_state_subtype(ep_ptr));
 		goto bail;
@@ -1184,8 +1142,8 @@ u32 dapl_ep_disconnect(DAT_EP_HANDLE ep_
 		 * If in state DISCONNECT_PENDING then this must be an
 		 * ABRUPT disconnect
 		 */
-		spin_unlock_irqrestore(&ep_ptr->header.lock,
-				       ep_ptr->header.flags);
+		spin_unlock_irqrestore(&ep_ptr->common.lock,
+				       ep_ptr->common.flags);
 		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG2);
 		goto bail;
 	}
@@ -1198,18 +1156,19 @@ u32 dapl_ep_disconnect(DAT_EP_HANDLE ep_
 		 */
 		ep_ptr->param.ep_state = DAT_EP_STATE_DISCONNECTED;
 
-		spin_unlock_irqrestore(&ep_ptr->header.lock,
-				       ep_ptr->header.flags);
+		spin_unlock_irqrestore(&ep_ptr->common.lock,
+				       ep_ptr->common.flags);
 		/* disconnect and make sure we get no callbacks */
 		(void)dapl_ib_disconnect(ep_ptr, DAT_CLOSE_ABRUPT_FLAG);
 
 		/* clean up connection state */
 		dapl_sp_remove_ep(ep_ptr);
 
-		evd_ptr = (struct dapl_evd *)ep_ptr->param.connect_evd_handle;
+		evd_ptr = (struct dapl_evd *)ep_ptr->param.connect_evd;
 		dapl_evd_post_connection_event(evd_ptr,
 					       DAT_CONNECTION_EVENT_DISCONNECTED,
-					       (DAT_HANDLE) ep_ptr, 0, NULL);
+					       (struct dat_ep *)ep_ptr, 0,
+					       NULL);
 		dat_status = DAT_SUCCESS;
 		goto bail;
 	}
@@ -1227,14 +1186,14 @@ u32 dapl_ep_disconnect(DAT_EP_HANDLE ep_
 	if (ep_ptr->param.ep_state == DAT_EP_STATE_CONNECTED) {
 		ep_ptr->param.ep_state = DAT_EP_STATE_DISCONNECT_PENDING;
 	}
-	spin_unlock_irqrestore(&ep_ptr->header.lock, ep_ptr->header.flags);
+	spin_unlock_irqrestore(&ep_ptr->common.lock, ep_ptr->common.flags);
 	dat_status = dapl_ib_disconnect(ep_ptr, disconnect_flags);
 
 	/*
 	 * Reacquire the lock and make sure we didn't get a callback
 	 * that cleaned up.
 	 */
-	spin_lock_irqsave(&ep_ptr->header.lock, ep_ptr->header.flags);
+	spin_lock_irqsave(&ep_ptr->common.lock, ep_ptr->common.flags);
 	if (disconnect_flags == DAT_CLOSE_ABRUPT_FLAG &&
 	    ep_ptr->param.ep_state == DAT_EP_STATE_DISCONNECT_PENDING) {
 		/*
@@ -1245,8 +1204,8 @@ u32 dapl_ep_disconnect(DAT_EP_HANDLE ep_
 		 * on the way out.
 		 */
 		cr_ptr = ep_ptr->cr_ptr;
-		spin_unlock_irqrestore(&ep_ptr->header.lock, 
-				       ep_ptr->header.flags);
+		spin_unlock_irqrestore(&ep_ptr->common.lock, 
+				       ep_ptr->common.flags);
 
 		if (cr_ptr != NULL) {
 			dapl_dbg_log(DAPL_DBG_TYPE_API | DAPL_DBG_TYPE_CM,
@@ -1257,13 +1216,13 @@ u32 dapl_ep_disconnect(DAT_EP_HANDLE ep_
 					 DAT_CONNECTION_EVENT_DISCONNECTED,
 					 NULL, cr_ptr->sp_ptr);
 		} else {
-			dapl_evd_connection_callback(ep_ptr->cm_handle,
+			dapl_evd_connection_callback(ep_ptr->cm,
 						     DAT_CONNECTION_EVENT_DISCONNECTED,
 						     NULL, ep_ptr);
 		}
 	} else 
-		spin_unlock_irqrestore(&ep_ptr->header.lock, 
-				       ep_ptr->header.flags);
+		spin_unlock_irqrestore(&ep_ptr->common.lock, 
+				       ep_ptr->common.flags);
 
       bail:
 	dapl_dbg_log(DAPL_DBG_TYPE_RTN | DAPL_DBG_TYPE_CM,
@@ -1272,7 +1231,7 @@ u32 dapl_ep_disconnect(DAT_EP_HANDLE ep_
 	return dat_status;
 }
 
-u32 dapl_ep_get_status(DAT_EP_HANDLE ep_handle, enum dat_ep_state *ep_state,
+u32 dapl_ep_get_status(struct dat_ep *ep, enum dat_ep_state *ep_state,
 		       boolean_t *in_dto_idle, boolean_t *out_dto_idle)
 {
 	struct dapl_ep *ep_ptr;
@@ -1280,14 +1239,14 @@ u32 dapl_ep_get_status(DAT_EP_HANDLE ep_
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API,
 		     "dapl_ep_get_status (%p, %p, %p, %p)\n",
-		     ep_handle, ep_state, in_dto_idle, out_dto_idle);
+		     ep, ep_state, in_dto_idle, out_dto_idle);
 
-	ep_ptr = (struct dapl_ep *)ep_handle;
+	ep_ptr = (struct dapl_ep *)ep;
 
 	/*
 	 * Verify parameter & state
 	 */
-	if (DAPL_BAD_HANDLE(ep_ptr, DAPL_MAGIC_EP)) {
+	if (!ep_ptr) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 		goto bail;
@@ -1315,15 +1274,15 @@ u32 dapl_ep_get_status(DAT_EP_HANDLE ep_
 }
 
 static inline u32
-dapl_ep_modify_validate_parameters(DAT_EP_HANDLE ep_handle,
+dapl_ep_modify_validate_parameters(struct dat_ep *ep,
 				   enum dat_ep_param_mask mask,
 				   const struct dat_ep_param *ep_param,
 				   struct dapl_ia **ia_ptr,
 				   struct dapl_ep **ep_ptr,
 				   struct dat_ep_attr *ep_attr_ptr)
 {
-	struct dapl_ia *ia;
-	struct dapl_ep *ep;
+	struct dapl_ia *dapl_ia;
+	struct dapl_ep *dapl_ep;
 	struct dat_ep_attr ep_attr;
 	struct dat_ep_attr ep_attr_limit;
 	struct dat_ep_attr ep_attr_request;
@@ -1332,14 +1291,14 @@ dapl_ep_modify_validate_parameters(DAT_E
 	*ia_ptr = NULL;
 	*ep_ptr = NULL;
 
-	if (DAPL_BAD_HANDLE(ep_handle, DAPL_MAGIC_EP)) {
+	if (!ep) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 		goto bail;
 	}
 
-	ep = (struct dapl_ep *)ep_handle;
-	ia = ep->header.owner_ia;
+	dapl_ep = (struct dapl_ep *)ep;
+	dapl_ia = dapl_ep->common.owner_ia;
 
 	/*
 	 * Verify parameters valid in current EP state
@@ -1359,10 +1318,10 @@ dapl_ep_modify_validate_parameters(DAT_E
 	 * TENTATIVE_CONNECTION_PENDING (psp PROVIDER allocated EP)
 	 */
 	if ((mask & DAT_EP_FIELD_PZ_HANDLE) &&
-	    (ep->param.ep_state != DAT_EP_STATE_UNCONNECTED &&
-	     ep->param.ep_state != DAT_EP_STATE_TENTATIVE_CONNECTION_PENDING)) {
-		dat_status =
-		    DAT_ERROR(DAT_INVALID_STATE, dapl_ep_state_subtype(ep));
+	    (dapl_ep->param.ep_state != DAT_EP_STATE_UNCONNECTED &&
+	     dapl_ep->param.ep_state != DAT_EP_STATE_TENTATIVE_CONNECTION_PENDING)) {
+		dat_status = DAT_ERROR(DAT_INVALID_STATE,
+				       dapl_ep_state_subtype(dapl_ep));
 		goto bail;
 	}
 
@@ -1378,41 +1337,21 @@ dapl_ep_modify_validate_parameters(DAT_E
 			      DAT_EP_FIELD_EP_ATTR_MAX_REQUEST_DTOS |
 			      DAT_EP_FIELD_EP_ATTR_MAX_RECV_IOV |
 			      DAT_EP_FIELD_EP_ATTR_MAX_REQUEST_IOV)) &&
-	    (ep->param.ep_state != DAT_EP_STATE_UNCONNECTED &&
-	     ep->param.ep_state != DAT_EP_STATE_RESERVED &&
-	     ep->param.ep_state != DAT_EP_STATE_TENTATIVE_CONNECTION_PENDING)) {
-		dat_status =
-		    DAT_ERROR(DAT_INVALID_STATE, dapl_ep_state_subtype(ep));
+	    (dapl_ep->param.ep_state != DAT_EP_STATE_UNCONNECTED &&
+	     dapl_ep->param.ep_state != DAT_EP_STATE_RESERVED &&
+	     dapl_ep->param.ep_state != DAT_EP_STATE_TENTATIVE_CONNECTION_PENDING)) {
+		dat_status = DAT_ERROR(DAT_INVALID_STATE,
+				       dapl_ep_state_subtype(dapl_ep));
 		goto bail;
 	}
 
 	/*
 	 * Validate handles being modified
 	 */
-	if (mask & DAT_EP_FIELD_PZ_HANDLE) {
-		if (ep_param->pz_handle != NULL &&
-		    DAPL_BAD_HANDLE(ep_param->pz_handle, DAPL_MAGIC_PZ)) {
-			dat_status =
-			    DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3);
-			goto bail;
-		}
-	}
-
 	if (mask & DAT_EP_FIELD_RECV_EVD_HANDLE) {
-		if (ep_param->recv_evd_handle != NULL &&
-		    (DAPL_BAD_HANDLE(ep_param->recv_evd_handle, DAPL_MAGIC_EVD)
-		     || !((struct dapl_evd *)ep_param->recv_evd_handle)->
-		     evd_flags & DAT_EVD_DTO_FLAG)) {
-			dat_status =
-			    DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3);
-			goto bail;
-		}
-	}
-
-	if (mask & DAT_EP_FIELD_REQUEST_EVD_HANDLE) {
-		if (ep_param->request_evd_handle != NULL &&
-		    DAPL_BAD_HANDLE(ep_param->request_evd_handle,
-				    DAPL_MAGIC_EVD)) {
+		if (ep_param->recv_evd != NULL &&
+		    !((struct dapl_evd *)ep_param->recv_evd)->
+		     evd_flags & DAT_EVD_DTO_FLAG) {
 			dat_status =
 			    DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3);
 			goto bail;
@@ -1420,10 +1359,8 @@ dapl_ep_modify_validate_parameters(DAT_E
 	}
 
 	if (mask & DAT_EP_FIELD_CONNECT_EVD_HANDLE) {
-		if (ep_param->connect_evd_handle != NULL &&
-		    DAPL_BAD_HANDLE(ep_param->connect_evd_handle,
-				    DAPL_MAGIC_EVD)
-		    && !(((struct dapl_evd *)ep_param->connect_evd_handle)->
+		if (ep_param->connect_evd != NULL &&
+		    !(((struct dapl_evd *)ep_param->connect_evd)->
 			 evd_flags & DAT_EVD_CONNECTION_FLAG)) {
 			dat_status =
 			    DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3);
@@ -1434,8 +1371,8 @@ dapl_ep_modify_validate_parameters(DAT_E
 	/*
 	 * Validate the attributes against the HCA limits
 	 */
-	ep_attr = ep->param.ep_attr;
-	ep_attr_limit = ia->hca_ptr->ep_attr;
+	ep_attr = dapl_ep->param.ep_attr;
+	ep_attr_limit = dapl_ia->hca_ptr->ep_attr;
 	ep_attr_request = ep_param->ep_attr;
 
 	if (mask & DAT_EP_FIELD_EP_ATTR_MAX_MESSAGE_SIZE) {
@@ -1482,7 +1419,7 @@ dapl_ep_modify_validate_parameters(DAT_E
 
 	if (mask & DAT_EP_FIELD_EP_ATTR_MAX_RECV_DTOS) {
 		if (ep_attr_request.max_recv_dtos > ep_attr_limit.max_recv_dtos
-		    || (ep_param->recv_evd_handle == DAT_HANDLE_NULL
+		    || (ep_param->recv_evd == NULL
 			&& (ep_attr_request.max_recv_dtos > 0))) {
 			dat_status =
 			    DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3);
@@ -1495,7 +1432,7 @@ dapl_ep_modify_validate_parameters(DAT_E
 	if (mask & DAT_EP_FIELD_EP_ATTR_MAX_REQUEST_DTOS) {
 		if (ep_attr_request.max_request_dtos >
 		    ep_attr_limit.max_request_dtos
-		    || (ep_param->request_evd_handle == DAT_HANDLE_NULL
+		    || (ep_param->request_evd == NULL
 			&& (ep_attr_request.max_request_dtos > 0))) {
 			dat_status =
 			    DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3);
@@ -1552,15 +1489,15 @@ dapl_ep_modify_validate_parameters(DAT_E
 		}
 	}
 
-	*ia_ptr = ia;
-	*ep_ptr = ep;
+	*ia_ptr = dapl_ia;
+	*ep_ptr = dapl_ep;
 	*ep_attr_ptr = ep_attr;
 
       bail:
 	return dat_status;
 }
 
-u32 dapl_ep_modify(DAT_EP_HANDLE ep_handle, enum dat_ep_param_mask mask,
+u32 dapl_ep_modify(struct dat_ep *ep, enum dat_ep_param_mask mask,
 		   const struct dat_ep_param *ep_param)
 {
 	struct dapl_ia *ia;
@@ -1586,7 +1523,7 @@ u32 dapl_ep_modify(DAT_EP_HANDLE ep_hand
 	boolean_t rqst_iov_used = FALSE;
 	boolean_t recv_iov_used = FALSE;
 
-	dat_status = dapl_ep_modify_validate_parameters(ep_handle,
+	dat_status = dapl_ep_modify_validate_parameters(ep,
 							mask,
 							ep_param,
 							&ia, &ep1, &ep_attr1);
@@ -1600,16 +1537,16 @@ u32 dapl_ep_modify(DAT_EP_HANDLE ep_hand
 	alloc_ep = *ep1;
 	alloc_ep.param.ep_attr = ep_attr1;
 	if (mask & DAT_EP_FIELD_PZ_HANDLE)
-		alloc_ep.param.pz_handle = ep_param->pz_handle;
+		alloc_ep.param.pz = ep_param->pz;
 
 	if (mask & DAT_EP_FIELD_RECV_EVD_HANDLE)
-		alloc_ep.param.recv_evd_handle = ep_param->recv_evd_handle;
+		alloc_ep.param.recv_evd = ep_param->recv_evd;
 
 	if (mask & DAT_EP_FIELD_REQUEST_EVD_HANDLE)
-		alloc_ep.param.request_evd_handle = ep_param->request_evd_handle;
+		alloc_ep.param.request_evd = ep_param->request_evd;
 
 	if (mask & DAT_EP_FIELD_CONNECT_EVD_HANDLE)
-		alloc_ep.param.connect_evd_handle = ep_param->connect_evd_handle;
+		alloc_ep.param.connect_evd = ep_param->connect_evd;
 
 	/*
 	 * Allocate everything that might be needed.
@@ -1673,18 +1610,18 @@ u32 dapl_ep_modify(DAT_EP_HANDLE ep_hand
 	 * There's a lot of work done here, but there should be no
 	 * allocation or blocking.
 	 */
-	spin_lock_irqsave(&ep1->header.lock, ep1->header.flags);
+	spin_lock_irqsave(&ep1->common.lock, ep1->common.flags);
 
 	/*
 	 * Revalidate parameters; make sure that races haven't
 	 * changed anything important.
 	 */
-	dat_status = dapl_ep_modify_validate_parameters(ep_handle,
+	dat_status = dapl_ep_modify_validate_parameters(ep,
 							mask,
 							ep_param,
 							&ia, &ep2, &ep_attr2);
 	if (DAT_SUCCESS != dat_status) {
-		spin_unlock_irqrestore(&ep2->header.lock, ep2->header.flags);
+		spin_unlock_irqrestore(&ep2->common.lock, ep2->common.flags);
 		goto bail;
 	}
 
@@ -1713,10 +1650,10 @@ u32 dapl_ep_modify(DAT_EP_HANDLE ep_hand
 	 * is stuff changed by dapl_cr_accept, and neither PZ nor EVD is in that
 	 * list.
 	 */
-	new_ep.param.pz_handle = alloc_ep.param.pz_handle;
-	new_ep.param.recv_evd_handle = alloc_ep.param.recv_evd_handle;
-	new_ep.param.request_evd_handle = alloc_ep.param.request_evd_handle;
-	new_ep.param.connect_evd_handle = alloc_ep.param.connect_evd_handle;
+	new_ep.param.pz = alloc_ep.param.pz;
+	new_ep.param.recv_evd = alloc_ep.param.recv_evd;
+	new_ep.param.request_evd = alloc_ep.param.request_evd;
+	new_ep.param.connect_evd = alloc_ep.param.connect_evd;
 
 	/* Deal with each of the allocation fields.  */
 	if (mask & DAT_EP_FIELD_EP_ATTR_MAX_RECV_DTOS
@@ -1778,50 +1715,50 @@ u32 dapl_ep_modify(DAT_EP_HANDLE ep_hand
 	if (DAPL_QP_STATE_UNATTACHED != new_ep.qp_state) {
 		dat_status = dapl_ib_qp_modify(ia, ep2, &ep_attr2);
 		if (dat_status != DAT_SUCCESS) {
-			spin_unlock_irqrestore(&ep2->header.lock, 
-					       ep2->header.flags);
+			spin_unlock_irqrestore(&ep2->common.lock, 
+					       ep2->common.flags);
 			goto bail;
 		}
 	}
 	*ep2 = new_ep;
 
-	spin_unlock_irqrestore(&ep2->header.lock, ep2->header.flags);
+	spin_unlock_irqrestore(&ep2->common.lock, ep2->common.flags);
 
 	/*
 	 * Modify reference counts, incrementing new ones
 	 * and then decrementing old ones (so if they're the same
 	 * the refcount never drops to zero).
 	 */
-	tmp_pz = (struct dapl_pz *)new_ep.param.pz_handle;
+	tmp_pz = (struct dapl_pz *)new_ep.param.pz;
 	if (tmp_pz)
 		atomic_inc(&tmp_pz->pz_ref_count);
 
-	tmp_evd = (struct dapl_evd *)new_ep.param.recv_evd_handle;
+	tmp_evd = (struct dapl_evd *)new_ep.param.recv_evd;
 	if (tmp_evd)
 		atomic_inc(&tmp_evd->evd_ref_count);
 
-	tmp_evd = (struct dapl_evd *)new_ep.param.request_evd_handle;
+	tmp_evd = (struct dapl_evd *)new_ep.param.request_evd;
 	if (tmp_evd)
 		atomic_inc(&tmp_evd->evd_ref_count);
 
-	tmp_evd = (struct dapl_evd *)new_ep.param.connect_evd_handle;
+	tmp_evd = (struct dapl_evd *)new_ep.param.connect_evd;
 	if (tmp_evd)
 		atomic_inc(&tmp_evd->evd_ref_count);
 
 	/* decreament the old reference counts */
-	tmp_pz = (struct dapl_pz *)copy_of_old_ep.param.pz_handle;
+	tmp_pz = (struct dapl_pz *)copy_of_old_ep.param.pz;
 	if (tmp_pz)
 		atomic_dec(&tmp_pz->pz_ref_count);
 
-	tmp_evd = (struct dapl_evd *)copy_of_old_ep.param.recv_evd_handle;
+	tmp_evd = (struct dapl_evd *)copy_of_old_ep.param.recv_evd;
 	if (tmp_evd)
 		atomic_dec(&tmp_evd->evd_ref_count);
 
-	tmp_evd = (struct dapl_evd *)copy_of_old_ep.param.request_evd_handle;
+	tmp_evd = (struct dapl_evd *)copy_of_old_ep.param.request_evd;
 	if (tmp_evd)
 		atomic_dec(&tmp_evd->evd_ref_count);
 
-	tmp_evd = (struct dapl_evd *)copy_of_old_ep.param.connect_evd_handle;
+	tmp_evd = (struct dapl_evd *)copy_of_old_ep.param.connect_evd;
 	if (tmp_evd)
 		atomic_dec(&tmp_evd->evd_ref_count);
 
@@ -1869,7 +1806,7 @@ bail:
 	return dat_status;
 }
 
-u32 dapl_ep_post_rdma_read(DAT_EP_HANDLE ep_handle, int num_segments,
+u32 dapl_ep_post_rdma_read(struct dat_ep *ep, int num_segments,
 			   struct dat_lmr_triplet *local_iov,
 			   DAT_DTO_COOKIE user_cookie,
 			   const struct dat_rmr_triplet *remote_iov,
@@ -1880,12 +1817,12 @@ u32 dapl_ep_post_rdma_read(DAT_EP_HANDLE
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API,
 		     "dapl_ep_post_rdma_read (%p, %d, %p, %p, %p, %x)\n",
-		     ep_handle,
+		     ep,
 		     num_segments,
 		     local_iov,
 		     user_cookie.as_64, remote_iov, completion_flags);
 
-	dat_status = dapl_ep_post_send_req(ep_handle,
+	dat_status = dapl_ep_post_send_req(ep,
 					   num_segments,
 					   local_iov,
 					   user_cookie,
@@ -1900,7 +1837,7 @@ u32 dapl_ep_post_rdma_read(DAT_EP_HANDLE
 	return dat_status;
 }
 
-u32 dapl_ep_post_rdma_write(DAT_EP_HANDLE ep_handle, int num_segments,
+u32 dapl_ep_post_rdma_write(struct dat_ep *ep, int num_segments,
 			    struct dat_lmr_triplet *local_iov,
 			    DAT_DTO_COOKIE user_cookie,
 			    const struct dat_rmr_triplet *remote_iov,
@@ -1910,12 +1847,12 @@ u32 dapl_ep_post_rdma_write(DAT_EP_HANDL
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API,
 		     "dapl_ep_post_rdma_write (%p, %d, %p, %P, %p, %x)\n",
-		     ep_handle,
+		     ep,
 		     num_segments,
 		     local_iov,
 		     user_cookie.as_64, remote_iov, completion_flags);
 
-	dat_status = dapl_ep_post_send_req(ep_handle,
+	dat_status = dapl_ep_post_send_req(ep,
 					   num_segments,
 					   local_iov,
 					   user_cookie,
@@ -1930,7 +1867,7 @@ u32 dapl_ep_post_rdma_write(DAT_EP_HANDL
 	return dat_status;
 }
 
-u32 dapl_ep_post_recv(DAT_EP_HANDLE ep_handle, int num_segments,
+u32 dapl_ep_post_recv(struct dat_ep *ep, int num_segments,
 		      struct dat_lmr_triplet *local_iov,
 		      DAT_DTO_COOKIE user_cookie,
 		      enum dat_completion_flags completion_flags)
@@ -1941,15 +1878,15 @@ u32 dapl_ep_post_recv(DAT_EP_HANDLE ep_h
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API,
 		     "dapl_ep_post_recv (%p, %d, %p, %P, %x)\n",
-		     ep_handle, num_segments, local_iov, user_cookie.as_64, 
+		     ep, num_segments, local_iov, user_cookie.as_64, 
 		     completion_flags);
 
-	if (DAPL_BAD_HANDLE(ep_handle, DAPL_MAGIC_EP)) {
+	if (!ep) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 		goto bail;
 	}
 
-	ep_ptr = (struct dapl_ep *) ep_handle;
+	ep_ptr = (struct dapl_ep *) ep;
 
 	/*
 	 * Synchronization ok since this buffer is only used for receive
@@ -1979,7 +1916,7 @@ bail:
 	return status;
 }
 
-u32 dapl_ep_post_send(DAT_EP_HANDLE ep_handle, int num_segments,
+u32 dapl_ep_post_send(struct dat_ep *ep, int num_segments,
 		      struct dat_lmr_triplet *local_iov,
 		      DAT_DTO_COOKIE user_cookie,
 		      enum dat_completion_flags completion_flags)
@@ -1989,11 +1926,11 @@ u32 dapl_ep_post_send(DAT_EP_HANDLE ep_h
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API,
 		     "dapl_ep_post_send (%p, %d, %p, %P, %x)\n",
-		     ep_handle,
+		     ep,
 		     num_segments,
 		     local_iov, user_cookie.as_64, completion_flags);
 
-	dat_status = dapl_ep_post_send_req(ep_handle,
+	dat_status = dapl_ep_post_send_req(ep,
 					   num_segments,
 					   local_iov,
 					   user_cookie,
@@ -2007,21 +1944,21 @@ u32 dapl_ep_post_send(DAT_EP_HANDLE ep_h
 	return dat_status;
 }
 
-u32 dapl_ep_query(DAT_EP_HANDLE ep_handle, struct dat_ep_param *ep_param)
+u32 dapl_ep_query(struct dat_ep *ep, struct dat_ep_param *ep_param)
 {
 	struct dapl_ep *ep_ptr;
 	u32 status = DAT_SUCCESS;
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API,
 		     "dapl_ep_query (%p, %p)\n",
-		     ep_handle, ep_param);
+		     ep, ep_param);
 
-	ep_ptr = (struct dapl_ep *)ep_handle;
+	ep_ptr = (struct dapl_ep *)ep;
 
 	/*
 	 * Verify parameter & state
 	 */
-	if (DAPL_BAD_HANDLE(ep_ptr, DAPL_MAGIC_EP)) {
+	if (!ep_ptr) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 		goto bail;
 	}
@@ -2037,12 +1974,10 @@ u32 dapl_ep_query(DAT_EP_HANDLE ep_handl
 	 * N.B. Just slam all values into the user structure, there
 	 *      is nothing to be gained by checking for each bit.
 	 */
-        if (ep_ptr->param.ep_state == DAT_EP_STATE_CONNECTED) {
+        if (ep_ptr->param.ep_state == DAT_EP_STATE_CONNECTED)
             /* obtain the remote IP address */
-            status =
-                dapl_ib_cm_remote_addr((DAT_HANDLE) ep_handle,
-                                       &ep_ptr->remote_ia_address);
-        }
+            status = dapl_ib_cm_remote_addr(ep, &ep_ptr->remote_ia_address);
+
         ep_ptr->param.remote_ia_address_ptr =
             (struct sockaddr *)&ep_ptr->remote_ia_address;
         *ep_param = ep_ptr->param;
@@ -2051,21 +1986,21 @@ bail:
 	return status;
 }
 
-u32 dapl_ep_recv_query(DAT_EP_HANDLE ep_handle, int *nbufs_allocate,
+u32 dapl_ep_recv_query(struct dat_ep *ep, int *nbufs_allocate,
 		       int *bufs_alloc_span)
 {
 	struct dapl_ep *ep_ptr;
 	u32 dat_status = DAT_SUCCESS;
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_ep_recv_query (%p, %p, %p)\n",
-		     ep_handle, nbufs_allocate, bufs_alloc_span);
+		     ep, nbufs_allocate, bufs_alloc_span);
 
-	ep_ptr = (struct dapl_ep *)ep_handle;
+	ep_ptr = (struct dapl_ep *)ep;
 
 	/*
 	 * Verify parameter & state
 	 */
-	if (DAPL_BAD_HANDLE(ep_ptr, DAPL_MAGIC_EP)) {
+	if (!ep_ptr) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 		goto bail;
@@ -2078,17 +2013,17 @@ bail:
 
 }
 
-u32 dapl_ep_reset(DAT_EP_HANDLE ep_handle)
+u32 dapl_ep_reset(struct dat_ep *ep)
 {
 	struct dapl_ep *ep_ptr;
 	u32 dat_status = DAT_SUCCESS;
 
-	ep_ptr = (struct dapl_ep *)ep_handle;
+	ep_ptr = (struct dapl_ep *)ep;
 
 	/*
 	 * Verify parameter & state
 	 */
-	if (DAPL_BAD_HANDLE(ep_ptr, DAPL_MAGIC_EP)) {
+	if (!ep_ptr) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 		goto bail;
@@ -2110,7 +2045,7 @@ bail:
 	return dat_status;
 }
 
-u32 dapl_ep_set_watermark(DAT_EP_HANDLE ep_handle,
+u32 dapl_ep_set_watermark(struct dat_ep *ep,
 			  int soft_high_watermark,
 			  int hard_high_watermark)
 {
@@ -2118,14 +2053,14 @@ u32 dapl_ep_set_watermark(DAT_EP_HANDLE 
 	u32 dat_status = DAT_SUCCESS;
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_ep_set_watermark (%p, %d, %d)\n",
-		     ep_handle, soft_high_watermark, hard_high_watermark);
+		     ep, soft_high_watermark, hard_high_watermark);
 
-	ep_ptr = (struct dapl_ep *)ep_handle;
+	ep_ptr = (struct dapl_ep *)ep;
 
 	/*
 	 * Verify parameter & state
 	 */
-	if (DAPL_BAD_HANDLE(ep_ptr, DAPL_MAGIC_EP)) {
+	if (!ep_ptr) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 		goto bail;
Index: linux-kernel/dat-provider/dapl_rsp.c
===================================================================
--- linux-kernel/dat-provider/dapl_rsp.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_rsp.c	(working copy)
@@ -44,13 +44,13 @@
  * event
  *
  * Input:
- *	ia_handle
+ *	ia
  *	conn_qual
- *	ep_handle
- *	evd_handle
+ *	ep
+ *	evd
  *
  * Output:
- *	rsp_handle
+ *	rsp
  *
  * Returns:
  *	DAT_SUCCESS
@@ -59,9 +59,9 @@
  *	DAT_INVALID_STATE
  *	DAT_CONN_QUAL_IN_USE
  */
-u32 dapl_rsp_create(DAT_IA_HANDLE ia_handle, DAT_CONN_QUAL conn_qual,
-		    DAT_EP_HANDLE ep_handle, DAT_EVD_HANDLE evd_handle,
-		    DAT_RSP_HANDLE *rsp_handle)
+u32 dapl_rsp_create(struct dat_ia *ia, DAT_CONN_QUAL conn_qual,
+		    struct dat_ep *ep, struct dat_evd *evd,
+		    struct dat_sp **rsp)
 {
 	struct dapl_ia *ia_ptr;
 	struct dapl_sp *sp_ptr;
@@ -70,39 +70,39 @@ u32 dapl_rsp_create(DAT_IA_HANDLE ia_han
 	boolean_t sp_found;
 	u32 status = DAT_SUCCESS;
 
-	ia_ptr = (struct dapl_ia *)ia_handle;
+	ia_ptr = (struct dapl_ia *)ia;
 
 	dapl_dbg_log(DAPL_DBG_TYPE_CM,
 		     ">>> dapl_rsp_free conn_qual: %x EP: %p\n",
-		     conn_qual, ep_handle);
+		     conn_qual, ep);
 
-	if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
+	if (!ia_ptr) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
 		goto bail;
 	}
-	if (DAPL_BAD_HANDLE(ep_handle, DAPL_MAGIC_EP)) {
+	if (!ep) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
 		goto bail;
 	}
-	if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) {
+	if (!evd) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE,
 				   DAT_INVALID_HANDLE_EVD_CR);
 		goto bail;
 	}
 
-	if (rsp_handle == NULL) {
+	if (rsp == NULL) {
 		status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG5);
 		goto bail;
 	}
 
-	ep_ptr = (struct dapl_ep *)ep_handle;
+	ep_ptr = (struct dapl_ep *)ep;
 	if (ep_ptr->param.ep_state != DAT_EP_STATE_UNCONNECTED) {
 		status = DAT_ERROR(DAT_INVALID_STATE,
 				   dapl_ep_state_subtype(ep_ptr));
 		goto bail;
 	}
 
-	evd_ptr = (struct dapl_evd *)evd_handle;
+	evd_ptr = (struct dapl_evd *)evd;
 	if (!(evd_ptr->evd_flags & DAT_EVD_CR_FLAG)) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE,
 				   DAT_INVALID_HANDLE_EVD_CR);
@@ -126,11 +126,11 @@ u32 dapl_rsp_create(DAT_IA_HANDLE ia_han
 	/*
 	 * Fill out the RSP args
 	 */
-	sp_ptr->ia_handle = ia_handle;
+	sp_ptr->ia = ia;
 	sp_ptr->conn_qual = conn_qual;
-	sp_ptr->evd_handle = evd_handle;
+	sp_ptr->evd = evd;
 	sp_ptr->psp_flags = 0;
-	sp_ptr->ep_handle = ep_handle;
+	sp_ptr->ep = ep;
 
 	/*
 	 * Take a reference on the EVD handle
@@ -162,7 +162,7 @@ u32 dapl_rsp_create(DAT_IA_HANDLE ia_han
 			 * the state to FREE, so we know the call failed.
 			 */
 			atomic_dec(&evd_ptr->evd_ref_count);
-			sp_ptr->evd_handle = NULL;
+			sp_ptr->evd = NULL;
 			sp_ptr->state = DAPL_SP_STATE_FREE;
 			dapl_ia_unlink_sp(ia_ptr, sp_ptr);
 			dapl_sp_dealloc(sp_ptr);
@@ -178,7 +178,7 @@ u32 dapl_rsp_create(DAT_IA_HANDLE ia_han
 	/*
 	 * Return handle to the user
 	 */
-	*rsp_handle = (DAT_RSP_HANDLE)sp_ptr;
+	*rsp = (struct dat_sp *)sp_ptr;
 
 bail:
 	return status;
@@ -190,7 +190,7 @@ bail:
  * Destroy a specific instance of a Reserved Service Point.
  *
  * Input:
- *	rsp_handle
+ *	rsp
  *
  * Output:
  *	none
@@ -199,50 +199,49 @@ bail:
  *	DAT_SUCCESS
  *	DAT_INVALID_HANDLE
  */
-u32 dapl_rsp_free(DAT_RSP_HANDLE rsp_handle)
+u32 dapl_rsp_free(struct dat_sp *rsp)
 {
 	struct dapl_ia *ia_ptr;
 	struct dapl_sp *sp_ptr;
 	struct dapl_ep *ep_ptr;
 	u32 status = DAT_SUCCESS;
 
-	sp_ptr = (struct dapl_sp *)rsp_handle;
+	sp_ptr = (struct dapl_sp *)rsp;
 	/*
 	 * Verify handle
 	 */
-	dapl_dbg_log(DAPL_DBG_TYPE_CM, ">>> dapl_rsp_free %p\n", rsp_handle);
-	if (DAPL_BAD_HANDLE(sp_ptr, DAPL_MAGIC_RSP)) {
+	dapl_dbg_log(DAPL_DBG_TYPE_CM, ">>> dapl_rsp_free %p\n", rsp);
+	if (!sp_ptr) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RSP);
 		goto bail;
 	}
 
-	/* ia_ptr = (struct dapl_ia *)sp_ptr->header.owner_ia; */
-	ia_ptr = sp_ptr->header.owner_ia;
+	ia_ptr = sp_ptr->common.owner_ia;
 
 	/*
 	 * Remove the connection listener if there are no connections.  If
 	 * we defer removing the sp it becomes something of a zombie
 	 * container until disconnection, after which it will be cleaned up.
 	 */
-	spin_lock_irqsave(&sp_ptr->header.lock, sp_ptr->header.flags);
+	spin_lock_irqsave(&sp_ptr->common.lock, sp_ptr->common.flags);
 
 	/*
 	 * Make sure we don't leave a dangling EP. If the state is still
 	 * RESERVED then the RSP still owns it.
 	 */
-	ep_ptr = (struct dapl_ep *)sp_ptr->ep_handle;
+	ep_ptr = (struct dapl_ep *)sp_ptr->ep;
 	if (ep_ptr != NULL && ep_ptr->param.ep_state == DAT_EP_STATE_RESERVED)
 		ep_ptr->param.ep_state = DAT_EP_STATE_UNCONNECTED;
-	sp_ptr->ep_handle = NULL;
+	sp_ptr->ep = NULL;
 
 	/*
 	 * Release reference on EVD. If an error was encountered in a previous
-	 * free the evd_handle will be NULL
+	 * free the evd will be NULL
 	 */
-	if (sp_ptr->evd_handle) {
-		atomic_dec(&((struct dapl_evd *)sp_ptr->evd_handle)->
+	if (sp_ptr->evd) {
+		atomic_dec(&((struct dapl_evd *)sp_ptr->evd)->
 				   evd_ref_count);
-		sp_ptr->evd_handle = NULL;
+		sp_ptr->evd = NULL;
 	}
 
 	/*
@@ -258,8 +257,8 @@ u32 dapl_rsp_free(DAT_RSP_HANDLE rsp_han
 		/* This RSP has never been used. Clean it up */
 		sp_ptr->listening = FALSE;
 		sp_ptr->state = DAPL_SP_STATE_FREE;
-		spin_unlock_irqrestore(&sp_ptr->header.lock, 
-				       sp_ptr->header.flags);
+		spin_unlock_irqrestore(&sp_ptr->common.lock, 
+				       sp_ptr->common.flags);
 
 		status = dapl_ib_remove_conn_listener(ia_ptr, sp_ptr);
 		if (status != DAT_SUCCESS) {
@@ -275,20 +274,20 @@ u32 dapl_rsp_free(DAT_RSP_HANDLE rsp_han
 		 * ServiceID again, which will reactivate it.
 		 */
 		sp_ptr->state = DAPL_SP_STATE_RSP_PENDING;
-		spin_unlock_irqrestore(&sp_ptr->header.lock, 
-				       sp_ptr->header.flags);
+		spin_unlock_irqrestore(&sp_ptr->common.lock, 
+				       sp_ptr->common.flags);
 	}
 
 bail:
 	return status;
 }
 
-u32 dapl_rsp_query(DAT_RSP_HANDLE rsp_handle, struct dat_rsp_param *rsp_param)
+u32 dapl_rsp_query(struct dat_sp *rsp, struct dat_rsp_param *rsp_param)
 {
 	struct dapl_sp *sp_ptr;
 	u32 status;
 
-	if (DAPL_BAD_HANDLE(rsp_handle, DAPL_MAGIC_RSP)) {
+	if (!rsp) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RSP);
 		goto bail;
 	}
@@ -298,15 +297,15 @@ u32 dapl_rsp_query(DAT_RSP_HANDLE rsp_ha
 		goto bail;
 	}
 
-	sp_ptr = (struct dapl_sp *)rsp_handle;
+	sp_ptr = (struct dapl_sp *)rsp;
 
 	/*
 	 * Fill in the RSP params
 	 */
-	rsp_param->ia_handle = sp_ptr->ia_handle;
+	rsp_param->ia = sp_ptr->ia;
 	rsp_param->conn_qual = sp_ptr->conn_qual;
-	rsp_param->evd_handle = sp_ptr->evd_handle;
-	rsp_param->ep_handle = sp_ptr->ep_handle;
+	rsp_param->evd = sp_ptr->evd;
+	rsp_param->ep = sp_ptr->ep;
 
 	status = DAT_SUCCESS;
 
Index: linux-kernel/dat-provider/dapl_set_consumer_context.c
===================================================================
--- linux-kernel/dat-provider/dapl_set_consumer_context.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_set_consumer_context.c	(working copy)
@@ -1,74 +0,0 @@
-/*
- * 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
- *    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
- *    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 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.
- */
-
-/*
- * $Id$
- */
-
-#include "dapl.h"
-
-/*
- * dapl_set_consumer_context
- *
- * Set a consumer context in the provided dat_handle
- *
- * Input:
- *	dat_handle
- *	context
- *
- * Output:
- *	none
- *
- * Returns:
- * 	DAT_SUCCESS
- * 	DAT_INVALID_HANDLE
- */
-u32 dapl_set_consumer_context(DAT_HANDLE dat_handle, union dat_context context)
-{
-	u32 dat_status = DAT_SUCCESS;
-	struct dapl_header *header;
-
-	header = (struct dapl_header *)dat_handle;
-	if (((header) == NULL) ||
-	    ((unsigned long)(header) & 3) ||
-	    (header->magic != DAPL_MAGIC_IA &&
-	     header->magic != DAPL_MAGIC_EVD &&
-	     header->magic != DAPL_MAGIC_EP &&
-	     header->magic != DAPL_MAGIC_LMR &&
-	     header->magic != DAPL_MAGIC_RMR &&
-	     header->magic != DAPL_MAGIC_PZ &&
-	     header->magic != DAPL_MAGIC_PSP &&
-	     header->magic != DAPL_MAGIC_RSP &&
-	     header->magic != DAPL_MAGIC_CR)) {
-		dat_status = DAT_ERROR(DAT_INVALID_HANDLE, 0);
-		goto bail;
-	}
-	header->user_context = context;
-
-      bail:
-	return dat_status;
-}
Index: linux-kernel/dat-provider/dapl_ia_open.c
===================================================================
--- linux-kernel/dat-provider/dapl_ia_open.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_ia_open.c	(working copy)
@@ -45,18 +45,18 @@
  * and calls this function.
  */
 u32 dapl_ia_open(const char *name, int async_evd_qlen,
-		 DAT_EVD_HANDLE *async_evd_handle_ptr,
-		 DAT_IA_HANDLE *ia_handle_ptr)
+		 struct dat_evd **async_evd_ptr,
+		 struct dat_ia **ia_ptr)
 {
 	u32 dat_status = DAT_SUCCESS;
 	struct dat_provider *provider;
 	struct dapl_hca *hca_ptr = NULL;
-	struct dapl_ia *ia_ptr = NULL;
-	struct dapl_evd *evd_ptr;
+	struct dapl_ia *ia = NULL;
+	struct dapl_evd *evd;
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API,
 		     "dapl_ia_open (%s, %d, %p, %p)\n",
-		     name, async_evd_qlen, async_evd_handle_ptr, ia_handle_ptr);
+		     name, async_evd_qlen, async_evd_ptr, ia_ptr);
 
 	dat_status = dapl_provider_list_search(name, &provider);
 	if (DAT_SUCCESS != dat_status) {
@@ -64,25 +64,25 @@ u32 dapl_ia_open(const char *name, int a
 		goto bail;
 	}
 
-	/* ia_handle_ptr and async_evd_handle_ptr cannot be NULL */
-	if (ia_handle_ptr == NULL) {
+	/* ia_ptr and async_evd_ptr cannot be NULL */
+	if (ia_ptr == NULL) {
 		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG4);
 		goto bail;
 	}
-	if (async_evd_handle_ptr == NULL) {
+	if (async_evd_ptr == NULL) {
 		dat_status = DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3);
 		goto bail;
 	}
 
 	/* initialize the caller's param */
-	*ia_handle_ptr = DAT_HANDLE_NULL;
+	*ia_ptr = NULL;
 
 	hca_ptr = (struct dapl_hca *)provider->extension;
 	atomic_inc(&hca_ptr->handle_ref_count);
 
 	/* Allocate and initialize ia structure */
-	ia_ptr = dapl_ia_alloc(provider, hca_ptr);
-	if (!ia_ptr) {
+	ia = dapl_ia_alloc(provider, hca_ptr);
+	if (!ia) {
                 atomic_dec(&hca_ptr->handle_ref_count);
 		dat_status =
 		    DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, DAT_RESOURCE_MEMORY);
@@ -93,17 +93,16 @@ u32 dapl_ia_open(const char *name, int a
 	 * use the one passed in (if non-NULL) or create one
 	 */
 
-	evd_ptr = (struct dapl_evd *)*async_evd_handle_ptr;
-	if (evd_ptr) {
-		if (DAPL_BAD_HANDLE(evd_ptr, DAPL_MAGIC_EVD) ||
-		    !(evd_ptr->evd_flags & DAT_EVD_ASYNC_FLAG)) {
+	evd = (struct dapl_evd *)*async_evd_ptr;
+	if (evd) {
+		if (!(evd->evd_flags & DAT_EVD_ASYNC_FLAG)) {
 			dat_status =
 			    DAT_ERROR(DAT_INVALID_HANDLE,
 				      DAT_INVALID_HANDLE_EVD_ASYNC);
 			goto bail;
 		}
 
-		if (evd_ptr->header.owner_ia->hca_ptr->ib_hca_handle !=
+		if (evd->common.owner_ia->hca_ptr->ib_hca_handle !=
 		    hca_ptr->ib_hca_handle) {
 			dat_status =
 			    DAT_ERROR(DAT_INVALID_HANDLE,
@@ -111,8 +110,8 @@ u32 dapl_ia_open(const char *name, int a
 			goto bail;
 		}
 
-		ia_ptr->cleanup_async_error_evd = FALSE;
-		ia_ptr->async_error_evd = evd_ptr;
+		ia->cleanup_async_error_evd = FALSE;
+		ia->async_error_evd = evd;
 	} else {
 		/* Verify we have >0 length, and let the provider check the size */
 		if (async_evd_qlen <= 0) {
@@ -120,32 +119,33 @@ u32 dapl_ia_open(const char *name, int a
 			    DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG2);
 			goto bail;
 		}
-		dat_status = dapl_evd_internal_create(ia_ptr, async_evd_qlen,
+		dat_status = dapl_evd_internal_create(ia,
+						      async_evd_qlen,
 						      DAT_UPCALL_DISABLE, NULL,
 						      DAT_EVD_ASYNC_FLAG,
-						      &evd_ptr);
+						      &evd);
 		if (dat_status != DAT_SUCCESS)
 			goto bail;
 
-		atomic_inc(&evd_ptr->evd_ref_count);
+		atomic_inc(&evd->evd_ref_count);
  		/* Register the handlers associated with the async EVD.  */
- 		dat_status = dapl_ia_setup_callbacks(ia_ptr, evd_ptr);
+ 		dat_status = dapl_ia_setup_callbacks(ia, evd);
  		/* Assign the EVD so it gets cleaned up */
-		ia_ptr->cleanup_async_error_evd = TRUE;
-		ia_ptr->async_error_evd = evd_ptr;
+		ia->cleanup_async_error_evd = TRUE;
+		ia->async_error_evd = evd;
                 if (dat_status != DAT_SUCCESS)
                         goto bail;
 	}
 
 	dat_status = DAT_SUCCESS;
-	*ia_handle_ptr = ia_ptr;
-	*async_evd_handle_ptr = evd_ptr;
+	*ia_ptr = (struct dat_ia *)ia;
+	*async_evd_ptr = (struct dat_evd *)evd;
 
-      bail:
-	if (dat_status != DAT_SUCCESS) {
-		if (ia_ptr)
-			dapl_ia_close(ia_ptr, DAT_CLOSE_ABRUPT_FLAG);
-	}
+bail:
+	if (dat_status != DAT_SUCCESS)
+		if (ia)
+			dapl_ia_close((struct dat_ia *)ia,
+				      DAT_CLOSE_ABRUPT_FLAG);
 
 	dapl_dbg_log(DAPL_DBG_TYPE_RTN,
 		     "dapl_ia_open () returns 0x%x\n", dat_status);
Index: linux-kernel/dat-provider/dapl_mr_util.c
===================================================================
--- linux-kernel/dat-provider/dapl_mr_util.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_mr_util.c	(working copy)
@@ -59,7 +59,7 @@ u64 dapl_mr_get_address(DAT_REGION_DESCR
 	case DAT_MEM_TYPE_VIRTUAL:
 		return (u64) (unsigned long) desc.for_va;
 	case DAT_MEM_TYPE_LMR:
-		lmr = (struct dapl_lmr *)desc.for_lmr_handle;
+		lmr = (struct dapl_lmr *)desc.for_lmr;
 
 		/* Since this function is recoursive we cannot inline it */
 		return dapl_mr_get_address(lmr->param.region_desc,
Index: linux-kernel/dat-provider/dapl_evd.c
===================================================================
--- linux-kernel/dat-provider/dapl_evd.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_evd.c	(working copy)
@@ -51,7 +51,7 @@ static void dapl_evd_upcall_trigger(stru
 	}
 
 	for (;;) {
-		status = dapl_evd_dequeue((DAT_EVD_HANDLE)evd, &event);
+		status = dapl_evd_dequeue((struct dat_evd *)evd, &event);
 		if (DAT_SUCCESS != status) 
 			return;
 
@@ -157,17 +157,12 @@ struct dapl_evd *dapl_evd_alloc(struct d
 	/* zero the structure */
 	memset(evd, 0, sizeof *evd);
 
-	/*
-	 * initialize the header
-	 */
-	evd->header.provider = ia->header.provider;
-	evd->header.magic = DAPL_MAGIC_EVD;
-	evd->header.handle_type = DAT_HANDLE_TYPE_EVD;
-	evd->header.owner_ia = ia;
-	evd->header.user_context.as_64 = 0;
-	evd->header.user_context.as_ptr = NULL;
-	dapl_llist_init_entry(&evd->header.ia_list_entry);
-	spin_lock_init(&evd->header.lock);
+	evd->evd.provider = ia->ia.provider;
+	evd->common.owner_ia = ia;
+	evd->common.user_context.as_64 = 0;
+	evd->common.user_context.as_ptr = NULL;
+	dapl_llist_init_entry(&evd->common.ia_list_entry);
+	spin_lock_init(&evd->common.lock);
 
 	/*
 	 * Initialize the body
@@ -249,7 +244,6 @@ static u32 dapl_evd_dealloc(struct dapl_
 	u32 status = DAT_SUCCESS;
 	struct dapl_ia *ia;
 
-	dapl_os_assert(evd->header.magic == DAPL_MAGIC_EVD);
 	dapl_os_assert(atomic_read(&evd->evd_ref_count) == 0);
 
 	/*
@@ -257,7 +251,7 @@ static u32 dapl_evd_dealloc(struct dapl_
 	 * up from it.
 	 */
 	if (evd->cq != NULL) {
-		ia = evd->header.owner_ia;
+		ia = evd->common.owner_ia;
 
 		status = dapl_ib_cq_free(evd);
 		if (status != DAT_SUCCESS) {
@@ -265,12 +259,6 @@ static u32 dapl_evd_dealloc(struct dapl_
 		}
 	}
 
-	/*
-	 * We should now be safe to invalidate the EVD; reset the
-	 * magic to prevent reuse.
-	 */
-	evd->header.magic = DAPL_MAGIC_INVALID;
-
 	/* If the ring buffer allocation failed, then the dapl_rbuf_destroy   */
 	/* function will detect that the ring buffer's internal data (ex. base */
 	/* pointer) are invalid and will handle the situation appropriately    */
@@ -314,14 +302,14 @@ static struct dat_event *dapl_evd_get_ev
 	struct dat_event *event;
 
 	if (evd->evd_producer_locking_needed) {
-		spin_lock_irqsave(&evd->header.lock, evd->header.flags);
+		spin_lock_irqsave(&evd->common.lock, evd->common.flags);
 	}
 
 	event = (struct dat_event *) dapl_rbuf_remove(&evd->free_event_queue);
 
 	/* Release the lock if it was taken and the call failed.  */
 	if (!event && evd->evd_producer_locking_needed)
-		spin_unlock_irqrestore(&evd->header.lock, evd->header.flags);
+		spin_unlock_irqrestore(&evd->common.lock, evd->common.flags);
 
 	return event;
 }
@@ -348,8 +336,8 @@ static void dapl_evd_post_event(struct d
 	dapl_os_assert(evd->evd_state == DAPL_EVD_STATE_OPEN);
 
 	if (evd->evd_producer_locking_needed) 
-		spin_unlock_irqrestore(&evd->header.lock,
-				       evd->header.flags);
+		spin_unlock_irqrestore(&evd->common.lock,
+				       evd->common.flags);
 
 	dapl_evd_upcall_trigger(evd);
 }
@@ -363,12 +351,12 @@ static void dapl_evd_format_overflow_eve
 {
 	struct dapl_ia *ia;
 
-	ia = evd->header.owner_ia;
+	ia = evd->common.owner_ia;
 
-	event->evd_handle = (DAT_EVD_HANDLE) evd;
+	event->evd = (struct dat_evd *)evd;
 	event->event_number = DAT_ASYNC_ERROR_EVD_OVERFLOW;
 	event->event_data.asynch_error_event_data.dat_handle =
-	    (DAT_HANDLE) ia;
+	    (struct dat_ia *)ia;
 }
 
 /*
@@ -409,9 +397,9 @@ static struct dat_event *dapl_evd_get_an
 	event = dapl_evd_get_event(evd);
 	if (!event)
 		dapl_evd_post_overflow_event(
-				evd->header.owner_ia->async_error_evd, evd);
+				evd->common.owner_ia->async_error_evd, evd);
 	else {
-		event->evd_handle = (DAT_EVD_HANDLE) evd;
+		event->evd = (struct dat_evd *)evd;
 		event->event_number = evno;
 	}
 
@@ -419,10 +407,10 @@ static struct dat_event *dapl_evd_get_an
 }
 
 u32 dapl_evd_post_cr_arrival_event(struct dapl_evd *evd,
-				   DAT_SP_HANDLE sp_handle,
+				   struct dat_sp *sp,
 				   struct sockaddr *ia_address,
 				   DAT_CONN_QUAL conn_qual,
-				   DAT_CR_HANDLE cr_handle)
+				   struct dat_cr *cr)
 {
 	struct dat_event *event;
 	event = dapl_evd_get_and_init_event(evd, DAT_CONNECTION_REQUEST_EVENT);
@@ -436,11 +424,11 @@ u32 dapl_evd_post_cr_arrival_event(struc
 		return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,
 				 DAT_RESOURCE_MEMORY);
 
-	event->event_data.cr_arrival_event_data.sp_handle = sp_handle;
+	event->event_data.cr_arrival_event_data.sp = sp;
 	event->event_data.cr_arrival_event_data.local_ia_address_ptr = 
 								ia_address;
 	event->event_data.cr_arrival_event_data.conn_qual = conn_qual;
-	event->event_data.cr_arrival_event_data.cr_handle = cr_handle;
+	event->event_data.cr_arrival_event_data.cr = cr;
 
 	dapl_evd_post_event(evd, event);
 
@@ -449,7 +437,7 @@ u32 dapl_evd_post_cr_arrival_event(struc
 
 u32 dapl_evd_post_connection_event(struct dapl_evd *evd,
 				   enum dat_event_number event_number,
-				   DAT_EP_HANDLE ep_handle,
+				   struct dat_ep *ep,
 				   int private_data_size,
 				   void *private_data)
 {
@@ -466,7 +454,7 @@ u32 dapl_evd_post_connection_event(struc
 				 DAT_RESOURCE_MEMORY);
 	}
 
-	event->event_data.connect_event_data.ep_handle = ep_handle;
+	event->event_data.connect_event_data.ep = ep;
 	event->event_data.connect_event_data.private_data_size = 
 							private_data_size;
 	event->event_data.connect_event_data.private_data = private_data;
@@ -492,7 +480,7 @@ static u32 dapl_evd_post_async_error_eve
 		return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES,
 				 DAT_RESOURCE_MEMORY);
 
-	event->event_data.asynch_error_event_data.dat_handle = (DAT_HANDLE) ia;
+	event->event_data.asynch_error_event_data.dat_handle = ia;
 
 	dapl_evd_post_event(evd, event);
 
@@ -539,12 +527,8 @@ static void dapl_evd_wc_to_event(struct 
 
 	ep = cookie->ep;
 	dapl_os_assert(NULL != ep);
-	if (ep->header.magic != DAPL_MAGIC_EP) {
-		/* ep may have been freed, just return */
-		return;
-	}
 
-	event->evd_handle = (DAT_EVD_HANDLE) evd;
+	event->evd = (struct dat_evd *)evd;
 
 	switch (cookie->type) {
 	case DAPL_COOKIE_TYPE_DTO:
@@ -563,7 +547,7 @@ static void dapl_evd_wc_to_event(struct 
 		}
 
 		event->event_number = DAT_DTO_COMPLETION_EVENT;
-		event_data->ep_handle = cookie->ep;
+		event_data->ep = (struct dat_ep *)cookie->ep;
 		event_data->user_cookie = cookie->val.dto.cookie;
 		event_data->status = dto_status;
 
@@ -606,7 +590,7 @@ static void dapl_evd_wc_to_event(struct 
 
 		event->event_number = DAT_RMR_BIND_COMPLETION_EVENT;
 		event_data = &event->event_data.rmr_completion_event_data;
-		event_data->rmr_handle = cookie->val.rmr.rmr;
+		event_data->rmr = (struct dat_rmr *)cookie->val.rmr.rmr;
 		event_data->user_cookie = cookie->val.rmr.cookie;
 
 		if (dto_status == DAT_DTO_SUCCESS) {
@@ -654,7 +638,7 @@ void dapl_evd_qp_async_error_callback(st
 	u32 status;
 
 	ep = (struct dapl_ep *)context;
-	async_evd = (struct dapl_evd *)ep->header.owner_ia->async_error_evd;
+	async_evd = (struct dapl_evd *)ep->common.owner_ia->async_error_evd;
 
 	dapl_dbg_log(DAPL_DBG_TYPE_CALLBACK | DAPL_DBG_TYPE_EXCEPTION,
 		     "dapl_evd_qp_async_error_callback: "
@@ -679,7 +663,7 @@ void dapl_evd_qp_async_error_callback(st
 		 * we are not interested in.
 		 */
 		(void)dapl_evd_post_async_error_event(async_evd, async_event,
-						async_evd->header.owner_ia);
+						async_evd->common.owner_ia);
 	}
 	dapl_dbg_log(DAPL_DBG_TYPE_CALLBACK | DAPL_DBG_TYPE_EXCEPTION,
 		     "dapl_evd_qp_async_error_callback () returns\n");
@@ -698,11 +682,11 @@ void dapl_evd_cq_async_error_callback(st
 	if (!evd)
 		dapl_os_panic("NULL == context\n");
 
-	async_evd = evd->header.owner_ia->async_error_evd;
+	async_evd = evd->common.owner_ia->async_error_evd;
 
 	status = dapl_evd_post_async_error_event(async_evd,
 						 DAT_ASYNC_ERROR_EVD_OVERFLOW,
-						 async_evd->header.owner_ia);
+						 async_evd->common.owner_ia);
 
 	if (status != DAT_SUCCESS) {
 		dapl_os_panic("async EVD overflow\n");
@@ -738,7 +722,7 @@ void dapl_evd_un_async_error_callback(st
 		 */
 		dapl_evd_post_async_error_event(async_evd,
 						async_event,
-						async_evd->header.owner_ia);
+						async_evd->common.owner_ia);
 	}
 	dapl_dbg_log(DAPL_DBG_TYPE_CALLBACK | DAPL_DBG_TYPE_EXCEPTION,
 		     "dapl_evd_un_async_error_callback () returns\n");
@@ -764,14 +748,14 @@ void dapl_evd_connection_callback(struct
 		     "ep: %p\n",
 		     cm_handle, event, ep);
 
-	evd = (struct dapl_evd *)ep->param.connect_evd_handle;
+	evd = (struct dapl_evd *)ep->param.connect_evd;
 
 	private_data_size = 0;
 	/*
 	 * All operations effect the EP, so lock it once and unlock
 	 * when necessary
 	 */
-	spin_lock_irqsave(&ep->header.lock, ep->header.flags);
+	spin_lock_irqsave(&ep->common.lock, ep->common.flags);
 
 	switch (event) {
 	case DAT_CONNECTION_EVENT_ESTABLISHED:
@@ -784,13 +768,13 @@ void dapl_evd_connection_callback(struct
 			/* If someone pulled the plug on the connection, just
 			 * exit
 			 */
-			spin_unlock_irqrestore(&ep->header.lock, 
-					       ep->header.flags);
+			spin_unlock_irqrestore(&ep->common.lock, 
+					       ep->common.flags);
 			status = DAT_SUCCESS;
 			break;
 		}
 		ep->param.ep_state = DAT_EP_STATE_CONNECTED;
-		ep->cm_handle = cm_handle;
+		ep->cm = cm_handle;
 		if (private_data == NULL) {
 			private_data_size = 0;
 		} else {
@@ -798,7 +782,7 @@ void dapl_evd_connection_callback(struct
                                memcpy(ep->private_data, private_data,
 				      private_data_size);
 		}
-		spin_unlock_irqrestore(&ep->header.lock, ep->header.flags);
+		spin_unlock_irqrestore(&ep->common.lock, ep->common.flags);
 
 		break;
 	}
@@ -811,8 +795,8 @@ void dapl_evd_connection_callback(struct
 		 */
 		ep->param.ep_state = DAT_EP_STATE_DISCONNECTED;
 		dapl_ib_disconnect_clean(ep, TRUE);
-		spin_unlock_irqrestore(&ep->header.lock,
-				       ep->header.flags);
+		spin_unlock_irqrestore(&ep->common.lock,
+				       ep->common.flags);
 
 		break;
 	}
@@ -820,7 +804,7 @@ void dapl_evd_connection_callback(struct
 	{
 		ep->param.ep_state = DAT_EP_STATE_DISCONNECTED;
 		dapl_ib_disconnect_clean(ep, TRUE);
-		spin_unlock_irqrestore(&ep->header.lock, ep->header.flags);
+		spin_unlock_irqrestore(&ep->common.lock, ep->common.flags);
 
 		break;
 	}
@@ -828,7 +812,7 @@ void dapl_evd_connection_callback(struct
 	{
 		ep->param.ep_state = DAT_EP_STATE_DISCONNECTED;
 		dapl_ib_disconnect_clean(ep, TRUE);
-		spin_unlock_irqrestore(&ep->header.lock, ep->header.flags);
+		spin_unlock_irqrestore(&ep->common.lock, ep->common.flags);
 
 		break;
 	}
@@ -836,7 +820,7 @@ void dapl_evd_connection_callback(struct
 	{
 		ep->param.ep_state = DAT_EP_STATE_DISCONNECTED;
 		dapl_ib_disconnect_clean(ep, TRUE);
-		spin_unlock_irqrestore(&ep->header.lock, ep->header.flags);
+		spin_unlock_irqrestore(&ep->common.lock, ep->common.flags);
 
 		break;
 	}
@@ -844,14 +828,14 @@ void dapl_evd_connection_callback(struct
 	{
 		ep->param.ep_state = DAT_EP_STATE_DISCONNECTED;
 		dapl_ib_disconnect_clean(ep, FALSE);
-		spin_unlock_irqrestore(&ep->header.lock, ep->header.flags);
+		spin_unlock_irqrestore(&ep->common.lock, ep->common.flags);
 
 		break;
 	}
 	case DAT_CONNECTION_REQUEST_EVENT:
 	default:
 	{
-		spin_unlock_irqrestore(&ep->header.lock, ep->header.flags);
+		spin_unlock_irqrestore(&ep->common.lock, ep->common.flags);
 		evd = NULL;
 
 		dapl_os_assert(0);	/* shouldn't happen */
@@ -865,7 +849,7 @@ void dapl_evd_connection_callback(struct
 	 */
 	if (evd != NULL) {
 		status = dapl_evd_post_connection_event(evd, event, 
-                                                        (DAT_HANDLE) ep, 
+                                                        (struct dat_ep *)ep, 
                                                         private_data_size, /* 0 except on CONNECT */
 							ep->private_data);
 
@@ -877,10 +861,10 @@ void dapl_evd_connection_callback(struct
 			 * expect a callback on an ABRUPT disconnect.
 			 */
 			dapl_ib_disconnect(ep, DAT_CLOSE_ABRUPT_FLAG);
-			spin_lock_irqsave(&ep->header.lock, ep->header.flags);
+			spin_lock_irqsave(&ep->common.lock, ep->common.flags);
 			ep->param.ep_state = DAT_EP_STATE_DISCONNECTED;
-			spin_unlock_irqrestore(&ep->header.lock,
-					       ep->header.flags);
+			spin_unlock_irqrestore(&ep->common.lock,
+					       ep->common.flags);
 		}
 	}
 
@@ -901,7 +885,6 @@ void dapl_evd_dto_callback(struct ib_cq 
 	evd = (struct dapl_evd *)user_context;
 
 	dapl_os_assert(evd->cq == cq);
-	dapl_os_assert(evd->header.magic == DAPL_MAGIC_EVD);
 
 	/* Read once.  */
 	state = *(volatile DAPL_EVD_STATE *)&evd->evd_state;
@@ -927,9 +910,9 @@ void dapl_evd_dto_callback(struct ib_cq 
 		status = dapl_ib_completion_notify(evd);
 		if (DAT_SUCCESS != status) 
 			(void)dapl_evd_post_async_error_event(
-				evd->header.owner_ia->async_error_evd,
+				evd->common.owner_ia->async_error_evd,
 				DAT_ASYNC_ERROR_PROVIDER_INTERNAL_ERROR,
-				evd->header.owner_ia);
+				evd->common.owner_ia);
 
 		dapl_evd_upcall_trigger(evd);
 	}
@@ -1008,10 +991,10 @@ bail:
 	return status;
 }
 
-u32 dapl_evd_kcreate(DAT_IA_HANDLE ia_handle, int min_qlen,
+u32 dapl_evd_kcreate(struct dat_ia *ia_handle, int min_qlen,
 		     enum dat_upcall_policy upcall_policy, 
 		     const struct dat_upcall_object *upcall,
-		     enum dat_evd_flags flags, DAT_EVD_HANDLE *evd_handle)
+		     enum dat_evd_flags flags, struct dat_evd **evd_handle)
 {
 	struct dapl_ia *ia;
 	struct dapl_evd *evd;
@@ -1025,7 +1008,7 @@ u32 dapl_evd_kcreate(DAT_IA_HANDLE ia_ha
 	evd = NULL;
 	*evd_handle = NULL;
 
-	if (DAPL_BAD_HANDLE(ia_handle, DAPL_MAGIC_IA)) {
+	if (!ia_handle) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
 		goto bail;
 	}
@@ -1053,17 +1036,17 @@ u32 dapl_evd_kcreate(DAT_IA_HANDLE ia_ha
 	if (status != DAT_SUCCESS)
 		goto bail;
 
-	*evd_handle = (DAT_EVD_HANDLE) evd;
+	*evd_handle = (struct dat_evd *)evd;
 
 bail:
 	if (status != DAT_SUCCESS)
 		if (evd)
-			dapl_evd_free(evd);
+			dapl_evd_free((struct dat_evd *)evd);
 
 	return status;
 }
 
-u32 dapl_evd_free(DAT_EVD_HANDLE evd_handle)
+u32 dapl_evd_free(struct dat_evd *evd_handle)
 {
 	struct dapl_evd *evd;
 	u32 status = DAT_SUCCESS;
@@ -1072,7 +1055,7 @@ u32 dapl_evd_free(DAT_EVD_HANDLE evd_han
 
 	evd = (struct dapl_evd *)evd_handle;
 
-	if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) {
+	if (!evd_handle) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, 0);
 		goto bail;
 	}
@@ -1083,11 +1066,11 @@ u32 dapl_evd_free(DAT_EVD_HANDLE evd_han
 		goto bail;
 	}
 
-	dapl_ia_unlink_evd(evd->header.owner_ia, evd);
+	dapl_ia_unlink_evd(evd->common.owner_ia, evd);
 
 	status = dapl_evd_dealloc(evd);
 	if (status != DAT_SUCCESS) {
-		dapl_ia_link_evd(evd->header.owner_ia, evd);
+		dapl_ia_link_evd(evd->common.owner_ia, evd);
 	}
 
 bail:
@@ -1097,7 +1080,7 @@ bail:
 	return status;
 }
 
-u32 dapl_evd_kquery(DAT_EVD_HANDLE evd_handle, struct dat_evd_param *evd_param)
+u32 dapl_evd_kquery(struct dat_evd *evd_handle, struct dat_evd_param *evd_param)
 {
 	struct dapl_evd *evd;
 	u32 status = DAT_SUCCESS;
@@ -1108,11 +1091,11 @@ u32 dapl_evd_kquery(DAT_EVD_HANDLE evd_h
 	}
 
 	/* Note: the spec. allows for events to be directed to a NULL EVD */
-	/* with handle of type DAT_HANDLE_NULL. See 6.3.1                 */
-	if (DAT_HANDLE_NULL == evd_handle) {
+	/* with handle of type NULL. See 6.3.1                 */
+	if (NULL == evd_handle) {
 		memset(evd_param, 0, sizeof *evd_param);
 	} else {
-		if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) {
+		if (!evd_handle) {
 			status = DAT_ERROR(DAT_INVALID_HANDLE, 0);
 			goto bail;
 		}
@@ -1128,7 +1111,7 @@ u32 dapl_evd_kquery(DAT_EVD_HANDLE evd_h
 		 * about reading the state variable atomically when we add
 		 * in waitable/unwaitable.
 		 */
-		evd_param->ia_handle = evd->header.owner_ia;
+		evd_param->ia = (struct dat_ia *)evd->common.owner_ia;
 		evd_param->evd_qlen = evd->qlen;
 		evd_param->evd_flags = evd->evd_flags;
 		evd_param->upcall_policy = evd->upcall_policy;
@@ -1139,7 +1122,7 @@ bail:
 	return status;
 }
 
-u32 dapl_evd_modify_upcall(DAT_EVD_HANDLE evd_handle,
+u32 dapl_evd_modify_upcall(struct dat_evd *evd_handle,
 			   enum dat_upcall_policy upcall_policy,
 			   const struct dat_upcall_object *upcall)
 {
@@ -1150,7 +1133,7 @@ u32 dapl_evd_modify_upcall(DAT_EVD_HANDL
 
 	evd = (struct dapl_evd *)evd_handle;
 
-	if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) {
+	if (!evd_handle) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, 0);
 		goto bail;
 	}
@@ -1162,14 +1145,14 @@ bail:
 	return status;
 }
 
-u32 dapl_evd_post_se(DAT_EVD_HANDLE evd_handle, const struct dat_event *event)
+u32 dapl_evd_post_se(struct dat_evd *evd_handle, const struct dat_event *event)
 {
 	struct dapl_evd *evd;
 	u32 status = DAT_SUCCESS;
 
 	evd = (struct dapl_evd *)evd_handle;
 
-	if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) {
+	if (!evd_handle) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, 0);
 		goto bail;
 	}
@@ -1196,7 +1179,7 @@ u32 dapl_evd_post_se(DAT_EVD_HANDLE evd_
 	return status;
 }
 
-u32 dapl_evd_dequeue(DAT_EVD_HANDLE evd_handle, struct dat_event *event)
+u32 dapl_evd_dequeue(struct dat_evd *evd_handle, struct dat_event *event)
 {
 	struct dapl_evd *evd;
 	struct dat_event *local_event;
@@ -1207,7 +1190,7 @@ u32 dapl_evd_dequeue(DAT_EVD_HANDLE evd_
 
 	evd = (struct dapl_evd *)evd_handle;
 
-	if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) {
+	if (!evd_handle) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, 0);
 		goto bail;
 	}
@@ -1222,7 +1205,7 @@ u32 dapl_evd_dequeue(DAT_EVD_HANDLE evd_
 	 * restricts us from having multiple threads in CQ poll, and the
 	 * DAT API allows multiple threads in dat_evd_dequeue()
 	 */
-	spin_lock_irqsave(&evd->header.lock, evd->header.flags);
+	spin_lock_irqsave(&evd->common.lock, evd->common.flags);
 
 	/*
 	 * Make sure there are no other waiters and the evd is active.
@@ -1230,7 +1213,7 @@ u32 dapl_evd_dequeue(DAT_EVD_HANDLE evd_
 	 */
 	if (evd->evd_state != DAPL_EVD_STATE_OPEN ||
 	    evd->catastrophic_overflow) {
-		spin_unlock_irqrestore(&evd->header.lock, evd->header.flags);
+		spin_unlock_irqrestore(&evd->common.lock, evd->common.flags);
 		status = DAT_ERROR(DAT_INVALID_STATE, 0);
 		goto bail;
 	}
@@ -1249,7 +1232,7 @@ u32 dapl_evd_dequeue(DAT_EVD_HANDLE evd_
 		status = DAT_ERROR(DAT_QUEUE_EMPTY, 0);
 	}
 
-	spin_unlock_irqrestore(&evd->header.lock, evd->header.flags);
+	spin_unlock_irqrestore(&evd->common.lock, evd->common.flags);
       bail:
 	dapl_dbg_log(DAPL_DBG_TYPE_RTN,
 		     "dapl_evd_dequeue () returns 0x%x\n", status);
@@ -1257,7 +1240,7 @@ u32 dapl_evd_dequeue(DAT_EVD_HANDLE evd_
 	return status;
 }
 
-u32 dapl_evd_resize(DAT_EVD_HANDLE evd_handle, int evd_qlen)
+u32 dapl_evd_resize(struct dat_evd *evd_handle, int evd_qlen)
 {
 	struct dapl_ia *ia;
 	struct dapl_evd *evd;
@@ -1267,13 +1250,13 @@ u32 dapl_evd_resize(DAT_EVD_HANDLE evd_h
 	dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_evd_resize (%p, %d)\n",
 		     evd_handle, evd_qlen);
 
-	if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) {
+	if (!evd_handle) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, 0);
 		goto bail;
 	}
 
 	evd = (struct dapl_evd *)evd_handle;
-	ia = evd->header.owner_ia;
+	ia = evd->common.owner_ia;
 
 	if (evd_qlen == evd->qlen) {
 		status = DAT_SUCCESS;
@@ -1285,7 +1268,7 @@ u32 dapl_evd_resize(DAT_EVD_HANDLE evd_h
 		goto bail;
 	}
 
-	spin_lock_irqsave(&evd->header.lock, evd->header.flags);
+	spin_lock_irqsave(&evd->common.lock, evd->common.flags);
 
 	pend_cnt = dapl_rbuf_count(&evd->pending_event_queue);
 	if (pend_cnt > evd_qlen) {
@@ -1302,6 +1285,6 @@ u32 dapl_evd_resize(DAT_EVD_HANDLE evd_h
 		goto bail;
 
 bail:
-	spin_unlock_irqrestore(&evd->header.lock, evd->header.flags);
+	spin_unlock_irqrestore(&evd->common.lock, evd->common.flags);
 	return status;
 }
Index: linux-kernel/dat-provider/dapl_ia_query.c
===================================================================
--- linux-kernel/dat-provider/dapl_ia_query.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_ia_query.c	(working copy)
@@ -38,12 +38,12 @@
  * Provide the consumer with Interface Adapter and Provider parameters.
  *
  * Input:
- *	ia_handle
+ *	ia
  *	ia_mask
  *	provider_mask
  *
  * Output:
- *	async_evd_handle
+ *	async_evd
  *	ia_parameters
  *	provider_parameters
  *
@@ -51,7 +51,7 @@
  * 	DAT_SUCCESS
  * 	DAT_INVALID_PARAMETER
  */
-u32 dapl_ia_query(DAT_IA_HANDLE ia_handle, DAT_EVD_HANDLE *async_evd_handle,
+u32 dapl_ia_query(struct dat_ia *ia, struct dat_evd **async_evd,
 		  struct dat_ia_attr *ia_attr,
 		  struct dat_provider_attr *provider_attr)
 {
@@ -66,21 +66,21 @@ u32 dapl_ia_query(DAT_IA_HANDLE ia_handl
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API,
 		     "dapl_ia_query (%p, %p, %p, %p)\n",
-		     ia_handle,
-		     async_evd_handle,
+		     ia,
+		     async_evd,
 		     ia_attr, 
                      provider_attr);
 
-	ia_ptr = (struct dapl_ia *)ia_handle;
+	ia_ptr = (struct dapl_ia *)ia;
 
-	if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
+	if (!ia_ptr) {
 		dat_status =
 		    DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_IA);
 		goto bail;
 	}
 
-	if (NULL != async_evd_handle) {
-		*async_evd_handle = ia_ptr->async_error_evd;
+	if (NULL != async_evd) {
+		*async_evd = (struct dat_evd *)ia_ptr->async_error_evd;
 	}
 
 	if (NULL != ia_attr) 
@@ -88,7 +88,7 @@ u32 dapl_ia_query(DAT_IA_HANDLE ia_handl
 
 	if (NULL != provider_attr) {
 		strncpy(provider_attr->provider_name,
-			ia_ptr->header.provider->device_name,
+			ia_ptr->ia.provider->device_name,
 			DAT_NAME_MAX_LENGTH);
 		provider_attr->provider_version_major = DAPL_PROVIDER_MAJOR;
 		provider_attr->provider_version_minor = DAPL_PROVIDER_MINOR;
Index: linux-kernel/dat-provider/dapl_sp_util.c
===================================================================
--- linux-kernel/dat-provider/dapl_sp_util.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_sp_util.c	(working copy)
@@ -65,22 +65,16 @@ struct dapl_sp *dapl_sp_alloc(struct dap
 	/* zero the structure */
 	memset(sp_ptr, 0, sizeof *sp_ptr);
 
-	/*
-	 * initialize the header
-	 */
-	sp_ptr->header.provider = ia_ptr->header.provider;
-	if (is_psp) {
-		sp_ptr->header.magic = DAPL_MAGIC_PSP;
-		sp_ptr->header.handle_type = DAT_HANDLE_TYPE_PSP;
-	} else {
-		sp_ptr->header.magic = DAPL_MAGIC_RSP;
-		sp_ptr->header.handle_type = DAT_HANDLE_TYPE_RSP;
-	}
-	sp_ptr->header.owner_ia = ia_ptr;
-	sp_ptr->header.user_context.as_64 = 0;
-	sp_ptr->header.user_context.as_ptr = NULL;
-	dapl_llist_init_entry(&sp_ptr->header.ia_list_entry);
-	spin_lock_init(&sp_ptr->header.lock);
+	sp_ptr->sp.provider = ia_ptr->ia.provider;
+	if (is_psp)
+		sp_ptr->sp.type = DAT_SP_TYPE_PSP;
+	else
+		sp_ptr->sp.type = DAT_SP_TYPE_RSP;
+	sp_ptr->common.owner_ia = ia_ptr;
+	sp_ptr->common.user_context.as_64 = 0;
+	sp_ptr->common.user_context.as_ptr = NULL;
+	dapl_llist_init_entry(&sp_ptr->common.ia_list_entry);
+	spin_lock_init(&sp_ptr->common.lock);
 
 	/*
 	 * Initialize the Body (set to NULL above)
@@ -107,12 +101,8 @@ struct dapl_sp *dapl_sp_alloc(struct dap
  */
 void dapl_sp_dealloc(struct dapl_sp *sp_ptr)
 {
-	dapl_os_assert(sp_ptr->header.magic == DAPL_MAGIC_PSP ||
-		       sp_ptr->header.magic == DAPL_MAGIC_RSP);
 	dapl_os_assert(dapl_llist_is_empty(&sp_ptr->cr_list_head));
 
-	sp_ptr->header.magic = DAPL_MAGIC_INVALID; /* reset magic to prevent reuse */
-
 	kfree(sp_ptr);
 }
 
@@ -134,11 +124,11 @@ void dapl_sp_dealloc(struct dapl_sp *sp_
  */
 void dapl_sp_link_cr(struct dapl_sp *sp_ptr, struct dapl_cr *cr_ptr)
 {
-	spin_lock_irqsave(&sp_ptr->header.lock, sp_ptr->header.flags);
+	spin_lock_irqsave(&sp_ptr->common.lock, sp_ptr->common.flags);
 	dapl_llist_add_tail(&sp_ptr->cr_list_head,
-			    &cr_ptr->header.ia_list_entry, cr_ptr);
+			    &cr_ptr->common.ia_list_entry, cr_ptr);
 	sp_ptr->cr_list_count++;
-	spin_unlock_irqrestore(&sp_ptr->header.lock, sp_ptr->header.flags);
+	spin_unlock_irqrestore(&sp_ptr->common.lock, sp_ptr->common.flags);
 }
 
 /*
@@ -174,7 +164,7 @@ struct dapl_cr *dapl_sp_search_cr(struct
 		if (cr_ptr->ib_cm_handle == ib_cm_handle)
 			return cr_ptr;
 		
-		cr_ptr = cr_ptr->header.ia_list_entry.flink->data;
+		cr_ptr = cr_ptr->common.ia_list_entry.flink->data;
 	} while ((void *)cr_ptr != (void *)sp_ptr->cr_list_head->data);
 
 	return NULL;
@@ -208,7 +198,7 @@ void dapl_sp_remove_cr(struct dapl_sp *s
 	}
 
 	dapl_llist_remove_entry(&sp_ptr->cr_list_head,
-				&cr_ptr->header.ia_list_entry);
+				&cr_ptr->common.ia_list_entry);
 	sp_ptr->cr_list_count--;
 }
 
@@ -238,13 +228,13 @@ void dapl_sp_remove_ep(struct dapl_ep *e
 	if (cr_ptr != NULL) {
 		sp_ptr = cr_ptr->sp_ptr;
 
-		spin_lock_irqsave(&sp_ptr->header.lock, sp_ptr->header.flags);
+		spin_lock_irqsave(&sp_ptr->common.lock, sp_ptr->common.flags);
 
 		/* Remove the CR from the queue */
 		dapl_sp_remove_cr(sp_ptr, cr_ptr);
 
-		spin_unlock_irqrestore(&sp_ptr->header.lock, 
-				       sp_ptr->header.flags);
+		spin_unlock_irqrestore(&sp_ptr->common.lock, 
+				       sp_ptr->common.flags);
 
 		/* free memory outside of the lock */
 		dapl_cr_free(cr_ptr);
Index: linux-kernel/dat-provider/dapl_evd.h
===================================================================
--- linux-kernel/dat-provider/dapl_evd.h	(revision 2572)
+++ linux-kernel/dat-provider/dapl_evd.h	(working copy)
@@ -60,14 +60,14 @@ extern void dapl_evd_un_async_error_call
  */
 
 extern u32 dapl_evd_post_cr_arrival_event(struct dapl_evd *evd,
-					  DAT_SP_HANDLE sp_handle,
+					  struct dat_sp *sp_handle,
 					  struct sockaddr *ia_address,
 					  DAT_CONN_QUAL conn_qual,
-					  DAT_CR_HANDLE cr_handle);
+					  struct dat_cr *cr_handle);
 
 extern u32 dapl_evd_post_connection_event(struct dapl_evd *evd,
 					  enum dat_event_number event_number,
-					  DAT_EP_HANDLE ep_handle,
+					  struct dat_ep *ep_handle,
 					  int private_data_size,
 					  void *private_data);
 
Index: linux-kernel/dat-provider/dapl.h
===================================================================
--- linux-kernel/dat-provider/dapl.h	(revision 2572)
+++ linux-kernel/dat-provider/dapl.h	(working copy)
@@ -46,23 +46,6 @@
  *                                                                   *
  *********************************************************************/
 
-typedef enum dapl_magic {
-	/* magic number values for verification & debug */
-	DAPL_MAGIC_IA = 0xCafeF00d,
-	DAPL_MAGIC_EVD = 0xFeedFace,
-	DAPL_MAGIC_EP = 0xDeadBabe,
-	DAPL_MAGIC_LMR = 0xBeefCafe,
-	DAPL_MAGIC_RMR = 0xABadCafe,
-	DAPL_MAGIC_PZ = 0xDeafBeef,
-	DAPL_MAGIC_PSP = 0xBeadeD0c,
-	DAPL_MAGIC_RSP = 0xFab4Feed,
-	DAPL_MAGIC_SRQ = 0xC001Babe,
-	DAPL_MAGIC_CR = 0xBe12Cee1,
-	DAPL_MAGIC_CR_DESTROYED = 0xB12bDead,
-	DAPL_MAGIC_CNO = 0xDeadF00d,
-	DAPL_MAGIC_INVALID = 0xFFFFFFFF
-} DAPL_MAGIC;
-
 typedef enum dapl_evd_state {
 	DAPL_EVD_STATE_OPEN,
 	DAPL_EVD_STATE_DEAD = 0xDEAD
@@ -92,23 +75,6 @@ typedef enum dapl_evd_completion {
 
 /*********************************************************************
  *                                                                   *
- * Macros                                                            *
- *                                                                   *
- *********************************************************************/
-
-/*
- * Simple macro to verify a handle is bad. Conditions:
- * - pointer is NULL
- * - pointer is not word aligned
- * - pointer's magic number is wrong
- */
-#define DAPL_BAD_HANDLE(h, magicNum) (				\
-	    ((h) == NULL) ||					\
-	    ((unsigned long)(h) & 3) ||				\
-	    (((struct dapl_header *)(h))->magic != (magicNum)))
-
-/*********************************************************************
- *                                                                   *
  * Typedefs                                                          *
  *                                                                   *
  *********************************************************************/
@@ -170,11 +136,8 @@ struct dapl_hca {
 	struct dat_ep_attr ep_attr;
 };
 
-/* DAPL Objects always have the following header */
-struct dapl_header {
-	struct dat_provider *provider;	  /* required by DAT - must be first */
-	DAPL_MAGIC magic;		  /* magic number for verification */
-	enum dat_handle_type handle_type; 
+/* DAPL Objects always have the following items */
+struct dapl_common {
 	struct dapl_ia *owner_ia;
 	struct dapl_llist_entry ia_list_entry;	
 	union dat_context user_context;	  /* user context - opaque to DAPL */
@@ -182,9 +145,9 @@ struct dapl_header {
 	unsigned long flags;		  /* saved lock flag values */
 };
 
-/* struct dapl_ia maps to DAT_IA_HANDLE */
 struct dapl_ia {
-	struct dapl_header header; /* WARNING: must be first */
+	struct dat_ia ia;
+	struct dapl_common common;
 	struct dapl_hca *hca_ptr;
 	struct dapl_evd *async_error_evd;
 	boolean_t cleanup_async_error_evd;
@@ -200,9 +163,9 @@ struct dapl_ia {
 	struct dapl_llist_entry *srq_list_head;	/* SRQ queue */
 };
 
-/* struct dapl_evd maps to DAT_EVD_HANDLE */
 struct dapl_evd {
-	struct dapl_header	header; /* WARNING: must be first */
+	struct dat_evd		evd;
+	struct dapl_common	common;
 	DAPL_EVD_STATE		evd_state;
 	enum dat_evd_flags	evd_flags;
 
@@ -230,9 +193,9 @@ struct dapl_evd {
 	struct dat_upcall_object upcall;
 };
 
-/* struct dapl_ep maps to DAT_EP_HANDLE */
 struct dapl_ep {
-	struct dapl_header header;
+	struct dat_ep ep;
+	struct dapl_common common;
 	/* What the DAT Consumer asked for */
 	struct dat_ep_param param;
 
@@ -241,7 +204,7 @@ struct dapl_ep {
 	enum ib_qp_state qp_state;
 
 	/* communications manager handle */
-	struct dapl_cm_id *cm_handle;
+	struct dapl_cm_id *cm;
 	/* store the remote IA address here, reference from the param
 	 * struct which only has a pointer, no storage
 	 */
@@ -267,33 +230,33 @@ struct dapl_ep {
 	int send_iov_num;
 };
 
-/* struct dapl_srq maps to DAT_SRQ_HANDLE */
 struct dapl_srq {
-	struct dapl_header header; /* WARNING: must be first */
+	struct dat_srq srq;
+	struct dapl_common common;
 	struct dat_srq_param param;
 	atomic_t srq_ref_count;
 	struct dapl_cookie_buffer recv_buffer;
 	atomic_t recv_count;
 };
 
-/* struct dapl_pz maps to DAT_PZ_HANDLE */
 struct dapl_pz {
-	struct dapl_header header; /* WARNING: must be first */
+	struct dat_pz pz;
+	struct dapl_common common;
 	struct ib_pd *pd;
 	atomic_t pz_ref_count;
 };
 
-/* struct dapl_lmr maps to DAT_LMR_HANDLE */
 struct dapl_lmr {
-	struct dapl_header header; /* WARNING: must be first */
+	struct dat_lmr lmr;
+	struct dapl_common common;
 	struct dat_lmr_param param;
 	struct ib_mr *mr;
 	atomic_t lmr_ref_count;
 };
 
-/* struct dapl_rmr maps to DAT_RMR_HANDLE */
 struct dapl_rmr {
-	struct dapl_header header; /* WARNING: must be first */
+	struct dat_rmr rmr;
+	struct dapl_common common;
 	struct dat_rmr_param param;
 	struct dapl_ep *ep;
 	struct dapl_pz *pz;
@@ -310,17 +273,17 @@ typedef enum dapl_sp_state {
 	DAPL_SP_STATE_RSP_PENDING
 } DAPL_SP_STATE;
 
-/* struct dapl_sp maps to DAT_PSP_HANDLE and DAT_RSP_HANDLE */
 struct dapl_sp {
-	struct dapl_header header; /* WARNING: must be first */
+	struct dat_sp sp;
+	struct dapl_common common;
 	DAPL_SP_STATE state;	/* type and queue of the SP */
 
 	/* PSP/RSP PARAM fields */
-	DAT_IA_HANDLE ia_handle;
+	struct dat_ia *ia;
 	DAT_CONN_QUAL conn_qual;
-	DAT_EVD_HANDLE evd_handle;
+	struct dat_evd *evd;
 	enum dat_psp_flags psp_flags;
-	DAT_EP_HANDLE ep_handle;
+	struct dat_ep *ep;
 
 	/* maintenance fields */
 	boolean_t listening;	/* PSP is registered & active */
@@ -329,9 +292,9 @@ struct dapl_sp {
 	int cr_list_count;	/* count of CRs on queue */
 };
 
-/* struct dapl_cr maps to DAT_CR_HANDLE */
 struct dapl_cr {
-	struct dapl_header header;
+	struct dat_cr cr;
+	struct dapl_common common;
 	/* for convenience the data is kept as a struct dat_cr_param.
 	 * however, the "local_endpoint" field is always NULL
 	 * so this wastes a pointer. This is probably ok to
@@ -396,91 +359,88 @@ struct dapl_cookie {
  */
 
 extern u32 dapl_ia_open(const char *name, int async_evd_qlen,
-			DAT_EVD_HANDLE *async_evd_handle_ptr,
-			DAT_IA_HANDLE *ia_handle_ptr);
+			struct dat_evd **async_evd_ptr,
+			struct dat_ia **ia_ptr);
 
-extern u32 dapl_ia_close(DAT_IA_HANDLE, enum dat_close_flags);
+extern u32 dapl_ia_close(struct dat_ia *, enum dat_close_flags);
 
-extern u32 dapl_ia_query(DAT_IA_HANDLE, DAT_EVD_HANDLE *, struct dat_ia_attr *,
+extern u32 dapl_ia_query(struct dat_ia *, struct dat_evd **, struct dat_ia_attr *,
 			 struct dat_provider_attr *);
 
 /* helper functions */
 
-extern u32 dapl_set_consumer_context(DAT_HANDLE handle,
+extern u32 dapl_set_consumer_context(void *handle,
 				     union dat_context context);
 
-extern u32 dapl_get_consumer_context(DAT_HANDLE handle,
+extern u32 dapl_get_consumer_context(void *handle,
 				     union dat_context *context);
 
-extern u32 dapl_get_handle_type(DAT_HANDLE handle,
-				enum dat_handle_type *type);
-
 /* CR Functions */
 
-extern u32 dapl_cr_query(DAT_CR_HANDLE, struct dat_cr_param *);	
+extern u32 dapl_cr_query(struct dat_cr *, struct dat_cr_param *);	
 
-extern u32 dapl_cr_accept(DAT_CR_HANDLE cr_handle, DAT_EP_HANDLE ep_handle,
+extern u32 dapl_cr_accept(struct dat_cr *cr, struct dat_ep *ep,
 			  int private_data_size,
 			  const void *private_data);
 
-extern u32 dapl_cr_reject(DAT_CR_HANDLE cr_handle);
+extern u32 dapl_cr_reject(struct dat_cr *cr);
 
-extern u32 dapl_cr_handoff(DAT_CR_HANDLE cr_handle, DAT_CONN_QUAL handoff);
+extern u32 dapl_cr_handoff(struct dat_cr *cr, DAT_CONN_QUAL handoff);
 
 /* EVD Functions */
-extern u32 dapl_ia_memtype_hint(DAT_IA_HANDLE ia_handle,
+extern u32 dapl_ia_memtype_hint(struct dat_ia *ia,
 				enum dat_mem_type mem_type,
 				u64 length,
 				enum dat_mem_optimize_flags mem_optimization,
 				u64 *suggested_length,
 				u64 *suggested_alignment);
 
-extern u32 dapl_evd_kcreate(DAT_IA_HANDLE ia_handle, int evd_min_qlen,
+extern u32 dapl_evd_kcreate(struct dat_ia *ia, int evd_min_qlen,
 			    enum dat_upcall_policy upcall_policy,
 			    const struct dat_upcall_object * upcall,
 			    enum dat_evd_flags evd_flags,
-			    DAT_EVD_HANDLE * evd_handle);
+			    struct dat_evd ** evd);
 
-extern u32 dapl_evd_kquery(DAT_EVD_HANDLE evd_handle,
+extern u32 dapl_evd_kquery(struct dat_evd *evd,
 			   struct dat_evd_param *evd_args);
 
-extern u32 dapl_evd_modify_upcall(DAT_EVD_HANDLE evd_handle,
+extern u32 dapl_evd_modify_upcall(struct dat_evd *evd,
 				  enum dat_upcall_policy upcall_policy,
 				  const struct dat_upcall_object * upcall);
 
-extern u32 dapl_evd_enable(DAT_EVD_HANDLE evd_handle);
+extern u32 dapl_evd_enable(struct dat_evd *evd);
 
-extern u32 dapl_evd_disable(DAT_EVD_HANDLE evd_handle);
+extern u32 dapl_evd_disable(struct dat_evd *evd);
 
-extern u32 dapl_evd_resize(DAT_EVD_HANDLE evd_handle, int evd_qlen);
+extern u32 dapl_evd_resize(struct dat_evd *evd, int evd_qlen);
 
-extern u32 dapl_evd_post_se(DAT_EVD_HANDLE evd_handle,
+extern u32 dapl_evd_post_se(struct dat_evd *evd,
 			    const struct dat_event *event);
 
-extern u32 dapl_evd_dequeue(DAT_EVD_HANDLE evd_handle, struct dat_event *event);
+extern u32 dapl_evd_dequeue(struct dat_evd *evd, struct dat_event *event);
 
-extern u32 dapl_evd_free(DAT_EVD_HANDLE evd_handle);
+extern u32 dapl_evd_free(struct dat_evd *evd);
 
-extern u32 dapl_evd_set_unwaitable(DAT_EVD_HANDLE evd_handle);
+extern u32 dapl_evd_set_unwaitable(struct dat_evd *evd);
 
-extern u32 dapl_evd_clear_unwaitable(DAT_EVD_HANDLE evd_handle);
+extern u32 dapl_evd_clear_unwaitable(struct dat_evd *evd);
 
 /* EP functions */
 
-extern u32 dapl_ep_create(DAT_IA_HANDLE ia_handle, DAT_PZ_HANDLE pz_handle,
-			  DAT_EVD_HANDLE in_dto_completion_evd_handle,
-			  DAT_EVD_HANDLE out_dto_completion_evd_handle,
-			  DAT_EVD_HANDLE connect_evd_handle,
+extern u32 dapl_ep_create(struct dat_ia *ia, struct dat_pz *pz,
+			  struct dat_evd *in_dto_completion_evd,
+			  struct dat_evd *out_dto_completion_evd,
+			  struct dat_evd *connect_evd,
 			  const struct dat_ep_attr *ep_parameters,
-			  DAT_EP_HANDLE *ep_handle);
+			  struct dat_ep **ep);
 
-extern u32 dapl_ep_query(DAT_EP_HANDLE, struct dat_ep_param *);
+extern u32 dapl_ep_query(struct dat_ep *, struct dat_ep_param *);
 
-extern u32 dapl_ep_modify(DAT_EP_HANDLE ep_handle,
+extern u32 dapl_ep_modify(struct dat_ep *ep,
 			  enum dat_ep_param_mask ep_args_mask,
 			  const struct dat_ep_param *ep_args);
 
-extern u32 dapl_ep_connect(DAT_EP_HANDLE ep_handle,
+extern u32 dapl_ep_connect(struct dat_ep *ep,
 			   struct sockaddr *remote_ia_address,
 			   DAT_CONN_QUAL remote_conn_qual,
 			   unsigned long timeout,
@@ -489,161 +449,161 @@ extern u32 dapl_ep_connect(DAT_EP_HANDLE
 			   enum dat_qos quality_of_service,
 			   enum dat_connect_flags connect_flags);
 
-extern u32 dapl_ep_dup_connect(DAT_EP_HANDLE ep_handle,
-			       DAT_EP_HANDLE ep_dup_handle,
+extern u32 dapl_ep_dup_connect(struct dat_ep *ep,
+			       struct dat_ep *ep_dup,
 			       unsigned long timeout,
 			       int private_data_size,
 			       const void *private_data,
 			       enum dat_qos quality_of_service);
 
-extern u32 dapl_ep_disconnect(DAT_EP_HANDLE ep_handle,
+extern u32 dapl_ep_disconnect(struct dat_ep *ep,
 			      enum dat_close_flags close_flags);
 
-extern u32 dapl_ep_post_send(DAT_EP_HANDLE ep_handle, int num_segments,
+extern u32 dapl_ep_post_send(struct dat_ep *ep, int num_segments,
 			     struct dat_lmr_triplet *local_iov,
 			     DAT_DTO_COOKIE user_cookie,
 			     enum dat_completion_flags completion_flags);
 
-extern u32 dapl_ep_post_recv(DAT_EP_HANDLE ep_handle, int num_segments,
+extern u32 dapl_ep_post_recv(struct dat_ep *ep, int num_segments,
 			     struct dat_lmr_triplet *local_iov,
 			     DAT_DTO_COOKIE user_cookie,
 			     enum dat_completion_flags completion_flags);
 
-extern u32 dapl_ep_post_rdma_read(DAT_EP_HANDLE ep_handle,
+extern u32 dapl_ep_post_rdma_read(struct dat_ep *ep,
 				  int num_segments,
 				  struct dat_lmr_triplet *local_iov,
 				  DAT_DTO_COOKIE user_cookie,
 				  const struct dat_rmr_triplet *remote_iov,
 				  enum dat_completion_flags completion_flags);
 
-extern u32 dapl_ep_post_rdma_write(DAT_EP_HANDLE ep_handle,
+extern u32 dapl_ep_post_rdma_write(struct dat_ep *ep,
 				   int num_segments,
 				   struct dat_lmr_triplet *local_iov,
 				   DAT_DTO_COOKIE user_cookie,
 				   const struct dat_rmr_triplet *remote_iov,
 				   enum dat_completion_flags completion_flags);
 
-extern u32 dapl_ep_get_status(DAT_EP_HANDLE ep_handle,
+extern u32 dapl_ep_get_status(struct dat_ep *ep,
 			      enum dat_ep_state *ep_state,
 			      boolean_t *in_dto_idle, boolean_t *out_dto_idle);
 
-extern u32 dapl_ep_free(DAT_EP_HANDLE ep_handle);
+extern u32 dapl_ep_free(struct dat_ep *ep);
 
-extern u32 dapl_ep_reset(DAT_EP_HANDLE ep_handle);
+extern u32 dapl_ep_reset(struct dat_ep *ep);
 
-extern u32 dapl_ep_create_with_srq(DAT_IA_HANDLE ia_handle,
-				   DAT_PZ_HANDLE pz_handle,
-				   DAT_EVD_HANDLE recv_evd_handle,
-				   DAT_EVD_HANDLE request_evd_handle,
-				   DAT_EVD_HANDLE connect_evd_handle,
-				   DAT_SRQ_HANDLE srq_handle,
+extern u32 dapl_ep_create_with_srq(struct dat_ia *ia,
+				   struct dat_pz *pz,
+				   struct dat_evd *recv_evd,
+				   struct dat_evd *request_evd,
+				   struct dat_evd *connect_evd,
+				   struct dat_srq *srq_handle,
 				   const struct dat_ep_attr *ep_attributes,
-				   DAT_EP_HANDLE *ep_handle);
+				   struct dat_ep **ep);
 
-extern u32 dapl_ep_recv_query(DAT_EP_HANDLE ep_handle,
+extern u32 dapl_ep_recv_query(struct dat_ep *ep,
 			      int *nbufs_allocated,
 			      int *bufs_alloc_span);
 
-extern u32 dapl_ep_set_watermark(DAT_EP_HANDLE ep_handle,
+extern u32 dapl_ep_set_watermark(struct dat_ep *ep,
 				 int soft_high_watermark,
 				 int hard_high_watermark);
 
 /* LMR functions */
 
-extern u32 dapl_lmr_kcreate(DAT_IA_HANDLE ia_handle, enum dat_mem_type mem_type,
+extern u32 dapl_lmr_kcreate(struct dat_ia *ia, enum dat_mem_type mem_type,
 			    DAT_REGION_DESCRIPTION region_description,
-			    u64 length, DAT_PZ_HANDLE pz_handle,
+			    u64 length, struct dat_pz *pz,
 			    enum dat_mem_priv_flags privileges,
 			    enum dat_mem_optimize_flags optimization,
-			    DAT_LMR_HANDLE *lmr_handle,
+			    struct dat_lmr **lmr,
 			    DAT_LMR_CONTEXT *lmr_context,
 			    DAT_RMR_CONTEXT *rmr_context,
 			    u64 *registered_length,
 			    u64 *registered_address);
 
-extern u32 dapl_lmr_query(DAT_LMR_HANDLE, struct dat_lmr_param *);
+extern u32 dapl_lmr_query(struct dat_lmr *, struct dat_lmr_param *);
 
-extern u32 dapl_lmr_free(DAT_LMR_HANDLE);
+extern u32 dapl_lmr_free(struct dat_lmr *);
 
-extern u32 dapl_lmr_sync_rdma_read(DAT_IA_HANDLE ia_handle,
+extern u32 dapl_lmr_sync_rdma_read(struct dat_ia *ia,
 				   const struct dat_lmr_triplet *local_segments,
 				   u64 num_segments);
 
-extern u32 dapl_lmr_sync_rdma_write(DAT_IA_HANDLE ia_handle,
+extern u32 dapl_lmr_sync_rdma_write(struct dat_ia *ia,
 				    const struct dat_lmr_triplet *local_segments,
 				    u64 num_segments);
 
 /* RMR Functions */
 
-extern u32 dapl_rmr_create(DAT_PZ_HANDLE pz_handle, DAT_RMR_HANDLE *rmr_handle);
+extern u32 dapl_rmr_create(struct dat_pz *pz, struct dat_rmr **rmr);
 
-extern u32 dapl_rmr_query(DAT_RMR_HANDLE rmr_handle,
+extern u32 dapl_rmr_query(struct dat_rmr *rmr,
 			  struct dat_rmr_param *rmr_args);
 
-extern u32 dapl_rmr_bind(DAT_RMR_HANDLE rmr_handle,
+extern u32 dapl_rmr_bind(struct dat_rmr *rmr,
 			 const struct dat_lmr_triplet *lmr_triplet,
 			 enum dat_mem_priv_flags mem_priv,
-			 DAT_EP_HANDLE ep_handle,
+			 struct dat_ep *ep,
 			 DAT_RMR_COOKIE user_cookie,
 			 enum dat_completion_flags completion_flags,
 			 DAT_RMR_CONTEXT *context);
 
-extern u32 dapl_rmr_free(DAT_RMR_HANDLE);
+extern u32 dapl_rmr_free(struct dat_rmr *rmr);
 
 /* PSP Functions */
 
-extern u32 dapl_psp_create(DAT_IA_HANDLE ia_handle, DAT_CONN_QUAL conn_qual,
-			   DAT_EVD_HANDLE evd_handle,
+extern u32 dapl_psp_create(struct dat_ia *ia, DAT_CONN_QUAL conn_qual,
+			   struct dat_evd *evd,
 			   enum dat_psp_flags psp_flags,
-			   DAT_PSP_HANDLE *psp_handle);
+			   struct dat_sp **psp);
 
-extern u32 dapl_psp_create_any(DAT_IA_HANDLE ia_handle,
+extern u32 dapl_psp_create_any(struct dat_ia *ia,
 			       DAT_CONN_QUAL *conn_qual,
-			       DAT_EVD_HANDLE evd_handle,
+			       struct dat_evd *evd,
 			       enum dat_psp_flags psp_flags,
-			       DAT_PSP_HANDLE *psp_handle);
+			       struct dat_sp **psp);
 
-extern u32 dapl_psp_query(DAT_PSP_HANDLE, struct dat_psp_param *);
+extern u32 dapl_psp_query(struct dat_sp *, struct dat_psp_param *);
 
-extern u32 dapl_psp_free(DAT_PSP_HANDLE psp_handle);
+extern u32 dapl_psp_free(struct dat_sp *psp);
 
 /* RSP Functions */
 
-extern u32 dapl_rsp_create(DAT_IA_HANDLE ia_handle, DAT_CONN_QUAL conn_qual,
-			   DAT_EP_HANDLE ep_handle, DAT_EVD_HANDLE evd_handle,
-			   DAT_RSP_HANDLE *rsp_handle);
+extern u32 dapl_rsp_create(struct dat_ia *ia, DAT_CONN_QUAL conn_qual,
+			   struct dat_ep *ep, struct dat_evd *evd,
+			   struct dat_sp **rsp);
 
-extern u32 dapl_rsp_query(DAT_RSP_HANDLE, struct dat_rsp_param *);
+extern u32 dapl_rsp_query(struct dat_sp *, struct dat_rsp_param *);
 
-extern u32 dapl_rsp_free(DAT_RSP_HANDLE rsp_handle);
+extern u32 dapl_rsp_free(struct dat_sp *rsp);
 
 /* PZ Functions */
 
-extern u32 dapl_pz_create(DAT_IA_HANDLE ia_handle, DAT_PZ_HANDLE *pz_handle);
+extern u32 dapl_pz_create(struct dat_ia *ia, struct dat_pz **pz);
 
-extern u32 dapl_pz_query(DAT_PZ_HANDLE pz_handle, struct dat_pz_param *pz_args);
+extern u32 dapl_pz_query(struct dat_pz *pz, struct dat_pz_param *pz_args);
 
-extern u32 dapl_pz_free(DAT_PZ_HANDLE pz_handle);
+extern u32 dapl_pz_free(struct dat_pz *pz);
 
 /* SRQ functions */
 
-extern u32 dapl_srq_create(DAT_IA_HANDLE ia_handle, DAT_PZ_HANDLE pz_handle,
+extern u32 dapl_srq_create(struct dat_ia *ia, struct dat_pz *pz,
 			   struct dat_srq_attr *srq_attr,
-			   DAT_SRQ_HANDLE *srq_handle);
+			   struct dat_srq **srq);
 
-extern u32 dapl_srq_free(DAT_SRQ_HANDLE srq_handle);
+extern u32 dapl_srq_free(struct dat_srq *srq);
 
-extern u32 dapl_srq_post_recv(DAT_SRQ_HANDLE srq_handle, int num_segments,
+extern u32 dapl_srq_post_recv(struct dat_srq *srq, int num_segments,
 			      struct dat_lmr_triplet *local_iov,
 			      DAT_DTO_COOKIE user_cookie);
 
-extern u32 dapl_srq_query(DAT_SRQ_HANDLE srq_handle,
+extern u32 dapl_srq_query(struct dat_srq *srq,
 			  struct dat_srq_param *srq_param);
 
-extern u32 dapl_srq_resize(DAT_SRQ_HANDLE srq_handle,
+extern u32 dapl_srq_resize(struct dat_srq *srq,
 			   int srq_max_recv_dto);
 
-extern u32 dapl_srq_set_lw(DAT_SRQ_HANDLE srq_handle, int low_watermark);
+extern u32 dapl_srq_set_lw(struct dat_srq *srq, int low_watermark);
 
 /*
  * DAPL internal utility function prototypes
Index: linux-kernel/dat-provider/dapl_ia_util.c
===================================================================
--- linux-kernel/dat-provider/dapl_ia_util.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_ia_util.c	(working copy)
@@ -65,17 +65,12 @@ struct dapl_ia *dapl_ia_alloc(struct dat
 	/* zero the structure */
 	memset(ia_ptr, 0, sizeof *ia_ptr);
 
-	/*
-	 * initialize the header
-	 */
-	ia_ptr->header.provider = provider;
-	ia_ptr->header.magic = DAPL_MAGIC_IA;
-	ia_ptr->header.handle_type = DAT_HANDLE_TYPE_IA;
-	ia_ptr->header.owner_ia = ia_ptr;
-	ia_ptr->header.user_context.as_64 = 0;
-	ia_ptr->header.user_context.as_ptr = NULL;
-	dapl_llist_init_entry(&ia_ptr->header.ia_list_entry);
-	spin_lock_init(&ia_ptr->header.lock);
+	ia_ptr->ia.provider = provider;
+	ia_ptr->common.owner_ia = ia_ptr;
+	ia_ptr->common.user_context.as_64 = 0;
+	ia_ptr->common.user_context.as_ptr = NULL;
+	dapl_llist_init_entry(&ia_ptr->common.ia_list_entry);
+	spin_lock_init(&ia_ptr->common.lock);
 
 	/*
 	 * initialize the body
@@ -127,9 +122,9 @@ u32 dapl_ia_abrupt_close(struct dapl_ia 
 		   ? NULL : dapl_llist_peek_head(&ia_ptr->rmr_list_head));
 	while (rmr_ptr != NULL) {
 		next_rmr_ptr = dapl_llist_next_entry(&ia_ptr->rmr_list_head,
-						     &rmr_ptr->header.
+						     &rmr_ptr->common.
 						     ia_list_entry);
-		dat_status = dapl_rmr_free(rmr_ptr);
+		dat_status = dapl_rmr_free((struct dat_rmr *)rmr_ptr);
 		if (dat_status != DAT_SUCCESS)
 			dapl_dbg_log(DAPL_DBG_TYPE_WARN,
 				     "ia_close(ABRUPT): rmr_free(%p) returns %x\n",
@@ -141,9 +136,9 @@ u32 dapl_ia_abrupt_close(struct dapl_ia 
 		  ? NULL : dapl_llist_peek_head(&ia_ptr->rsp_list_head));
 	while (sp_ptr != NULL) {
 		next_sp_ptr = dapl_llist_next_entry(&ia_ptr->rsp_list_head,
-						    &sp_ptr->header.
+						    &sp_ptr->common.
 						    ia_list_entry);
-		dat_status = dapl_rsp_free(sp_ptr);
+		dat_status = dapl_rsp_free((struct dat_sp *)sp_ptr);
 		if (dat_status != DAT_SUCCESS)
 			dapl_dbg_log(DAPL_DBG_TYPE_WARN,
 				     "ia_close(ABRUPT): rsp_free(%p) returns %x\n",
@@ -155,7 +150,7 @@ u32 dapl_ia_abrupt_close(struct dapl_ia 
 		  ? NULL : dapl_llist_peek_head(&ia_ptr->ep_list_head));
 	while (ep_ptr != NULL) {
 		next_ep_ptr = dapl_llist_next_entry(&ia_ptr->ep_list_head,
-						    &ep_ptr->header.
+						    &ep_ptr->common.
 						    ia_list_entry);
 		/*
 		 * Issue a disconnect if the EP needs it
@@ -163,21 +158,19 @@ u32 dapl_ia_abrupt_close(struct dapl_ia 
 		if (ep_ptr->param.ep_state == DAT_EP_STATE_CONNECTED ||
 		    ep_ptr->param.ep_state == DAT_EP_STATE_DISCONNECTED ||
 		    ep_ptr->param.ep_state ==
-		    DAT_EP_STATE_ACTIVE_CONNECTION_PENDING
-		    || ep_ptr->param.ep_state == DAT_EP_STATE_COMPLETION_PENDING
-		    || ep_ptr->param.ep_state ==
-		    DAT_EP_STATE_DISCONNECT_PENDING) {
-			dat_status =
-			    dapl_ep_disconnect(ep_ptr, DAT_CLOSE_ABRUPT_FLAG);
+		    DAT_EP_STATE_ACTIVE_CONNECTION_PENDING ||
+		    ep_ptr->param.ep_state == DAT_EP_STATE_COMPLETION_PENDING ||		    ep_ptr->param.ep_state == DAT_EP_STATE_DISCONNECT_PENDING) {
+			dat_status = dapl_ep_disconnect((struct dat_ep *)ep_ptr,
+							DAT_CLOSE_ABRUPT_FLAG);
 			if (dat_status != DAT_SUCCESS)
 				dapl_dbg_log(DAPL_DBG_TYPE_WARN,
 					     "ia_close(ABRUPT): ep_disconnect(%p) returns %x\n",
 					     ep_ptr, dat_status);
 		}
 		/* force the EP into error state to force flush all posted DTOs. */
-		(void) dapl_modify_qp_state_to_error(ep_ptr->qp);
+		(void)dapl_modify_qp_state_to_error(ep_ptr->qp);
 
-		dat_status = dapl_ep_free(ep_ptr);
+		dat_status = dapl_ep_free((struct dat_ep *)ep_ptr);
 		if (dat_status != DAT_SUCCESS)
 			dapl_dbg_log(DAPL_DBG_TYPE_WARN,
 				     "ia_close(ABRUPT): ep_free(%p) returns %x\n",
@@ -189,9 +182,9 @@ u32 dapl_ia_abrupt_close(struct dapl_ia 
 		   ? NULL : dapl_llist_peek_head(&ia_ptr->lmr_list_head));
 	while (lmr_ptr != NULL) {
 		next_lmr_ptr = dapl_llist_next_entry(&ia_ptr->lmr_list_head,
-						     &lmr_ptr->header.
+						     &lmr_ptr->common.
 						     ia_list_entry);
-		dat_status = dapl_lmr_free(lmr_ptr);
+		dat_status = dapl_lmr_free((struct dat_lmr *)lmr_ptr);
 		if (dat_status != DAT_SUCCESS)
 			dapl_dbg_log(DAPL_DBG_TYPE_WARN,
 				     "ia_close(ABRUPT): lmr_free(%p) returns %x\n",
@@ -213,7 +206,7 @@ u32 dapl_ia_abrupt_close(struct dapl_ia 
 				     dat_status);
 
 		next_sp_ptr = dapl_llist_next_entry(&ia_ptr->psp_list_head,
-						    &sp_ptr->header.
+						    &sp_ptr->common.
 						    ia_list_entry);
 
 		/* Remove CR's from this PSP and clean them up */
@@ -222,18 +215,19 @@ u32 dapl_ia_abrupt_close(struct dapl_ia 
 		while (cr_ptr != NULL) {
 			next_cr_ptr = dapl_llist_next_entry(
 						&sp_ptr->cr_list_head, 
-						&cr_ptr->header.ia_list_entry);
+						&cr_ptr->common.ia_list_entry);
 			/* Remove the CR from the queue & cleanup */
-			spin_lock_irqsave(&sp_ptr->header.lock, sp_ptr->header.flags);
+			spin_lock_irqsave(&sp_ptr->common.lock,
+					  sp_ptr->common.flags);
 			dapl_sp_remove_cr(sp_ptr, cr_ptr);
-			spin_unlock_irqrestore(&sp_ptr->header.lock, 
-					       sp_ptr->header.flags);
+			spin_unlock_irqrestore(&sp_ptr->common.lock, 
+					       sp_ptr->common.flags);
 
 			dapl_cr_free(cr_ptr);
 			cr_ptr = next_cr_ptr;
 		}
 
-		dat_status = dapl_psp_free(sp_ptr);
+		dat_status = dapl_psp_free((struct dat_sp *)sp_ptr);
 		if (dat_status != DAT_SUCCESS)
 			dapl_dbg_log(DAPL_DBG_TYPE_WARN,
 				     "ia_close(ABRUPT): psp_free(%p) returns %x\n",
@@ -246,9 +240,9 @@ u32 dapl_ia_abrupt_close(struct dapl_ia 
 		  ? NULL : dapl_llist_peek_head(&ia_ptr->pz_list_head));
 	while (pz_ptr != NULL) {
 		next_pz_ptr = dapl_llist_next_entry(&ia_ptr->pz_list_head,
-						    &pz_ptr->header.
+						    &pz_ptr->common.
 						    ia_list_entry);
-		dat_status = dapl_pz_free(pz_ptr);
+		dat_status = dapl_pz_free((struct dat_pz *)pz_ptr);
 		if (dat_status != DAT_SUCCESS)
 			dapl_dbg_log(DAPL_DBG_TYPE_WARN,
 				     "ia_close(ABRUPT): pz_free(%p) returns %x\n",
@@ -266,11 +260,11 @@ u32 dapl_ia_abrupt_close(struct dapl_ia 
 		   ? NULL : dapl_llist_peek_head(&ia_ptr->evd_list_head));
 	while (evd_ptr != NULL) {
 		next_evd_ptr = dapl_llist_next_entry(&ia_ptr->evd_list_head,
-						     &evd_ptr->header.
+						     &evd_ptr->common.
 						     ia_list_entry);
 		if (evd_ptr != ia_ptr->async_error_evd) {
 			/* it isn't the async EVD; delete it.  */
-			dat_status = dapl_evd_free(evd_ptr);
+			dat_status = dapl_evd_free((struct dat_evd *)evd_ptr);
 			if (dat_status != DAT_SUCCESS)
 				dapl_dbg_log(DAPL_DBG_TYPE_WARN,
 					     "ia_close(ABRUPT): evd_free(%p) returns %x\n",
@@ -289,7 +283,7 @@ u32 dapl_ia_abrupt_close(struct dapl_ia 
 		dat_status = dapl_ia_teardown_callbacks(ia_ptr);
 
 		atomic_dec(&ia_ptr->async_error_evd->evd_ref_count);
-		dat_status = dapl_evd_free(ia_ptr->async_error_evd);
+		dat_status = dapl_evd_free((struct dat_evd *)ia_ptr->async_error_evd);
 
 		if (DAT_SUCCESS != dat_status)
 			dapl_dbg_log(DAPL_DBG_TYPE_WARN,
@@ -404,7 +398,7 @@ u32 dapl_ia_graceful_close(struct dapl_i
 		if (DAT_SUCCESS != cur_dat_status)
 			dat_status = cur_dat_status;
 		atomic_dec(&ia_ptr->async_error_evd->evd_ref_count);
-		cur_dat_status = dapl_evd_free(ia_ptr->async_error_evd);
+		cur_dat_status = dapl_evd_free((struct dat_evd *)ia_ptr->async_error_evd);
 		if (DAT_SUCCESS != cur_dat_status)
 			dat_status = cur_dat_status;
 
@@ -424,8 +418,6 @@ bail:
  */
 void dapl_ia_free(struct dapl_ia *ia_ptr)
 {
-	dapl_os_assert(ia_ptr->header.magic == DAPL_MAGIC_IA);
-
 	dapl_os_assert(ia_ptr->async_error_evd == NULL);
 	dapl_os_assert(dapl_llist_is_empty(&ia_ptr->lmr_list_head));
 	dapl_os_assert(dapl_llist_is_empty(&ia_ptr->rmr_list_head));
@@ -434,12 +426,8 @@ void dapl_ia_free(struct dapl_ia *ia_ptr
 	dapl_os_assert(dapl_llist_is_empty(&ia_ptr->psp_list_head));
 	dapl_os_assert(dapl_llist_is_empty(&ia_ptr->rsp_list_head));
 
-	/*
-	 * deinitialize the header
-	 */
 	dapl_hca_unlink_ia(ia_ptr->hca_ptr, ia_ptr);
-	ia_ptr->header.magic = DAPL_MAGIC_INVALID;	/* reset magic to prevent reuse */
-	/* no need to destroy ia_ptr->header.lock */
+	/* no need to destroy ia_ptr->common.lock */
 
 	kfree(ia_ptr);
 }
@@ -449,10 +437,10 @@ void dapl_ia_free(struct dapl_ia *ia_ptr
  */
 void dapl_ia_link_ep(struct dapl_ia *ia_ptr, struct dapl_ep *ep_ptr)
 {
-	spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_lock_irqsave(&ia_ptr->common.lock, ia_ptr->common.flags);
 	dapl_llist_add_head(&ia_ptr->ep_list_head,
-			    &ep_ptr->header.ia_list_entry, ep_ptr);
-	spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
+			    &ep_ptr->common.ia_list_entry, ep_ptr);
+	spin_unlock_irqrestore(&ia_ptr->common.lock, ia_ptr->common.flags);
 }
 
 /*
@@ -460,10 +448,10 @@ void dapl_ia_link_ep(struct dapl_ia *ia_
  */
 void dapl_ia_unlink_ep(struct dapl_ia *ia_ptr, struct dapl_ep *ep_ptr)
 {
-	spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_lock_irqsave(&ia_ptr->common.lock, ia_ptr->common.flags);
 	dapl_llist_remove_entry(&ia_ptr->ep_list_head,
-				&ep_ptr->header.ia_list_entry);
-	spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
+				&ep_ptr->common.ia_list_entry);
+	spin_unlock_irqrestore(&ia_ptr->common.lock, ia_ptr->common.flags);
 }
 
 /*
@@ -471,10 +459,10 @@ void dapl_ia_unlink_ep(struct dapl_ia *i
  */
 void dapl_ia_link_srq(struct dapl_ia *ia_ptr, struct dapl_srq *srq_ptr)
 {
-	spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_lock_irqsave(&ia_ptr->common.lock, ia_ptr->common.flags);
 	dapl_llist_add_head(&ia_ptr->srq_list_head,
-			    &srq_ptr->header.ia_list_entry, srq_ptr);
-	spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
+			    &srq_ptr->common.ia_list_entry, srq_ptr);
+	spin_unlock_irqrestore(&ia_ptr->common.lock, ia_ptr->common.flags);
 }
 
 /*
@@ -482,10 +470,10 @@ void dapl_ia_link_srq(struct dapl_ia *ia
  */
 void dapl_ia_unlink_srq(struct dapl_ia *ia_ptr, struct dapl_srq *srq_ptr)
 {
-	spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_lock_irqsave(&ia_ptr->common.lock, ia_ptr->common.flags);
 	dapl_llist_remove_entry(&ia_ptr->srq_list_head,
-				&srq_ptr->header.ia_list_entry);
-	spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
+				&srq_ptr->common.ia_list_entry);
+	spin_unlock_irqrestore(&ia_ptr->common.lock, ia_ptr->common.flags);
 }
 
 /*
@@ -493,10 +481,10 @@ void dapl_ia_unlink_srq(struct dapl_ia *
  */
 void dapl_ia_link_lmr(struct dapl_ia *ia_ptr, struct dapl_lmr *lmr_ptr)
 {
-	spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_lock_irqsave(&ia_ptr->common.lock, ia_ptr->common.flags);
 	dapl_llist_add_head(&ia_ptr->lmr_list_head,
-			    &lmr_ptr->header.ia_list_entry, lmr_ptr);
-	spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
+			    &lmr_ptr->common.ia_list_entry, lmr_ptr);
+	spin_unlock_irqrestore(&ia_ptr->common.lock, ia_ptr->common.flags);
 }
 
 /*
@@ -504,10 +492,10 @@ void dapl_ia_link_lmr(struct dapl_ia *ia
  */
 void dapl_ia_unlink_lmr(struct dapl_ia *ia_ptr, struct dapl_lmr *lmr_ptr)
 {
-	spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_lock_irqsave(&ia_ptr->common.lock, ia_ptr->common.flags);
 	dapl_llist_remove_entry(&ia_ptr->lmr_list_head,
-				&lmr_ptr->header.ia_list_entry);
-	spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
+				&lmr_ptr->common.ia_list_entry);
+	spin_unlock_irqrestore(&ia_ptr->common.lock, ia_ptr->common.flags);
 }
 
 /*
@@ -515,10 +503,10 @@ void dapl_ia_unlink_lmr(struct dapl_ia *
  */
 void dapl_ia_link_rmr(struct dapl_ia *ia_ptr, struct dapl_rmr *rmr_ptr)
 {
-	spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_lock_irqsave(&ia_ptr->common.lock, ia_ptr->common.flags);
 	dapl_llist_add_head(&ia_ptr->rmr_list_head,
-			    &rmr_ptr->header.ia_list_entry, rmr_ptr);
-	spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
+			    &rmr_ptr->common.ia_list_entry, rmr_ptr);
+	spin_unlock_irqrestore(&ia_ptr->common.lock, ia_ptr->common.flags);
 }
 
 /*
@@ -526,10 +514,10 @@ void dapl_ia_link_rmr(struct dapl_ia *ia
  */
 void dapl_ia_unlink_rmr(struct dapl_ia *ia_ptr, struct dapl_rmr *rmr_ptr)
 {
-	spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_lock_irqsave(&ia_ptr->common.lock, ia_ptr->common.flags);
 	dapl_llist_remove_entry(&ia_ptr->rmr_list_head,
-				&rmr_ptr->header.ia_list_entry);
-	spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
+				&rmr_ptr->common.ia_list_entry);
+	spin_unlock_irqrestore(&ia_ptr->common.lock, ia_ptr->common.flags);
 }
 
 /*
@@ -537,10 +525,10 @@ void dapl_ia_unlink_rmr(struct dapl_ia *
  */
 void dapl_ia_link_pz(struct dapl_ia *ia_ptr, struct dapl_pz *pz_ptr)
 {
-	spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_lock_irqsave(&ia_ptr->common.lock, ia_ptr->common.flags);
 	dapl_llist_add_head(&ia_ptr->pz_list_head,
-			    &pz_ptr->header.ia_list_entry, pz_ptr);
-	spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
+			    &pz_ptr->common.ia_list_entry, pz_ptr);
+	spin_unlock_irqrestore(&ia_ptr->common.lock, ia_ptr->common.flags);
 }
 
 /*
@@ -548,10 +536,10 @@ void dapl_ia_link_pz(struct dapl_ia *ia_
  */
 void dapl_ia_unlink_pz(struct dapl_ia *ia_ptr, struct dapl_pz *pz_ptr)
 {
-	spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_lock_irqsave(&ia_ptr->common.lock, ia_ptr->common.flags);
 	dapl_llist_remove_entry(&ia_ptr->pz_list_head,
-				&pz_ptr->header.ia_list_entry);
-	spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
+				&pz_ptr->common.ia_list_entry);
+	spin_unlock_irqrestore(&ia_ptr->common.lock, ia_ptr->common.flags);
 }
 
 /*
@@ -559,10 +547,10 @@ void dapl_ia_unlink_pz(struct dapl_ia *i
  */
 void dapl_ia_link_evd(struct dapl_ia *ia_ptr, struct dapl_evd *evd_ptr)
 {
-	spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_lock_irqsave(&ia_ptr->common.lock, ia_ptr->common.flags);
 	dapl_llist_add_head(&ia_ptr->evd_list_head,
-			    &evd_ptr->header.ia_list_entry, evd_ptr);
-	spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
+			    &evd_ptr->common.ia_list_entry, evd_ptr);
+	spin_unlock_irqrestore(&ia_ptr->common.lock, ia_ptr->common.flags);
 }
 
 /*
@@ -570,10 +558,10 @@ void dapl_ia_link_evd(struct dapl_ia *ia
  */
 void dapl_ia_unlink_evd(struct dapl_ia *ia_ptr, struct dapl_evd *evd_ptr)
 {
-	spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_lock_irqsave(&ia_ptr->common.lock, ia_ptr->common.flags);
 	dapl_llist_remove_entry(&ia_ptr->evd_list_head,
-				&evd_ptr->header.ia_list_entry);
-	spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
+				&evd_ptr->common.ia_list_entry);
+	spin_unlock_irqrestore(&ia_ptr->common.lock, ia_ptr->common.flags);
 }
 
 /*
@@ -581,10 +569,10 @@ void dapl_ia_unlink_evd(struct dapl_ia *
  */
 void dapl_ia_link_psp(struct dapl_ia *ia_ptr, struct dapl_sp *sp_ptr)
 {
-	spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_lock_irqsave(&ia_ptr->common.lock, ia_ptr->common.flags);
 	dapl_llist_add_head(&ia_ptr->psp_list_head,
-			    &sp_ptr->header.ia_list_entry, sp_ptr);
-	spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
+			    &sp_ptr->common.ia_list_entry, sp_ptr);
+	spin_unlock_irqrestore(&ia_ptr->common.lock, ia_ptr->common.flags);
 }
 
 /*
@@ -594,17 +582,17 @@ void dapl_ia_unlink_sp(struct dapl_ia *i
 {
 	struct dapl_llist_entry **list_head;
 
-	if (sp_ptr->header.handle_type == DAT_HANDLE_TYPE_PSP) {
+	if (sp_ptr->sp.type == DAT_SP_TYPE_PSP) {
 		list_head = &ia_ptr->psp_list_head;
 	} else {
-		dapl_os_assert(sp_ptr->header.handle_type ==
-			       DAT_HANDLE_TYPE_RSP);
+		dapl_os_assert(sp_ptr->sp.type ==
+			       DAT_SP_TYPE_RSP);
 		list_head = &ia_ptr->rsp_list_head;
 	}
 
-	spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
-	dapl_llist_remove_entry(list_head, &sp_ptr->header.ia_list_entry);
-	spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_lock_irqsave(&ia_ptr->common.lock, ia_ptr->common.flags);
+	dapl_llist_remove_entry(list_head, &sp_ptr->common.ia_list_entry);
+	spin_unlock_irqrestore(&ia_ptr->common.lock, ia_ptr->common.flags);
 }
 
 /*
@@ -634,7 +622,7 @@ struct dapl_sp *dapl_ia_sp_search(struct
 	else
 		list_head = &ia_ptr->rsp_list_head;
 
-	spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_lock_irqsave(&ia_ptr->common.lock, ia_ptr->common.flags);
 
 	sp_ptr = (dapl_llist_is_empty(list_head) ? NULL :
 		  dapl_llist_peek_head(list_head));
@@ -644,10 +632,10 @@ struct dapl_sp *dapl_ia_sp_search(struct
 			break;
 		
 		sp_ptr = dapl_llist_next_entry(list_head,
-					       &sp_ptr->header.ia_list_entry);
+					       &sp_ptr->common.ia_list_entry);
 	}
 
-	spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_unlock_irqrestore(&ia_ptr->common.lock, ia_ptr->common.flags);
 
 	return sp_ptr;
 }
@@ -670,10 +658,10 @@ struct dapl_sp *dapl_ia_sp_search(struct
  */
 void dapl_ia_link_rsp(struct dapl_ia *ia_ptr, struct dapl_sp *sp_ptr)
 {
-	spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
+	spin_lock_irqsave(&ia_ptr->common.lock, ia_ptr->common.flags);
 	dapl_llist_add_head(&ia_ptr->rsp_list_head,
-			    &sp_ptr->header.ia_list_entry, sp_ptr);
-	spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
+			    &sp_ptr->common.ia_list_entry, sp_ptr);
+	spin_unlock_irqrestore(&ia_ptr->common.lock, ia_ptr->common.flags);
 }
 
 u32 dapl_ia_setup_callbacks(struct dapl_ia *ia_ptr,
Index: linux-kernel/dat-provider/dapl_cr_query.c
===================================================================
--- linux-kernel/dat-provider/dapl_cr_query.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_cr_query.c	(working copy)
@@ -34,16 +34,16 @@
 #include "dapl.h"
 #include "dapl_openib_util.h"
 
-u32 dapl_cr_query(DAT_CR_HANDLE cr_handle, struct dat_cr_param *cr_param)
+u32 dapl_cr_query(struct dat_cr *cr, struct dat_cr_param *cr_param)
 {
 	struct dapl_cr *cr_ptr;
 	u32 status;
 
 	dapl_dbg_log(DAPL_DBG_TYPE_API,
 		     "dapl_cr_query (%p, %x, %p)\n",
-		     cr_handle, cr_param);
+		     cr, cr_param);
 
-	if (DAPL_BAD_HANDLE(cr_handle, DAPL_MAGIC_CR)) {
+	if (cr == NULL) {
 		status = DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_CR);
 		goto bail;
 	}
@@ -53,10 +53,10 @@ u32 dapl_cr_query(DAT_CR_HANDLE cr_handl
 		goto bail;
 	}
 
-	cr_ptr = (struct dapl_cr *)cr_handle;
+	cr_ptr = (struct dapl_cr *)cr;
 
 	/* obtain the remote IP address */
-        (void) dapl_ib_cm_remote_addr((DAT_HANDLE) cr_handle, 
+        (void) dapl_ib_cm_remote_addr((void *) cr, 
                                       &cr_ptr->remote_ia_address);
 
 	/* since the arguments are easily accessible, ignore the mask */
Index: linux-kernel/dat-provider/dapl_provider.c
===================================================================
--- linux-kernel/dat-provider/dapl_provider.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_provider.c	(working copy)
@@ -71,9 +71,8 @@ static struct dat_provider g_dapl_provid
 	.ia_close_func = &dapl_ia_close,
 	.ia_memtype_hint_func = &dapl_ia_memtype_hint,
 
-	.set_consumer_context_func = &dapl_set_consumer_context,
-	.get_consumer_context_func = &dapl_get_consumer_context,
-	.get_handle_type_func = &dapl_get_handle_type,
+	.set_consumer_context_func = NULL,
+	.get_consumer_context_func = NULL,
 
 	.cr_query_func = &dapl_cr_query,
 	.cr_accept_func = &dapl_cr_accept,
Index: linux-kernel/dat-provider/dapl_openib_cm.c
===================================================================
--- linux-kernel/dat-provider/dapl_openib_cm.c	(revision 2572)
+++ linux-kernel/dat-provider/dapl_openib_cm.c	(working copy)
@@ -70,7 +70,7 @@ static void dapl_destroy_cm_id(struct da
 			     conn, conn->cm_id);
 		ib_destroy_cm_id(conn->cm_id);
 		if (conn->ep)
-			conn->ep->cm_handle = NULL;
+			conn->ep->cm = NULL;
 		kfree(conn);
 	}
 }
@@ -172,7 +172,7 @@ static int dapl_cm_active_cb_handler(str
 	spin_unlock_irqrestore(&conn->lock, flags);
 	if (ret) {
 		if (conn->ep)
-			conn->ep->cm_handle = NULL;
+			conn->ep->cm = NULL;
 		kfree(conn);
 	}
 	return ret;
@@ -285,7 +285,7 @@ static int dapl_cm_passive_cb_handler(st
 	spin_unlock_irqrestore(&conn->lock, flags);
 	if (ret) {
 		if (conn->ep)
-			conn->ep->cm_handle = NULL;
+			conn->ep->cm = NULL;
 		kfree(conn);
 	}
 	return ret;
@@ -413,7 +413,7 @@ error:
  * Initiate a connection with the passive listener on another node
  *
  * Input:
- *        ep_handle
+ *        ep
  *        remote_ia_address
  *        remote_conn_qual
  *        private_data_size    size of private data and structure
@@ -428,7 +428,7 @@ error:
  *         DAT_INVALID_PARAMETER
  * 
  */
-u32 dapl_ib_connect(DAT_EP_HANDLE ep_handle,
+u32 dapl_ib_connect(struct dat_ep *ep,
 		    struct sockaddr *remote_ia_address,
 		    DAT_CONN_QUAL remote_conn_qual, unsigned long timeout,
 		    int private_data_size, void *private_data)
@@ -438,7 +438,7 @@ u32 dapl_ib_connect(DAT_EP_HANDLE ep_han
 	struct dapl_cm_id *conn;
 	int status;
 
-	ep_ptr = (struct dapl_ep *)ep_handle;
+	ep_ptr = (struct dapl_ep *)ep;
 	if (ep_ptr->qp == NULL) {
 		printk(KERN_ERR "dapl_ib_connect: qp handle invalid\n");
 		return DAT_INTERNAL_ERROR;
@@ -460,9 +460,9 @@ u32 dapl_ib_connect(DAT_EP_HANDLE ep_han
 		kfree(conn);
 		return DAT_INTERNAL_ERROR;
 	}
-	conn->ep->cm_handle = conn;
+	conn->ep->cm = conn;
 
-	ia_ptr = conn->ep->header.owner_ia;
+	ia_ptr = conn->ep->common.owner_ia;
 
 	/* Setup QP/CM parameters */
 	memset(&conn->param, 0, sizeof conn->param);
@@ -507,7 +507,7 @@ u32 dapl_ib_connect(DAT_EP_HANDLE ep_han
  * Disconnect an EP
  *
  * Input:
- *        ep_handle
+ *        ep
  *        close_flags
  *
  * Output:
@@ -521,7 +521,7 @@ u32 dapl_ib_connect(DAT_EP_HANDLE ep_han
  */
 u32 dapl_ib_disconnect(struct dapl_ep *ep_ptr, enum dat_close_flags close_flags)
 {
-	struct dapl_cm_id *conn = ep_ptr->cm_handle;
+	struct dapl_cm_id *conn = ep_ptr->cm;
 	int status;
 
 	dapl_dbg_log(DAPL_DBG_TYPE_CM,
@@ -537,7 +537,7 @@ u32 dapl_ib_disconnect(struct dapl_ep *e
 		status = ib_send_cm_dreq(conn->cm_id, NULL, 0);
 		if (status)
 			printk(KERN_ERR "dapl_ib_disconnect: CM ID 0x%p "
-			       "status %d\n", ep_ptr->cm_handle, status);
+			       "status %d\n", ep_ptr->cm, status);
 	}
 
 	return DAT_SUCCESS;
@@ -607,14 +607,14 @@ void dapl_ib_reinit_ep(struct dapl_ep *e
 	dapl_dbg_log(DAPL_DBG_TYPE_CM,
 		     "  >>> dapl_ib_reinit_ep: EP %p\n", ep_ptr);
 
-	ia_ptr = ep_ptr->header.owner_ia;
+	ia_ptr = ep_ptr->common.owner_ia;
 
 	/*
 	 * What if QP is connected?  Do we need to destroy the cm_id
 	 * here as well, send a DREQ, REJ?  What cm_id state are we in?
 	 * we may not care if we just destroy the cm_id
-	 * ib_destroy_cm_id(ep_ptr->cm_handle);
-	 * supporting this call may require setting the cm_handle to
+	 * ib_destroy_cm_id(ep_ptr->cm);
+	 * supporting this call may require setting the cm to
 	 * something like NULL wherever it is destroyed
 	 */
 
@@ -685,7 +685,7 @@ u32 dapl_ib_setup_conn_listener(struct d
  * Have the CM remove a connection listener.
  *
  * Input:
- *      ia_handle               IA handle
+ *      ia               IA handle
  *      ServiceID               IB Channel Service ID
  *
  * Output:
@@ -719,7 +719,7 @@ u32 dapl_ib_remove_conn_listener(struct 
  * Perform necessary steps to reject a connection
  *
  * Input:
- *        cm_handle
+ *        cm
  *
  * Output:
  *         none
@@ -730,24 +730,24 @@ u32 dapl_ib_remove_conn_listener(struct 
  *        DAT_INVALID_PARAMETER
  *
  */
-u32 dapl_ib_reject_connection(struct dapl_cm_id *cm_handle)
+u32 dapl_ib_reject_connection(struct dapl_cm_id *cm)
 {
 	int status;
 
-	if (cm_handle == NULL) {
+	if (cm == NULL) {
 		dapl_dbg_log(DAPL_DBG_TYPE_ERR, 
 			     "dapl_ib_reject_connection: invalid cm handle\n");
 		return DAT_SUCCESS;
 	}
 
-	status = ib_send_cm_rej(cm_handle->cm_id, IB_CM_REJ_CONSUMER_DEFINED,
+	status = ib_send_cm_rej(cm->cm_id, IB_CM_REJ_CONSUMER_DEFINED,
 				NULL, 0, NULL, 0);
 	if (status) {
 		dapl_dbg_log(DAPL_DBG_TYPE_ERR, " dapl_ib_reject_connection: "
 			     "ib_send_cm_rej failed: %d\n", status);
 		return DAT_ERROR(DAT_INSUFFICIENT_RESOURCES, 0);
 	}
-	dapl_destroy_cm_id(cm_handle);
+	dapl_destroy_cm_id(cm);
 	return DAT_SUCCESS;
 }
 
@@ -757,8 +757,8 @@ u32 dapl_ib_reject_connection(struct dap
  * Perform necessary steps to accept a connection
  *
  * Input:
- *        cr_handle
- *        ep_handle
+ *        cr
+ *        ep
  *        private_data_size
  *        private_data
  *
@@ -771,7 +771,7 @@ u32 dapl_ib_reject_connection(struct dap
  *        DAT_INVALID_PARAMETER
  *
  */
-u32 dapl_ib_accept_connection(DAT_CR_HANDLE cr_handle, DAT_EP_HANDLE ep_handle,
+u32 dapl_ib_accept_connection(struct dat_cr *cr, struct dat_ep *ep,
 			      int private_data_size,
 			      const void *prd_ptr)
 {
@@ -783,9 +783,9 @@ u32 dapl_ib_accept_connection(DAT_CR_HAN
 	struct ib_cm_rep_param passive_params;
 	struct dapl_cm_id *conn;
 
-	cr_ptr = (struct dapl_cr *)cr_handle;
-	ep_ptr = (struct dapl_ep *)ep_handle;
-	ia_ptr = ep_ptr->header.owner_ia;
+	cr_ptr = (struct dapl_cr *)cr;
+	ep_ptr = (struct dapl_ep *)ep;
+	ia_ptr = ep_ptr->common.owner_ia;
 	conn = cr_ptr->ib_cm_handle;
 
 	/* Obtain size of private data structure & contents */
@@ -810,8 +810,8 @@ u32 dapl_ib_accept_connection(DAT_CR_HAN
 		}
 	}
 
-	cr_ptr->param.local_ep_handle = ep_handle;
-	ep_ptr->cm_handle = conn;
+	cr_ptr->param.local_ep = ep;
+	ep_ptr->cm = conn;
 	conn->ep = ep_ptr;
 
 	memset(&passive_params, 0, sizeof passive_params);
@@ -851,7 +851,7 @@ reject:
 /*
  * ib_cm_get_remote_gid 
  */
-static int ib_cm_get_remote_gid(struct dapl_cm_id *cm_handle, u8 *remote_gid)
+static int ib_cm_get_remote_gid(struct dapl_cm_id *cm, u8 *remote_gid)
 {
 	return DAT_INTERNAL_ERROR;	/* for now!!! */
 }
@@ -862,7 +862,7 @@ static int ib_cm_get_remote_gid(struct d
  * Obtain the remote IP address given a connection
  *
  * Input:
- *	cr_handle
+ *	cr
  *	private data structure handle (only if not using ATS)
  *
  * Output:
@@ -874,7 +874,7 @@ static int ib_cm_get_remote_gid(struct d
  *	DAT_INVALID_PARAMETER
  *
  */
-u32 dapl_ib_cm_remote_addr(DAT_HANDLE dat_handle,
+u32 dapl_ib_cm_remote_addr(void *dat_handle,
 			   struct sockaddr_in6 *remote_ia_address)
 {
 	struct dapl_ia *ia_ptr;
@@ -883,7 +883,7 @@ u32 dapl_ib_cm_remote_addr(DAT_HANDLE da
 
 	struct dapl_cr *cr_ptr = (struct dapl_cr *)dat_handle;
 
-	ia_ptr = (struct dapl_ia *)cr_ptr->sp_ptr->ia_handle;
+	ia_ptr = (struct dapl_ia *)cr_ptr->sp_ptr->ia;
 
 	rc = ib_cm_get_remote_gid(cr_ptr->ib_cm_handle, (u8 *) & remote_gid);
 	if (rc < 0)
Index: linux-kernel/patches/alt_dat_provider_makefile
===================================================================
--- linux-kernel/patches/alt_dat_provider_makefile	(revision 2572)
+++ linux-kernel/patches/alt_dat_provider_makefile	(working copy)
@@ -21,8 +21,6 @@ PROVIDER_MODULES := \
         dapl_cr_util                  	\
         dapl_ep               	        \
         dapl_evd                        \
-        dapl_get_consumer_context     	\
-        dapl_get_handle_type          	\
         dapl_hash                     	\
         dapl_hca_util                 	\
         dapl_ia_close                 	\
@@ -39,7 +37,6 @@ PROVIDER_MODULES := \
         dapl_ring_buffer_util         	\
         dapl_rmr                        \
         dapl_rsp                	\
-        dapl_set_consumer_context     	\
         dapl_sp_util                  	\
         dapl_srq                 	\
 	dapl_util
Index: linux-kernel/dat/api.c
===================================================================
--- linux-kernel/dat/api.c	(revision 2572)
+++ linux-kernel/dat/api.c	(working copy)
@@ -350,7 +350,7 @@ static u32 dat_strerror_minor(u32 value,
 }
 
 u32 dat_ia_openv(const char *name, int async_event_qlen,
-		 DAT_EVD_HANDLE *async_event_handle, DAT_IA_HANDLE *ia_handle,
+		 struct dat_evd **async_event_handle, struct dat_ia **ia,
 		 u32 dat_major, u32 dat_minor, boolean_t thread_safety)
 {
 	DAT_IA_OPEN_FUNC ia_open_func;
@@ -387,13 +387,12 @@ u32 dat_ia_openv(const char *name, int a
 		return status;
 	}
 
-        return ia_open_func(name, async_event_qlen, async_event_handle,	
-			    ia_handle);
+        return ia_open_func(name, async_event_qlen, async_event_handle,	ia);
 }
 
 EXPORT_SYMBOL(dat_ia_openv);
 
-u32 dat_ia_close(DAT_IA_HANDLE ia_handle, enum dat_close_flags flags)
+u32 dat_ia_close(struct dat_ia *ia, enum dat_close_flags flags)
 {
 	struct dat_provider *provider;
 	struct dat_provider_attr provider_attr;
@@ -401,17 +400,16 @@ u32 dat_ia_close(DAT_IA_HANDLE ia_handle
 	const char *ia_name;
 
 	dat_dbg_print(DAT_DBG_TYPE_CONSUMER_API, 
-                      "%s(ia:%x, flags:%x)\n", __func__, ia_handle, flags);
+                      "%s(ia:%x, flags:%x)\n", __func__, ia, flags);
         
-	provider = DAT_HANDLE_TO_PROVIDER(ia_handle);
+	provider = DAT_HANDLE_TO_PROVIDER(ia);
 	ia_name = provider->device_name;
 
-	if (DAT_SUCCESS != (status = dat_ia_query(ia_handle, NULL, NULL,
+	if (DAT_SUCCESS != (status = dat_ia_query(ia, NULL, NULL,
 						  &provider_attr)))
 		dat_dbg_print(DAT_DBG_TYPE_CONSUMER_API,
 			      "dat_ia_query for IA %s failed\n", ia_name);
-	else if (DAT_SUCCESS != (status = provider->ia_close_func(ia_handle,
-								  flags)))
+	else if (DAT_SUCCESS != (status = provider->ia_close_func(ia, flags)))
 		dat_dbg_print(DAT_DBG_TYPE_CONSUMER_API,
 			      "close function for IA %s failed\n", ia_name);
 	else {
Index: linux-kernel/dat/dat.h
===================================================================
--- linux-kernel/dat/dat.h	(revision 2572)
+++ linux-kernel/dat/dat.h	(working copy)
@@ -333,20 +333,6 @@ enum dat_return_subtype {
 #define DAT_GET_TYPE(status)    ((u32)(status) & DAT_TYPE_MASK)
 #define DAT_GET_SUBTYPE(status) ((u32)(status) & DAT_SUBTYPE_MASK)
 
-/* dat handle types */
-enum dat_handle_type {
-	DAT_HANDLE_TYPE_CR,
-	DAT_HANDLE_TYPE_EP,
-	DAT_HANDLE_TYPE_EVD,
-	DAT_HANDLE_TYPE_IA,
-	DAT_HANDLE_TYPE_LMR,
-	DAT_HANDLE_TYPE_PSP,
-	DAT_HANDLE_TYPE_PZ,
-	DAT_HANDLE_TYPE_RMR,
-	DAT_HANDLE_TYPE_RSP,
-	DAT_HANDLE_TYPE_SRQ
-};
-
 #define DAT_NAME_MAX_LENGTH     256
 
 struct dat_named_attr {
@@ -385,21 +371,6 @@ enum dat_completion_flags {
 
 #define DAT_TIMEOUT_MAX ULONG_MAX
 
-/* dat handles */
-typedef void *DAT_HANDLE;
-typedef DAT_HANDLE DAT_CR_HANDLE;
-typedef DAT_HANDLE DAT_EP_HANDLE;
-typedef DAT_HANDLE DAT_EVD_HANDLE;
-typedef DAT_HANDLE DAT_IA_HANDLE;
-typedef DAT_HANDLE DAT_LMR_HANDLE;
-typedef DAT_HANDLE DAT_PSP_HANDLE;
-typedef DAT_HANDLE DAT_PZ_HANDLE;
-typedef DAT_HANDLE DAT_RMR_HANDLE;
-typedef DAT_HANDLE DAT_RSP_HANDLE;
-typedef DAT_HANDLE DAT_SRQ_HANDLE;
-
-#define DAT_HANDLE_NULL ((DAT_HANDLE)NULL)
-
 typedef u64 DAT_CONN_QUAL;
 typedef u64 DAT_PORT_QUAL;
 
@@ -541,8 +512,8 @@ enum dat_mem_priv_flags {
 
 /* RMR Arguments */
 struct dat_rmr_param {
-	DAT_IA_HANDLE ia_handle;
-	DAT_PZ_HANDLE pz_handle;
+	struct dat_ia *ia;
+	struct dat_pz *pz;
 	struct dat_lmr_triplet lmr_triplet;
 	enum dat_mem_priv_flags mem_priv;
 	DAT_RMR_CONTEXT rmr_context;
@@ -588,17 +559,17 @@ enum dat_ep_state {
 };
 
 struct dat_ep_param {
-	DAT_IA_HANDLE ia_handle;
+	struct dat_ia *ia;
 	enum dat_ep_state ep_state;
 	struct sockaddr *local_ia_address_ptr;
 	DAT_PORT_QUAL local_port_qual;
 	struct sockaddr *remote_ia_address_ptr;
 	DAT_PORT_QUAL remote_port_qual;
-	DAT_PZ_HANDLE pz_handle;
-	DAT_EVD_HANDLE recv_evd_handle;
-	DAT_EVD_HANDLE request_evd_handle;
-	DAT_EVD_HANDLE connect_evd_handle;
-	DAT_SRQ_HANDLE srq_handle;
+	struct dat_pz *pz;
+	struct dat_evd *recv_evd;
+	struct dat_evd *request_evd;
+	struct dat_evd *connect_evd;
+	struct dat_srq *srq;
 	struct dat_ep_attr ep_attr;
 };
 
@@ -654,9 +625,9 @@ struct dat_srq_attr {
 };
 
 struct dat_srq_param {
-	DAT_IA_HANDLE ia_handle;
+	struct dat_ia *ia;
 	enum dat_srq_state srq_state;
-	DAT_PZ_HANDLE pz_handle;
+	struct dat_pz *pz;
 	int max_recv_dtos;
 	int max_recv_iov;
 	int low_watermark;
@@ -667,25 +638,25 @@ struct dat_srq_param {
 /* PZ Parameters */
 
 struct dat_pz_param {
-	DAT_IA_HANDLE ia_handle;
+	struct dat_ia *ia;
 };
 
 /* PSP Parameters */
 
 struct dat_psp_param {
-	DAT_IA_HANDLE ia_handle;
+	struct dat_ia *ia;
 	DAT_CONN_QUAL conn_qual;
-	DAT_EVD_HANDLE evd_handle;
+	struct dat_evd *evd;
 	enum dat_psp_flags psp_flags;
 };
 
 /* RSP Parameters */
 
 struct dat_rsp_param {
-	DAT_IA_HANDLE ia_handle;
+	struct dat_ia *ia;
 	DAT_CONN_QUAL conn_qual;
-	DAT_EVD_HANDLE evd_handle;
-	DAT_EP_HANDLE ep_handle;
+	struct dat_evd *evd;
+	struct dat_ep *ep;
 };
 
 /* Connection Request Parameters.
@@ -712,11 +683,11 @@ struct dat_cr_param {
 
 	/* The local Endpoint provided by the Service Point for the requested
 	 * connection. It is the only Endpoint that can accept a Connection
-	 * Request on this Service Point. The value DAT_HANDLE_NULL
+	 * Request on this Service Point. The value NULL
 	 * represents that there is no associated local Endpoint for the
 	 * requested connection.
 	 */
-	DAT_EP_HANDLE local_ep_handle;
+	struct dat_ep *local_ep;
 };
 
 /************************** Events ******************************/
@@ -753,7 +724,7 @@ enum dat_dto_completion_status {
 /* DTO completion event data */
 /* transfered_length is not defined if status is not DAT_SUCCESS */
 struct dat_dto_completion_event_data {
-	DAT_EP_HANDLE ep_handle;
+	struct dat_ep *ep;
 	DAT_DTO_COOKIE user_cookie;
 	enum dat_dto_completion_status status;
 	u64 transfered_length;
@@ -761,25 +732,20 @@ struct dat_dto_completion_event_data {
 
     /* RMR bind  completion event data */
 struct dat_rmr_bind_completion_event_data {
-	DAT_RMR_HANDLE rmr_handle;
+	struct dat_rmr *rmr;
 	DAT_RMR_COOKIE user_cookie;
 	enum dat_dto_completion_status status;
 };
 
-typedef union dat_sp_handle {
-	DAT_RSP_HANDLE rsp_handle;
-	DAT_PSP_HANDLE psp_handle;
-} DAT_SP_HANDLE;
-
     /* Connection Request Arrival event data */
 struct dat_cr_arrival_event_data {
 	/* Handle to the Service Point that received the Connection Request
 	 * from the remote side. If the Service Point was Reserved, sp is
-	 * DAT_HANDLE_NULL because the reserved Service Point is
+	 * NULL because the reserved Service Point is
 	 * automatically destroyed upon generating this event. Can be PSP
 	 * or RSP.
 	 */
-	DAT_SP_HANDLE sp_handle;
+	struct dat_sp *sp;
 
 	/* Address of the IA on which the Connection Request arrived. */
 	struct sockaddr *local_ia_address_ptr;
@@ -791,30 +757,30 @@ struct dat_cr_arrival_event_data {
 
 	/* The Connection Request instance created by a Provider for the 
 	 * arrived Connection Request. Consumers can find out private_data 
-	 * passed by a remote Consumer from cr_handle. It is up to a Consumer
+	 * passed by a remote Consumer from cr. It is up to a Consumer
 	 * to dat_cr_accept or dat_cr_reject of the Connection Request.
 	 */
-	DAT_CR_HANDLE cr_handle;
+	struct dat_cr *cr;
 };
 
     /* Connection event data */
 struct dat_connection_event_data {
-	DAT_EP_HANDLE ep_handle;
+	struct dat_ep *ep;
 	int private_data_size;
 	void *private_data;
 };
 
 /* Async Error event data */
 
-/* For unaffiliated asynchronous event dat_handle is ia_handle. For
- * Endpoint affiliated asynchronous event dat_handle is ep_handle. For
- * EVD affiliated asynchronous event dat_handle is evd_handle. For SRQ
+/* For unaffiliated asynchronous event dat_handle is ia. For
+ * Endpoint affiliated asynchronous event dat_handle is ep. For
+ * EVD affiliated asynchronous event dat_handle is evd. For SRQ
  * affiliated asynchronous event dat_handle is srq_handle. For Memory
- * affiliated asynchronous event dat_handle is either lmr_handle,
- * rmr_handle or pz_handle.
+ * affiliated asynchronous event dat_handle is either lmr,
+ * rmr_handle or pz.
  */
 struct dat_asynch_error_event_data {
-	DAT_HANDLE dat_handle;	/* either IA, EP, EVD, SRQ, */
+	void *dat_handle;	/* either IA, EP, EVD, SRQ, */
 	/* LMR, RMR, or PZ handle   */
 	int reason;	/* object specific          */
 };
@@ -894,7 +860,7 @@ typedef union dat_event_data {
 
 struct dat_event {
 	enum dat_event_number event_number;
-	DAT_EVD_HANDLE evd_handle;
+	struct dat_evd *evd;
 	DAT_EVENT_DATA event_data;
 };
 
@@ -934,7 +900,7 @@ struct dat_provider_info {
 };
 
 struct dat_evd_param {
-	DAT_IA_HANDLE ia_handle;
+	struct dat_ia *ia;
 	int evd_qlen;
 	enum dat_upcall_policy upcall_policy;
 	struct dat_upcall_object upcall;
@@ -960,7 +926,7 @@ enum dat_mem_optimize_flags {
 
 typedef union dat_region_description {
 	void *for_va;
-	DAT_LMR_HANDLE for_lmr_handle;
+	struct dat_lmr *for_lmr;
 	void *for_pointer;	/* For kdapl only */
 	void *for_array;	/* For kdapl only */
 	u64 for_pa;		/* For kdapl only */
@@ -968,11 +934,11 @@ typedef union dat_region_description {
 
 /* LMR Arguments */
 struct dat_lmr_param {
-	DAT_IA_HANDLE ia_handle;
+	struct dat_ia *ia;
 	enum dat_mem_type mem_type;
 	DAT_REGION_DESCRIPTION region_desc;
 	u64 length;
-	DAT_PZ_HANDLE pz_handle;
+	struct dat_pz *pz;
 	enum dat_mem_priv_flags mem_priv;
 	DAT_LMR_CONTEXT lmr_context;
 	DAT_RMR_CONTEXT rmr_context;
@@ -1083,178 +1049,176 @@ struct dat_provider_attr {
  *
  ****************************************************************/
 
-typedef u32 (*DAT_IA_OPEN_FUNC)(const char *, int, DAT_EVD_HANDLE *,
-				DAT_IA_HANDLE *);
+typedef u32 (*DAT_IA_OPEN_FUNC)(const char *, int, struct dat_evd **,
+				struct dat_ia **);
 
-typedef u32 (*DAT_IA_OPENV_FUNC)(const char *, int, DAT_EVD_HANDLE *,
-				 DAT_IA_HANDLE *, u32, u32, boolean_t);
+typedef u32 (*DAT_IA_OPENV_FUNC)(const char *, int, struct dat_evd **,
+				 struct dat_ia **, u32, u32, boolean_t);
 
-typedef u32 (*DAT_IA_CLOSE_FUNC)(DAT_IA_HANDLE, enum dat_close_flags);
+typedef u32 (*DAT_IA_CLOSE_FUNC)(struct dat_ia *, enum dat_close_flags);
 
-typedef u32 (*DAT_IA_QUERY_FUNC)(DAT_IA_HANDLE, DAT_EVD_HANDLE *,
+typedef u32 (*DAT_IA_QUERY_FUNC)(struct dat_ia *, struct dat_evd **,
 				 struct dat_ia_attr *,
 				 struct dat_provider_attr *);
 
-typedef u32 (*DAT_SET_CONSUMER_CONTEXT_FUNC)(DAT_HANDLE, union dat_context);
-
-typedef u32 (*DAT_GET_CONSUMER_CONTEXT_FUNC)(DAT_HANDLE, union dat_context *);
+typedef u32 (*DAT_SET_CONSUMER_CONTEXT_FUNC)(void *, union dat_context);
 
-typedef u32 (*DAT_GET_HANDLE_TYPE_FUNC)(DAT_HANDLE, enum dat_handle_type *);
+typedef u32 (*DAT_GET_CONSUMER_CONTEXT_FUNC)(void *, union dat_context *);
 
-typedef u32 (*DAT_CR_QUERY_FUNC)(DAT_CR_HANDLE, struct dat_cr_param *);
+typedef u32 (*DAT_CR_QUERY_FUNC)(struct dat_cr *, struct dat_cr_param *);
 
-typedef u32 (*DAT_CR_ACCEPT_FUNC)(DAT_CR_HANDLE, DAT_EP_HANDLE, int,
+typedef u32 (*DAT_CR_ACCEPT_FUNC)(struct dat_cr *, struct dat_ep *, int,
 				  const void*);
 
-typedef u32 (*DAT_CR_REJECT_FUNC)(DAT_CR_HANDLE);
+typedef u32 (*DAT_CR_REJECT_FUNC)(struct dat_cr *);
 
-typedef u32 (*DAT_CR_HANDOFF_FUNC)(DAT_CR_HANDLE, DAT_CONN_QUAL);
+typedef u32 (*DAT_CR_HANDOFF_FUNC)(struct dat_cr *, DAT_CONN_QUAL);
 
-typedef u32 (*DAT_EVD_RESIZE_FUNC)(DAT_EVD_HANDLE, int);
+typedef u32 (*DAT_EVD_RESIZE_FUNC)(struct dat_evd *, int);
 
-typedef u32 (*DAT_EVD_POST_SE_FUNC)(DAT_EVD_HANDLE, const struct dat_event *);
+typedef u32 (*DAT_EVD_POST_SE_FUNC)(struct dat_evd *, const struct dat_event *);
 
-typedef u32 (*DAT_EVD_DEQUEUE_FUNC)(DAT_EVD_HANDLE, struct dat_event *);
+typedef u32 (*DAT_EVD_DEQUEUE_FUNC)(struct dat_evd *, struct dat_event *);
 
-typedef u32 (*DAT_EVD_FREE_FUNC)(DAT_EVD_HANDLE);
+typedef u32 (*DAT_EVD_FREE_FUNC)(struct dat_evd *);
 
-typedef u32 (*DAT_EVD_QUERY_FUNC)(DAT_EVD_HANDLE, struct dat_evd_param *);
+typedef u32 (*DAT_EVD_QUERY_FUNC)(struct dat_evd *, struct dat_evd_param *);
 
-typedef u32 (*DAT_EP_CREATE_FUNC)(DAT_IA_HANDLE, DAT_PZ_HANDLE, DAT_EVD_HANDLE,
-				  DAT_EVD_HANDLE, DAT_EVD_HANDLE,
-				  const struct dat_ep_attr *, DAT_EP_HANDLE *);
+typedef u32 (*DAT_EP_CREATE_FUNC)(struct dat_ia *, struct dat_pz *, struct dat_evd *,
+				  struct dat_evd *, struct dat_evd *,
+				  const struct dat_ep_attr *, struct dat_ep **);
 
-typedef u32 (*DAT_EP_CREATE_WITH_SRQ_FUNC)(DAT_IA_HANDLE, DAT_PZ_HANDLE,
-					   DAT_EVD_HANDLE, DAT_EVD_HANDLE,
-					   DAT_EVD_HANDLE, DAT_SRQ_HANDLE,
+typedef u32 (*DAT_EP_CREATE_WITH_SRQ_FUNC)(struct dat_ia *, struct dat_pz *,
+					   struct dat_evd *, struct dat_evd *,
+					   struct dat_evd *, struct dat_srq *,
 					   const struct dat_ep_attr *,
-					   DAT_EP_HANDLE *);
+					   struct dat_ep **);
 
-typedef u32 (*DAT_EP_QUERY_FUNC)(DAT_EP_HANDLE, struct dat_ep_param *);
+typedef u32 (*DAT_EP_QUERY_FUNC)(struct dat_ep *, struct dat_ep_param *);
 
-typedef u32 (*DAT_EP_MODIFY_FUNC)(DAT_EP_HANDLE, enum dat_ep_param_mask,
+typedef u32 (*DAT_EP_MODIFY_FUNC)(struct dat_ep *, enum dat_ep_param_mask,
 				  const struct dat_ep_param *);
 
-typedef u32 (*DAT_EP_CONNECT_FUNC)(DAT_EP_HANDLE, struct sockaddr *,
+typedef u32 (*DAT_EP_CONNECT_FUNC)(struct dat_ep *, struct sockaddr *,
 				   DAT_CONN_QUAL, unsigned long timeout, int,
 				   const void *, enum dat_qos,
 				   enum dat_connect_flags);
 
-typedef u32 (*DAT_EP_DUP_CONNECT_FUNC)(DAT_EP_HANDLE, DAT_EP_HANDLE,
+typedef u32 (*DAT_EP_DUP_CONNECT_FUNC)(struct dat_ep *, struct dat_ep *,
 				       unsigned long timeout, int, const void *,
 				       enum dat_qos);
 
-typedef u32 (*DAT_EP_DISCONNECT_FUNC)(DAT_EP_HANDLE, enum dat_close_flags);
+typedef u32 (*DAT_EP_DISCONNECT_FUNC)(struct dat_ep *, enum dat_close_flags);
 
-typedef u32 (*DAT_EP_POST_SEND_FUNC)(DAT_EP_HANDLE, int,
+typedef u32 (*DAT_EP_POST_SEND_FUNC)(struct dat_ep *, int,
 				     struct dat_lmr_triplet *, DAT_DTO_COOKIE,
 				     enum dat_completion_flags);
 
-typedef u32 (*DAT_EP_POST_RECV_FUNC)(DAT_EP_HANDLE, int,
+typedef u32 (*DAT_EP_POST_RECV_FUNC)(struct dat_ep *, int,
 				     struct dat_lmr_triplet *, DAT_DTO_COOKIE,
 				     enum dat_completion_flags);
 
-typedef u32 (*DAT_EP_POST_RDMA_READ_FUNC)(DAT_EP_HANDLE, int,
+typedef u32 (*DAT_EP_POST_RDMA_READ_FUNC)(struct dat_ep *, int,
 					  struct dat_lmr_triplet *,
 					  DAT_DTO_COOKIE,
 					  const struct dat_rmr_triplet *,
 					  enum dat_completion_flags);
 
-typedef u32 (*DAT_EP_POST_RDMA_WRITE_FUNC)(DAT_EP_HANDLE, int,
+typedef u32 (*DAT_EP_POST_RDMA_WRITE_FUNC)(struct dat_ep *, int,
 					   struct dat_lmr_triplet *,
 					   DAT_DTO_COOKIE,
 					   const struct dat_rmr_triplet *,
 					   enum dat_completion_flags);
 
-typedef u32 (*DAT_EP_GET_STATUS_FUNC)(DAT_EP_HANDLE, enum dat_ep_state *,
+typedef u32 (*DAT_EP_GET_STATUS_FUNC)(struct dat_ep *, enum dat_ep_state *,
 				      boolean_t *, boolean_t *);
 
-typedef u32 (*DAT_EP_FREE_FUNC)(DAT_EP_HANDLE);
+typedef u32 (*DAT_EP_FREE_FUNC)(struct dat_ep *);
 
-typedef u32 (*DAT_EP_RESET_FUNC)(DAT_EP_HANDLE);
+typedef u32 (*DAT_EP_RESET_FUNC)(struct dat_ep *);
 
-typedef u32 (*DAT_EP_RECV_QUERY_FUNC)(DAT_EP_HANDLE, int *, int *);
+typedef u32 (*DAT_EP_RECV_QUERY_FUNC)(struct dat_ep *, int *, int *);
 
-typedef u32 (*DAT_EP_SET_WATERMARK_FUNC)(DAT_EP_HANDLE, int, int);
+typedef u32 (*DAT_EP_SET_WATERMARK_FUNC)(struct dat_ep *, int, int);
 
-typedef u32 (*DAT_LMR_FREE_FUNC)(DAT_LMR_HANDLE);
+typedef u32 (*DAT_LMR_FREE_FUNC)(struct dat_lmr *);
 
-typedef u32 (*DAT_LMR_QUERY_FUNC)(DAT_LMR_HANDLE, struct dat_lmr_param *);
+typedef u32 (*DAT_LMR_QUERY_FUNC)(struct dat_lmr *, struct dat_lmr_param *);
 
-typedef u32 (*DAT_LMR_SYNC_RDMA_READ_FUNC)(DAT_IA_HANDLE,
+typedef u32 (*DAT_LMR_SYNC_RDMA_READ_FUNC)(struct dat_ia *,
 					   const struct dat_lmr_triplet *,
 					   u64);
 
-typedef u32 (*DAT_LMR_SYNC_RDMA_WRITE_FUNC)(DAT_IA_HANDLE,
+typedef u32 (*DAT_LMR_SYNC_RDMA_WRITE_FUNC)(struct dat_ia *,
 					    const struct dat_lmr_triplet *,
 					    u64);
 
-typedef u32 (*DAT_RMR_CREATE_FUNC)(DAT_PZ_HANDLE, DAT_RMR_HANDLE *);
+typedef u32 (*DAT_RMR_CREATE_FUNC)(struct dat_pz *, struct dat_rmr * *);
 
-typedef u32 (*DAT_RMR_QUERY_FUNC)(DAT_RMR_HANDLE, struct dat_rmr_param *);
+typedef u32 (*DAT_RMR_QUERY_FUNC)(struct dat_rmr *, struct dat_rmr_param *);
 
-typedef u32 (*DAT_RMR_BIND_FUNC)(DAT_RMR_HANDLE, const struct dat_lmr_triplet *,
-				 enum dat_mem_priv_flags, DAT_EP_HANDLE,
+typedef u32 (*DAT_RMR_BIND_FUNC)(struct dat_rmr *, const struct dat_lmr_triplet *,
+				 enum dat_mem_priv_flags, struct dat_ep *,
 				 DAT_RMR_COOKIE, enum dat_completion_flags,
 				 DAT_RMR_CONTEXT *);
 
-typedef u32 (*DAT_RMR_FREE_FUNC)(DAT_RMR_HANDLE);
+typedef u32 (*DAT_RMR_FREE_FUNC)(struct dat_rmr *);
 
-typedef u32 (*DAT_PSP_CREATE_FUNC)(DAT_IA_HANDLE, DAT_CONN_QUAL, DAT_EVD_HANDLE,
-				   enum dat_psp_flags, DAT_PSP_HANDLE *);
+typedef u32 (*DAT_PSP_CREATE_FUNC)(struct dat_ia *, DAT_CONN_QUAL, struct dat_evd *,
+				   enum dat_psp_flags, struct dat_sp **);
 
-typedef u32 (*DAT_PSP_CREATE_ANY_FUNC)(DAT_IA_HANDLE, DAT_CONN_QUAL *,
-				       DAT_EVD_HANDLE, enum dat_psp_flags,
-				       DAT_PSP_HANDLE *);
+typedef u32 (*DAT_PSP_CREATE_ANY_FUNC)(struct dat_ia *, DAT_CONN_QUAL *,
+				       struct dat_evd *, enum dat_psp_flags,
+				       struct dat_sp **);
 
-typedef u32 (*DAT_PSP_QUERY_FUNC)(DAT_PSP_HANDLE, struct dat_psp_param *);
+typedef u32 (*DAT_PSP_QUERY_FUNC)(struct dat_sp *, struct dat_psp_param *);
 
-typedef u32 (*DAT_PSP_FREE_FUNC)(DAT_PSP_HANDLE);
+typedef u32 (*DAT_PSP_FREE_FUNC)(struct dat_sp *);
 
-typedef u32 (*DAT_RSP_CREATE_FUNC)(DAT_IA_HANDLE, DAT_CONN_QUAL, DAT_EP_HANDLE,
-				   DAT_EVD_HANDLE, DAT_RSP_HANDLE *);
+typedef u32 (*DAT_RSP_CREATE_FUNC)(struct dat_ia *, DAT_CONN_QUAL, struct dat_ep *,
+				   struct dat_evd *, struct dat_sp **);
 
-typedef u32 (*DAT_RSP_QUERY_FUNC)(DAT_RSP_HANDLE, struct dat_rsp_param *);
+typedef u32 (*DAT_RSP_QUERY_FUNC)(struct dat_sp *, struct dat_rsp_param *);
 
-typedef u32 (*DAT_RSP_FREE_FUNC)(DAT_RSP_HANDLE);
+typedef u32 (*DAT_RSP_FREE_FUNC)(struct dat_sp *);
 
-typedef u32 (*DAT_PZ_CREATE_FUNC)(DAT_IA_HANDLE, DAT_PZ_HANDLE *);
+typedef u32 (*DAT_PZ_CREATE_FUNC)(struct dat_ia *, struct dat_pz **);
 
-typedef u32 (*DAT_PZ_QUERY_FUNC)(DAT_PZ_HANDLE, struct dat_pz_param *);
+typedef u32 (*DAT_PZ_QUERY_FUNC)(struct dat_pz *, struct dat_pz_param *);
 
-typedef u32 (*DAT_PZ_FREE_FUNC)(DAT_PZ_HANDLE);
+typedef u32 (*DAT_PZ_FREE_FUNC)(struct dat_pz *);
 
-typedef u32 (*DAT_SRQ_CREATE_FUNC)(DAT_IA_HANDLE, DAT_PZ_HANDLE,
-				   struct dat_srq_attr *, DAT_SRQ_HANDLE *);
+typedef u32 (*DAT_SRQ_CREATE_FUNC)(struct dat_ia *, struct dat_pz *,
+				   struct dat_srq_attr *, struct dat_srq **);
 
-typedef u32 (*DAT_SRQ_SET_LW_FUNC)(DAT_SRQ_HANDLE, int);
+typedef u32 (*DAT_SRQ_SET_LW_FUNC)(struct dat_srq *, int);
 
-typedef u32 (*DAT_SRQ_FREE_FUNC)(DAT_SRQ_HANDLE);
+typedef u32 (*DAT_SRQ_FREE_FUNC)(struct dat_srq *);
 
-typedef u32 (*DAT_SRQ_QUERY_FUNC)(DAT_SRQ_HANDLE, struct dat_srq_param *);
+typedef u32 (*DAT_SRQ_QUERY_FUNC)(struct dat_srq *, struct dat_srq_param *);
 
-typedef u32 (*DAT_SRQ_RESIZE_FUNC)(DAT_SRQ_HANDLE, int);
+typedef u32 (*DAT_SRQ_RESIZE_FUNC)(struct dat_srq *, int);
 
-typedef u32 (*DAT_SRQ_POST_RECV_FUNC)(DAT_SRQ_HANDLE, int,
+typedef u32 (*DAT_SRQ_POST_RECV_FUNC)(struct dat_srq *, int,
 				      struct dat_lmr_triplet *, DAT_DTO_COOKIE);
 
-typedef u32 (*DAT_LMR_KCREATE_FUNC)(DAT_IA_HANDLE, enum dat_mem_type,
+typedef u32 (*DAT_LMR_KCREATE_FUNC)(struct dat_ia *, enum dat_mem_type,
 				    DAT_REGION_DESCRIPTION, u64,
-				    DAT_PZ_HANDLE, enum dat_mem_priv_flags,
+				    struct dat_pz *, enum dat_mem_priv_flags,
 				    enum dat_mem_optimize_flags,
-				    DAT_LMR_HANDLE *,
+				    struct dat_lmr **,
 				    DAT_LMR_CONTEXT *, DAT_RMR_CONTEXT *,
 				    u64 *, u64 *);
 
-typedef u32 (*DAT_IA_MEMTYPE_HINT_FUNC)(DAT_IA_HANDLE, enum dat_mem_type, u64,
+typedef u32 (*DAT_IA_MEMTYPE_HINT_FUNC)(struct dat_ia *, enum dat_mem_type, u64,
 					enum dat_mem_optimize_flags, u64 *,
 					u64 *);
 
-typedef u32 (*DAT_EVD_KCREATE_FUNC) (DAT_IA_HANDLE, int, enum dat_upcall_policy,
+typedef u32 (*DAT_EVD_KCREATE_FUNC) (struct dat_ia *, int, enum dat_upcall_policy,
 				     const struct dat_upcall_object *,
-				     enum dat_evd_flags, DAT_EVD_HANDLE *);
+				     enum dat_evd_flags, struct dat_evd **);
 
-typedef u32 (*DAT_EVD_MODIFY_UPCALL_FUNC)(DAT_EVD_HANDLE,
+typedef u32 (*DAT_EVD_MODIFY_UPCALL_FUNC)(struct dat_evd *,
 					  enum dat_upcall_policy,
 					  const struct dat_upcall_object *);
 
@@ -1269,7 +1233,6 @@ struct dat_provider {
         
         DAT_SET_CONSUMER_CONTEXT_FUNC       set_consumer_context_func;
         DAT_GET_CONSUMER_CONTEXT_FUNC       get_consumer_context_func;
-        DAT_GET_HANDLE_TYPE_FUNC            get_handle_type_func;
 
         DAT_CR_QUERY_FUNC                   cr_query_func;
         DAT_CR_ACCEPT_FUNC                  cr_accept_func;
@@ -1338,6 +1301,52 @@ struct dat_provider {
         DAT_SRQ_SET_LW_FUNC                 srq_set_lw_func;
 };
 
+struct dat_ep {
+	struct dat_provider *provider;
+};
+
+struct dat_ia {
+	struct dat_provider *provider;
+};
+
+struct dat_evd {
+	struct dat_provider *provider;
+};
+
+struct dat_cno {
+	struct dat_provider *provider;
+};
+
+struct dat_srq {
+	struct dat_provider *provider;
+};
+
+struct dat_pz {
+	struct dat_provider *provider;
+};
+
+struct dat_lmr {
+	struct dat_provider *provider;
+};
+
+struct dat_rmr {
+	struct dat_provider *provider;
+};
+
+enum dat_sp_type {
+	DAT_SP_TYPE_RSP,
+	DAT_SP_TYPE_PSP
+};
+
+struct dat_sp {
+	struct dat_provider *provider;
+	enum dat_sp_type type;
+};
+
+struct dat_cr {
+	struct dat_provider *provider;
+};
+
 /***************************************************************
  *
  * FUNCTION PROTOTYPES
@@ -1359,8 +1368,8 @@ extern u32 dat_registry_remove_provider(
  * DAT registry functions for consumers
  */
 extern u32 dat_ia_openv(const char *name, int async_event_qlen,
-			DAT_EVD_HANDLE *async_event_handle,
-			DAT_IA_HANDLE *ia_handle, u32 dat_major, u32 dat_minor,
+			struct dat_evd **async_event_handle,
+			struct dat_ia **ia, u32 dat_major, u32 dat_minor,
 			boolean_t thread_safety);
 
 #define dat_ia_open(name, qlen, async_evd, ia) \
@@ -1368,7 +1377,7 @@ extern u32 dat_ia_openv(const char *name
                 DAT_VERSION_MAJOR, DAT_VERSION_MINOR, \
                 DAT_THREADSAFE)
 
-extern u32 dat_ia_close(DAT_IA_HANDLE, enum dat_close_flags);
+extern u32 dat_ia_close(struct dat_ia *, enum dat_close_flags);
 
 extern u32 dat_strerror(u32, const char **, const char **);
 
@@ -1383,27 +1392,21 @@ extern u32 dat_registry_list_providers(i
 #define DAT_CALL_PROVIDER_FUNC(func, handle, ...) \
         DAT_HANDLE_TO_PROVIDER(handle)->func(handle, ##__VA_ARGS__)
 
-static inline u32 dat_set_consumer_context(DAT_HANDLE handle,
+static inline u32 dat_set_consumer_context(void *handle,
 					   union dat_context context) 
 {
         return DAT_CALL_PROVIDER_FUNC(set_consumer_context_func, handle,
 				      context);
 }
 
-static inline u32 dat_get_consumer_context(DAT_HANDLE handle,
+static inline u32 dat_get_consumer_context(void *handle,
 					   union dat_context *context)
 {
         return DAT_CALL_PROVIDER_FUNC(get_consumer_context_func, handle,
 				      context);
 }
 
-static inline u32 dat_get_handle_type(DAT_HANDLE handle,
-				      enum dat_handle_type *type)
-{
-        return DAT_CALL_PROVIDER_FUNC(get_handle_type_func, handle, type);
-}
-
-static inline u32 dat_ia_memtype_hint(DAT_IA_HANDLE ia,
+static inline u32 dat_ia_memtype_hint(struct dat_ia *ia,
 				      enum dat_mem_type mem_type,
 				      u64 length,
 				      enum dat_mem_optimize_flags mem_optimize,
@@ -1415,7 +1418,7 @@ static inline u32 dat_ia_memtype_hint(DA
 				      preferred_alignment);
 }
 
-static inline u32 dat_ia_query(DAT_IA_HANDLE ia, DAT_EVD_HANDLE *async_evd,
+static inline u32 dat_ia_query(struct dat_ia *ia, struct dat_evd **async_evd,
 			       struct dat_ia_attr *ia_attr,
 			       struct dat_provider_attr *provider_attr)
 {
@@ -1423,49 +1426,49 @@ static inline u32 dat_ia_query(DAT_IA_HA
                 ia_query_func, ia, async_evd, ia_attr, provider_attr);
 }
 
-static inline u32 dat_cr_accept(DAT_CR_HANDLE cr, DAT_EP_HANDLE ep,
+static inline u32 dat_cr_accept(struct dat_cr *cr, struct dat_ep *ep,
 				int private_data_size, const void *private_data)
 {
         return DAT_CALL_PROVIDER_FUNC(
                 cr_accept_func, cr, ep, private_data_size, private_data);
 }
 
-static inline u32 dat_cr_handoff(DAT_CR_HANDLE cr, DAT_CONN_QUAL handoff)
+static inline u32 dat_cr_handoff(struct dat_cr *cr, DAT_CONN_QUAL handoff)
 {
 	return DAT_CALL_PROVIDER_FUNC(cr_handoff_func, cr, handoff);
 }
 
-static inline u32 dat_cr_query(DAT_CR_HANDLE cr, struct dat_cr_param *param)
+static inline u32 dat_cr_query(struct dat_cr *cr, struct dat_cr_param *param)
 {
         return DAT_CALL_PROVIDER_FUNC(cr_query_func, cr, param);
 }
 
-static inline u32 dat_cr_reject(DAT_CR_HANDLE cr) 
+static inline u32 dat_cr_reject(struct dat_cr *cr) 
 {
         return DAT_CALL_PROVIDER_FUNC(cr_reject_func, cr);
 }
 
-static inline u32 dat_evd_dequeue(DAT_EVD_HANDLE evd, struct dat_event *event)
+static inline u32 dat_evd_dequeue(struct dat_evd *evd, struct dat_event *event)
 {
         return DAT_CALL_PROVIDER_FUNC(evd_dequeue_func, evd, event);
 }
 
-static inline u32 dat_evd_free(DAT_EVD_HANDLE evd)
+static inline u32 dat_evd_free(struct dat_evd *evd)
 {
         return DAT_CALL_PROVIDER_FUNC(evd_free_func, evd);
 }
 
-static inline u32 dat_evd_kcreate(DAT_IA_HANDLE ia, int qlen,
+static inline u32 dat_evd_kcreate(struct dat_ia *ia, int qlen,
 				  enum dat_upcall_policy policy,
 				  const struct dat_upcall_object *upcall,
 				  enum dat_evd_flags flags,
-				  DAT_EVD_HANDLE * evd)
+				  struct dat_evd ** evd)
 {
         return DAT_CALL_PROVIDER_FUNC(evd_kcreate_func, ia, qlen, policy,
 				      upcall, flags, evd);
 }
 
-static inline u32 dat_evd_modify_upcall(DAT_EVD_HANDLE evd,
+static inline u32 dat_evd_modify_upcall(struct dat_evd *evd,
 					enum dat_upcall_policy policy,
 					const struct dat_upcall_object *upcall)
 {
@@ -1473,23 +1476,23 @@ static inline u32 dat_evd_modify_upcall(
 				      upcall);
 }
 
-static inline u32 dat_evd_post_se(DAT_EVD_HANDLE evd,
+static inline u32 dat_evd_post_se(struct dat_evd *evd,
 				  const struct dat_event *event)
 {
         return DAT_CALL_PROVIDER_FUNC(evd_post_se_func, evd, event);
 }
 
-static inline u32 dat_evd_query(DAT_EVD_HANDLE evd, struct dat_evd_param *param)
+static inline u32 dat_evd_query(struct dat_evd *evd, struct dat_evd_param *param)
 {
         return DAT_CALL_PROVIDER_FUNC(evd_query_func, evd, param);
 }
 
-static inline u32 dat_evd_resize(DAT_EVD_HANDLE evd, int qlen)
+static inline u32 dat_evd_resize(struct dat_evd *evd, int qlen)
 {
         return DAT_CALL_PROVIDER_FUNC(evd_resize_func, evd, qlen);
 }
 
-static inline u32 dat_ep_connect(DAT_EP_HANDLE ep, struct sockaddr *ia_addr,
+static inline u32 dat_ep_connect(struct dat_ep *ep, struct sockaddr *ia_addr,
 				 DAT_CONN_QUAL conn_qual, unsigned long timeout,
 				 int private_data_size,
 				 const void *private_data, enum dat_qos qos,
@@ -1500,36 +1503,36 @@ static inline u32 dat_ep_connect(DAT_EP_
 				      qos, flags);
 }
 
-static inline u32 dat_ep_create(DAT_IA_HANDLE ia, DAT_PZ_HANDLE pz,
-				DAT_EVD_HANDLE in_evd, DAT_EVD_HANDLE out_evd,
-				DAT_EVD_HANDLE connect_evd,
+static inline u32 dat_ep_create(struct dat_ia *ia, struct dat_pz *pz,
+				struct dat_evd *in_evd, struct dat_evd *out_evd,
+				struct dat_evd *connect_evd,
 				const struct dat_ep_attr *attr,
-				DAT_EP_HANDLE *ep)
+				struct dat_ep **ep)
 {
         return DAT_CALL_PROVIDER_FUNC(ep_create_func, ia, pz, in_evd, out_evd,
 				      connect_evd, attr, ep);
 }
 
 
-static inline u32 dat_ep_create_with_srq(DAT_IA_HANDLE ia, DAT_PZ_HANDLE pz,
-					 DAT_EVD_HANDLE in_evd,
-					 DAT_EVD_HANDLE out_evd,
-					 DAT_EVD_HANDLE connect_evd,
-					 DAT_SRQ_HANDLE srq,
+static inline u32 dat_ep_create_with_srq(struct dat_ia *ia, struct dat_pz *pz,
+					 struct dat_evd *in_evd,
+					 struct dat_evd *out_evd,
+					 struct dat_evd *connect_evd,
+					 struct dat_srq *srq,
 					 const struct dat_ep_attr *attr,
-					 DAT_EP_HANDLE *ep)
+					 struct dat_ep **ep)
 {
         return DAT_CALL_PROVIDER_FUNC(ep_create_with_srq_func, ia, pz, in_evd, 
                                       out_evd, connect_evd, srq, attr, ep);
 }
 
-static inline u32 dat_ep_disconnect(DAT_EP_HANDLE ep,
+static inline u32 dat_ep_disconnect(struct dat_ep *ep,
 				    enum dat_close_flags flags)
 {
         return DAT_CALL_PROVIDER_FUNC(ep_disconnect_func, ep, flags);
 }
 
-static inline u32 dat_ep_dup_connect(DAT_EP_HANDLE ep, DAT_EP_HANDLE dup_ep,
+static inline u32 dat_ep_dup_connect(struct dat_ep *ep, struct dat_ep *dup_ep,
 				     unsigned long timeout,
 				     int private_data_size,
 				     const void *private_data, enum dat_qos qos)
@@ -1538,25 +1541,25 @@ static inline u32 dat_ep_dup_connect(DAT
                                       private_data_size, private_data, qos);
 }
 
-static inline u32 dat_ep_free(DAT_EP_HANDLE ep)
+static inline u32 dat_ep_free(struct dat_ep *ep)
 {
         return DAT_CALL_PROVIDER_FUNC(ep_free_func, ep);
 }
 
-static inline u32 dat_ep_get_status(DAT_EP_HANDLE ep, enum dat_ep_state *state,
+static inline u32 dat_ep_get_status(struct dat_ep *ep, enum dat_ep_state *state,
 				    boolean_t *recv_idle, boolean_t *req_idle)
 {
         return DAT_CALL_PROVIDER_FUNC(ep_get_status_func, ep, state, recv_idle,
 				      req_idle);
 }
 
-static inline u32 dat_ep_modify(DAT_EP_HANDLE ep, enum dat_ep_param_mask mask,
+static inline u32 dat_ep_modify(struct dat_ep *ep, enum dat_ep_param_mask mask,
 				const struct dat_ep_param *param)
 {
         return DAT_CALL_PROVIDER_FUNC(ep_modify_func, ep, mask, param);
 }
 
-static inline u32 dat_ep_post_rdma_read(DAT_EP_HANDLE ep, int size,
+static inline u32 dat_ep_post_rdma_read(struct dat_ep *ep, int size,
 					struct dat_lmr_triplet *local_iov,
 					DAT_DTO_COOKIE cookie,
 					const struct dat_rmr_triplet *remote_iov,
@@ -1566,7 +1569,7 @@ static inline u32 dat_ep_post_rdma_read(
                                       local_iov, cookie, remote_iov, flags);
 }
 
-static inline u32 dat_ep_post_rdma_write(DAT_EP_HANDLE ep, int size,
+static inline u32 dat_ep_post_rdma_write(struct dat_ep *ep, int size,
 					 struct dat_lmr_triplet *local_iov,
 					 DAT_DTO_COOKIE cookie,
 					 const struct dat_rmr_triplet *remote_iov,
@@ -1576,7 +1579,7 @@ static inline u32 dat_ep_post_rdma_write
                                       local_iov, cookie, remote_iov, flags);
 }
 
-static inline u32 dat_ep_post_recv(DAT_EP_HANDLE ep, int size,
+static inline u32 dat_ep_post_recv(struct dat_ep *ep, int size,
 				   struct dat_lmr_triplet *local_iov,
 				   DAT_DTO_COOKIE cookie,
 				   enum dat_completion_flags flags)
@@ -1585,7 +1588,7 @@ static inline u32 dat_ep_post_recv(DAT_E
 				      cookie, flags);
 }
 
-static inline u32 dat_ep_post_send(DAT_EP_HANDLE ep, 
+static inline u32 dat_ep_post_send(struct dat_ep *ep, 
                                           int size, 
                                           struct dat_lmr_triplet *local_iov,
                                           DAT_DTO_COOKIE cookie, 
@@ -1595,24 +1598,24 @@ static inline u32 dat_ep_post_send(DAT_E
                 ep_post_send_func, ep, size, local_iov, cookie, flags);
 }
 
-static inline u32 dat_ep_query(DAT_EP_HANDLE ep, struct dat_ep_param *param)
+static inline u32 dat_ep_query(struct dat_ep *ep, struct dat_ep_param *param)
 {
         return DAT_CALL_PROVIDER_FUNC(ep_query_func, ep, param);
 }
 
-static inline u32 dat_ep_recv_query(DAT_EP_HANDLE ep, int *bufs_alloc,
+static inline u32 dat_ep_recv_query(struct dat_ep *ep, int *bufs_alloc,
 				    int *bufs_avail)
 {
         return DAT_CALL_PROVIDER_FUNC(ep_recv_query_func, ep, bufs_alloc,
 				      bufs_avail);
 }
 
-static inline u32 dat_ep_reset(DAT_EP_HANDLE ep)
+static inline u32 dat_ep_reset(struct dat_ep *ep)
 {
         return DAT_CALL_PROVIDER_FUNC(ep_reset_func, ep);
 }
 
-static inline u32 dat_ep_set_watermark(DAT_EP_HANDLE ep,
+static inline u32 dat_ep_set_watermark(struct dat_ep *ep,
 				       int soft_high_watermark,
 				       int hard_high_watermark)
 {
@@ -1620,17 +1623,17 @@ static inline u32 dat_ep_set_watermark(D
                                       soft_high_watermark, hard_high_watermark);
 }
 
-static inline u32 dat_lmr_query(DAT_LMR_HANDLE lmr, struct dat_lmr_param *param)
+static inline u32 dat_lmr_query(struct dat_lmr *lmr, struct dat_lmr_param *param)
 {
         return DAT_CALL_PROVIDER_FUNC(lmr_query_func, lmr, param);
 }
 
-static inline u32 dat_lmr_free(DAT_LMR_HANDLE lmr) 
+static inline u32 dat_lmr_free(struct dat_lmr *lmr) 
 {
         return DAT_CALL_PROVIDER_FUNC(lmr_free_func, lmr);
 }
 
-static inline u32 dat_lmr_sync_rdma_read(DAT_IA_HANDLE ia,
+static inline u32 dat_lmr_sync_rdma_read(struct dat_ia *ia,
 					 const struct dat_lmr_triplet *iovs,
 					 u64 num_iovs)
 {
@@ -1638,7 +1641,7 @@ static inline u32 dat_lmr_sync_rdma_read
 				      num_iovs);
 }
 
-static inline u32 dat_lmr_sync_rdma_write(DAT_IA_HANDLE ia,
+static inline u32 dat_lmr_sync_rdma_write(struct dat_ia *ia,
 					  const struct dat_lmr_triplet *iovs,
 					  u64 num_iovs)
 {
@@ -1646,20 +1649,20 @@ static inline u32 dat_lmr_sync_rdma_writ
 				      num_iovs);
 }
 
-static inline u32 dat_rmr_create(DAT_PZ_HANDLE pz, DAT_RMR_HANDLE *rmr)
+static inline u32 dat_rmr_create(struct dat_pz *pz, struct dat_rmr * *rmr)
 {
         return DAT_CALL_PROVIDER_FUNC(rmr_create_func, pz, rmr);
 }
 
-static inline u32 dat_rmr_query(DAT_RMR_HANDLE rmr, struct dat_rmr_param *param)
+static inline u32 dat_rmr_query(struct dat_rmr * rmr, struct dat_rmr_param *param)
 {
         return DAT_CALL_PROVIDER_FUNC(rmr_query_func, rmr, param);
 }
 
-static inline u32 dat_rmr_bind(DAT_RMR_HANDLE rmr,
+static inline u32 dat_rmr_bind(struct dat_rmr * rmr,
 			       const struct dat_lmr_triplet *iov,
 			       enum dat_mem_priv_flags mem_flags,
-			       DAT_EP_HANDLE ep, DAT_RMR_COOKIE cookie,
+			       struct dat_ep *ep, DAT_RMR_COOKIE cookie,
 			       enum dat_completion_flags comp_flags,
 			       DAT_RMR_CONTEXT *context)
 {
@@ -1667,84 +1670,84 @@ static inline u32 dat_rmr_bind(DAT_RMR_H
                                       cookie, comp_flags, context);
 }
 
-static inline u32 dat_rmr_free(DAT_RMR_HANDLE rmr)
+static inline u32 dat_rmr_free(struct dat_rmr * rmr)
 {
         return DAT_CALL_PROVIDER_FUNC(rmr_free_func, rmr);
 }
 
-static inline u32 dat_psp_create(DAT_IA_HANDLE ia, DAT_CONN_QUAL conn_qual,
-				 DAT_EVD_HANDLE evd, enum dat_psp_flags flags,
-				 DAT_PSP_HANDLE *psp)
+static inline u32 dat_psp_create(struct dat_ia *ia, DAT_CONN_QUAL conn_qual,
+				 struct dat_evd *evd, enum dat_psp_flags flags,
+				 struct dat_sp **psp)
 {
         return DAT_CALL_PROVIDER_FUNC(psp_create_func, ia, conn_qual, evd,
 				      flags, psp);
 }
 
-static inline u32 dat_psp_create_any(DAT_IA_HANDLE ia, DAT_CONN_QUAL *conn_qual,
-				     DAT_EVD_HANDLE evd,
+static inline u32 dat_psp_create_any(struct dat_ia *ia, DAT_CONN_QUAL *conn_qual,
+				     struct dat_evd *evd,
 				     enum dat_psp_flags flags,
-				     DAT_PSP_HANDLE *psp)
+				     struct dat_sp **psp)
 {
         return DAT_CALL_PROVIDER_FUNC(psp_create_any_func, ia, conn_qual, evd,
 				      flags, psp);
 }
 
-static inline u32 dat_psp_query(DAT_PSP_HANDLE psp, struct dat_psp_param *param)
+static inline u32 dat_psp_query(struct dat_sp *psp, struct dat_psp_param *param)
 {
         return DAT_CALL_PROVIDER_FUNC(psp_query_func, psp, param);
 }
 
-static inline u32 dat_psp_free(DAT_PSP_HANDLE psp)
+static inline u32 dat_psp_free(struct dat_sp *psp)
 {
         return DAT_CALL_PROVIDER_FUNC(psp_free_func, psp);
 }
 
-static inline u32 dat_rsp_create(DAT_IA_HANDLE ia, DAT_CONN_QUAL conn_qual,
-				 DAT_EP_HANDLE ep, DAT_EVD_HANDLE evd,
-				 DAT_RSP_HANDLE *rsp)
+static inline u32 dat_rsp_create(struct dat_ia *ia, DAT_CONN_QUAL conn_qual,
+				 struct dat_ep *ep, struct dat_evd *evd,
+				 struct dat_sp **rsp)
 {
         return DAT_CALL_PROVIDER_FUNC(rsp_create_func, ia, conn_qual, ep, evd,
 				      rsp);
 }
 
-static inline u32 dat_rsp_query(DAT_RSP_HANDLE rsp, struct dat_rsp_param *param)
+static inline u32 dat_rsp_query(struct dat_sp *rsp, struct dat_rsp_param *param)
 {
         return DAT_CALL_PROVIDER_FUNC(rsp_query_func, rsp, param);
 }
 
-static inline u32 dat_rsp_free(DAT_RSP_HANDLE rsp)
+static inline u32 dat_rsp_free(struct dat_sp *rsp)
 {
         return DAT_CALL_PROVIDER_FUNC(rsp_free_func, rsp);
 }
 
-static inline u32 dat_pz_create(DAT_IA_HANDLE ia, DAT_PZ_HANDLE *pz)
+static inline u32 dat_pz_create(struct dat_ia *ia, struct dat_pz **pz)
 {
         return DAT_CALL_PROVIDER_FUNC(pz_create_func, ia, pz);
 }
 
-static inline u32 dat_pz_query(DAT_PZ_HANDLE pz, struct dat_pz_param *param)
+static inline u32 dat_pz_query(struct dat_pz *pz, struct dat_pz_param *param)
 {
         return DAT_CALL_PROVIDER_FUNC(pz_query_func, pz, param);
 }
 
-static inline u32 dat_pz_free(DAT_PZ_HANDLE pz)
+static inline u32 dat_pz_free(struct dat_pz *pz)
 {
         return DAT_CALL_PROVIDER_FUNC(pz_free_func, pz);
 }
 
-static inline u32 dat_srq_create(DAT_IA_HANDLE ia, DAT_PZ_HANDLE pz,
+static inline u32 dat_srq_create(struct dat_ia *ia, struct dat_pz *pz,
 				 struct dat_srq_attr *attr,
-				 DAT_SRQ_HANDLE *srq)
+				 struct dat_srq **srq)
 {
         return DAT_CALL_PROVIDER_FUNC(srq_create_func, ia, pz, attr, srq);
 }
 
-static inline u32 dat_srq_free(DAT_SRQ_HANDLE srq)
+static inline u32 dat_srq_free(struct dat_srq *srq)
 {
         return DAT_CALL_PROVIDER_FUNC(srq_free_func, srq);
 }
 
-static inline u32 dat_srq_post_recv(DAT_SRQ_HANDLE srq, int num_iovs,
+static inline u32 dat_srq_post_recv(struct dat_srq *srq, int num_iovs,
 				    struct dat_lmr_triplet *iovs,
 				    DAT_DTO_COOKIE cookie)
 {
@@ -1752,34 +1755,34 @@ static inline u32 dat_srq_post_recv(DAT_
 				      cookie);
 }
 
-static inline u32 dat_srq_query(DAT_SRQ_HANDLE srq, struct dat_srq_param *param)
+static inline u32 dat_srq_query(struct dat_srq *srq, struct dat_srq_param *param)
 {
         return DAT_CALL_PROVIDER_FUNC(srq_query_func, srq, param);
 }
 
-static inline u32 dat_srq_resize(DAT_SRQ_HANDLE srq, int max_recv_dtos)
+static inline u32 dat_srq_resize(struct dat_srq *srq, int max_recv_dtos)
 {
         return DAT_CALL_PROVIDER_FUNC(srq_resize_func, srq, max_recv_dtos);
 }
 
-static inline u32 dat_srq_set_lw(DAT_SRQ_HANDLE srq, int low_watermark)
+static inline u32 dat_srq_set_lw(struct dat_srq *srq, int low_watermark)
 {
         return DAT_CALL_PROVIDER_FUNC(srq_set_lw_func, srq, low_watermark);
 }
 
-static inline u32 dat_lmr_kcreate(DAT_IA_HANDLE ia, enum dat_mem_type type,
+static inline u32 dat_lmr_kcreate(struct dat_ia *ia, enum dat_mem_type type,
 				  DAT_REGION_DESCRIPTION region, u64 len,
-				  DAT_PZ_HANDLE pz,
+				  struct dat_pz *pz,
 				  enum dat_mem_priv_flags privileges,
 				  enum dat_mem_optimize_flags optimization,
-				  DAT_LMR_HANDLE *lmr_handle,
+				  struct dat_lmr **lmr,
 				  DAT_LMR_CONTEXT *lmr_context,
 				  DAT_RMR_CONTEXT *rmr_context,
 				  u64 *registered_length,
 				  u64 *registered_address)
 {
         return DAT_CALL_PROVIDER_FUNC(lmr_kcreate_func, ia, type, region, len,
-				      pz, privileges, optimization, lmr_handle,
+				      pz, privileges, optimization, lmr,
 				      lmr_context, rmr_context,
 				      registered_length, registered_address);
 }




More information about the general mailing list