[openib-general] [PATCH] kDAPL: remove use of typedefs for structs in dapl.h
Tom Duffy
tduffy at sun.com
Fri May 20 17:34:30 PDT 2005
James,
I am sorry this is such a large patch. I had broken it out into 19
different patches, each changing one typedef, but after the large
changes you made today, it was going to be a big PITA to regenerate them
all. So, I just rebased my final tree with r2431 and generated one
large patch.
This patch removes the use of many of the struct typedefs in dapl.h.
Signed-off-by: Tom Duffy <tduffy at sun.com>
Index: linux-kernel-resolv/dat-provider/dapl_evd_cq_async_error_callb.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_evd_cq_async_error_callb.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_evd_cq_async_error_callb.c (working copy)
@@ -53,22 +53,19 @@
*
*/
-void
-dapl_evd_cq_async_error_callback(struct ib_event *cause_ptr, void *context)
+void dapl_evd_cq_async_error_callback(struct ib_event *cause_ptr, void *context)
{
- DAPL_EVD *async_evd;
- DAPL_EVD *evd;
+ struct dapl_evd *async_evd;
+ struct dapl_evd *evd = context;
u32 dat_status;
dapl_dbg_log(DAPL_DBG_TYPE_CALLBACK | DAPL_DBG_TYPE_EXCEPTION,
"dapl_evd_cq_async_error_callback (%p, %p)\n",
cause_ptr, context);
- if (NULL == context) {
+ if (!evd)
dapl_os_panic("NULL == context\n");
- }
- evd = (DAPL_EVD *) context;
async_evd = evd->header.owner_ia->async_error_evd;
dat_status = dapl_evd_post_async_error_event(async_evd,
Index: linux-kernel-resolv/dat-provider/dapl_cookie.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_cookie.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_cookie.c (working copy)
@@ -84,9 +84,11 @@
* *
*********************************************************************/
-u32 dapl_cb_get(DAPL_COOKIE_BUFFER *buffer, DAPL_COOKIE **cookie_ptr);
+u32 dapl_cb_get(struct dapl_cookie_buffer *buffer,
+ struct dapl_cookie **cookie_ptr);
-u32 dapl_cb_put(DAPL_COOKIE_BUFFER *buffer, DAPL_COOKIE *cookie);
+u32 dapl_cb_put(struct dapl_cookie_buffer *buffer,
+ struct dapl_cookie *cookie);
/*********************************************************************
* *
@@ -97,11 +99,11 @@ u32 dapl_cb_put(DAPL_COOKIE_BUFFER *buff
/*
* dapl_cb_create
*
- * Given a DAPL_COOKIE_BUFFER, allocate and initialize memory for
+ * Given a struct dapl_cookie_buffer, allocate and initialize memory for
* the data structure.
*
* Input:
- * buffer pointer to DAPL_COOKIE_BUFFER
+ * buffer pointer to struct dapl_cookie_buffer
* ep endpoint to associate with cookies
* size number of elements to allocate & manage
*
@@ -113,7 +115,8 @@ u32 dapl_cb_put(DAPL_COOKIE_BUFFER *buff
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_cb_create(DAPL_COOKIE_BUFFER *buffer, DAPL_EP *ep, int size)
+u32 dapl_cb_create(struct dapl_cookie_buffer *buffer, struct dapl_ep *ep,
+ int size)
{
int i;
@@ -145,7 +148,7 @@ u32 dapl_cb_create(DAPL_COOKIE_BUFFER *b
* Free the data structure
*
* Input:
- * buffer pointer to DAPL_COOKIE_BUFFER
+ * buffer pointer to struct dapl_cookie_buffer
*
* Output:
* none
@@ -154,7 +157,7 @@ u32 dapl_cb_create(DAPL_COOKIE_BUFFER *b
* none
*
*/
-void dapl_cb_free(DAPL_COOKIE_BUFFER * buffer)
+void dapl_cb_free(struct dapl_cookie_buffer *buffer)
{
if (NULL != buffer->pool)
kfree(buffer->pool);
@@ -166,7 +169,7 @@ void dapl_cb_free(DAPL_COOKIE_BUFFER * b
* Remove an entry from the buffer
*
* Input:
- * buffer pointer to DAPL_COOKIE_BUFFER
+ * buffer pointer to struct dapl_cookie_buffer
*
* Output:
* cookie_ptr pointer to pointer to cookie
@@ -177,7 +180,8 @@ void dapl_cb_free(DAPL_COOKIE_BUFFER * b
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_cb_get(DAPL_COOKIE_BUFFER *buffer, DAPL_COOKIE **cookie_ptr)
+u32 dapl_cb_get(struct dapl_cookie_buffer *buffer,
+ struct dapl_cookie **cookie_ptr)
{
u32 dat_status;
int new_head;
@@ -195,7 +199,7 @@ u32 dapl_cb_get(DAPL_COOKIE_BUFFER *buff
*cookie_ptr = &buffer->pool[atomic_read(&buffer->head)];
dat_status = DAT_SUCCESS;
}
- bail:
+bail:
return dat_status;
}
@@ -205,7 +209,7 @@ u32 dapl_cb_get(DAPL_COOKIE_BUFFER *buff
* Add entry(s) to the buffer
*
* Input:
- * buffer pointer to DAPL_COOKIE_BUFFER
+ * buffer pointer to struct dapl_cookie_buffer
* cookie pointer to cookie
*
* Output:
@@ -216,7 +220,7 @@ u32 dapl_cb_get(DAPL_COOKIE_BUFFER *buff
* DAT_INSUFFICIENT_EMPTY
*
*/
-u32 dapl_cb_put(DAPL_COOKIE_BUFFER *buffer, DAPL_COOKIE *cookie)
+u32 dapl_cb_put(struct dapl_cookie_buffer *buffer, struct dapl_cookie *cookie)
{
atomic_set(&buffer->tail, cookie->index);
@@ -229,7 +233,7 @@ u32 dapl_cb_put(DAPL_COOKIE_BUFFER *buff
* Allocate an RMR Bind cookie
*
* Input:
- * buffer pointer to DAPL_COOKIE_BUFFER
+ * buffer pointer to struct dapl_cookie_buffer
* rmr rmr to associate with the cookie
* user_cookie user's cookie data
*
@@ -241,10 +245,11 @@ u32 dapl_cb_put(DAPL_COOKIE_BUFFER *buff
* DAT_INSUFFICIENT_EMPTY
*
*/
-u32 dapl_rmr_cookie_alloc(DAPL_COOKIE_BUFFER *buffer, DAPL_RMR *rmr,
- DAT_RMR_COOKIE user_cookie, DAPL_COOKIE **cookie_ptr)
+u32 dapl_rmr_cookie_alloc(struct dapl_cookie_buffer *buffer,
+ struct dapl_rmr *rmr, DAT_RMR_COOKIE user_cookie,
+ struct dapl_cookie **cookie_ptr)
{
- DAPL_COOKIE *cookie;
+ struct dapl_cookie *cookie;
u32 dat_status;
if (DAT_SUCCESS != dapl_cb_get(buffer, &cookie)) {
@@ -261,7 +266,7 @@ u32 dapl_rmr_cookie_alloc(DAPL_COOKIE_BU
*cookie_ptr = cookie;
- bail:
+bail:
return dat_status;
}
@@ -271,7 +276,7 @@ u32 dapl_rmr_cookie_alloc(DAPL_COOKIE_BU
* Allocate a DTO cookie
*
* Input:
- * buffer pointer to DAPL_COOKIE_BUFFER
+ * buffer pointer to struct dapl_cookie_buffer
* type DTO type
* user_cookie user's cookie data
*
@@ -283,10 +288,10 @@ u32 dapl_rmr_cookie_alloc(DAPL_COOKIE_BU
* DAT_INSUFFICIENT_EMPTY
*
*/
-u32 dapl_dto_cookie_alloc(DAPL_COOKIE_BUFFER *buffer, DAPL_DTO_TYPE type,
- DAT_DTO_COOKIE user_cookie, DAPL_COOKIE **cookie_ptr)
+u32 dapl_dto_cookie_alloc(struct dapl_cookie_buffer *buffer, DAPL_DTO_TYPE type,
+ DAT_DTO_COOKIE user_cookie, struct dapl_cookie **cookie_ptr)
{
- DAPL_COOKIE *cookie;
+ struct dapl_cookie *cookie;
if (DAT_SUCCESS != dapl_cb_get(buffer, &cookie)) {
*cookie_ptr = NULL;
@@ -303,7 +308,8 @@ u32 dapl_dto_cookie_alloc(DAPL_COOKIE_BU
return DAT_SUCCESS;
}
-void dapl_cookie_dealloc(DAPL_COOKIE_BUFFER * buffer, DAPL_COOKIE * cookie)
+void dapl_cookie_dealloc(struct dapl_cookie_buffer *buffer,
+ struct dapl_cookie * cookie)
{
dapl_cb_put(buffer, cookie);
}
Index: linux-kernel-resolv/dat-provider/dapl_ia_memtype_hint.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ia_memtype_hint.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ia_memtype_hint.c (working copy)
@@ -69,13 +69,13 @@ u32 dapl_ia_memtype_hint(DAT_IA_HANDLE i
u64 *suggested_length,
u64 *suggested_alignment)
{
- DAPL_IA *ia_ptr;
+ struct dapl_ia *ia_ptr;
u32 dat_status = DAT_SUCCESS;
dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_ia_memtype_hint (%p)\n",
ia_handle);
- ia_ptr = (DAPL_IA *) ia_handle;
+ ia_ptr = (struct dapl_ia *)ia_handle;
if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
dat_status =
Index: linux-kernel-resolv/dat-provider/dapl_ep_connect.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ep_connect.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ep_connect.c (working copy)
@@ -48,8 +48,7 @@ u32 dapl_ep_connect(DAT_EP_HANDLE ep_han
int private_data_size, const void *private_data,
enum dat_qos qos, enum dat_connect_flags connect_flags)
{
- DAPL_EP *ep_ptr;
- DAPL_EP alloc_ep;
+ struct dapl_ep *ep_ptr, alloc_ep;
u32 dat_status = DAT_SUCCESS;
dapl_dbg_log(DAPL_DBG_TYPE_API | DAPL_DBG_TYPE_CM,
@@ -63,7 +62,7 @@ u32 dapl_ep_connect(DAT_EP_HANDLE ep_han
timeout,
private_data_size, private_data, qos, connect_flags);
- ep_ptr = (DAPL_EP *) ep_handle;
+ ep_ptr = (struct dapl_ep *)ep_handle;
/*
* Verify parameter & state. The connection handle must be good
@@ -174,7 +173,7 @@ u32 dapl_ep_connect(DAT_EP_HANDLE ep_han
/* test connect handle */
|| ep_ptr->param.connect_evd_handle == NULL
|| DAPL_BAD_HANDLE(ep_ptr->param.connect_evd_handle, DAPL_MAGIC_EVD)
- || !(((DAPL_EVD *) ep_ptr->param.connect_evd_handle)->
+ || !(((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 &&
@@ -261,8 +260,8 @@ u32 dapl_ep_connect(DAT_EP_HANDLE ep_han
* this happens, return SUCCESS and generate the event
*/
if (dat_status == DAT_ERROR(DAT_INTERNAL_ERROR, 1)) {
- dapl_evd_post_connection_event((DAPL_EVD *) ep_ptr->
- param.
+ dapl_evd_post_connection_event((struct dapl_evd *)
+ ep_ptr->param.
connect_evd_handle,
DAT_CONNECTION_EVENT_UNREACHABLE,
(DAT_HANDLE) ep_ptr, 0,
Index: linux-kernel-resolv/dat-provider/dapl_cookie.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_cookie.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_cookie.h (working copy)
@@ -36,20 +36,21 @@
#include "dapl.h"
-extern u32 dapl_cb_create(DAPL_COOKIE_BUFFER *buffer, DAPL_EP *ep,
+extern u32 dapl_cb_create(struct dapl_cookie_buffer *buffer, struct dapl_ep *ep,
int size);
-extern void dapl_cb_free(DAPL_COOKIE_BUFFER *buffer);
+extern void dapl_cb_free(struct dapl_cookie_buffer *buffer);
-extern u32 dapl_rmr_cookie_alloc(DAPL_COOKIE_BUFFER *buffer, DAPL_RMR *rmr,
+extern u32 dapl_rmr_cookie_alloc(struct dapl_cookie_buffer *buffer,
+ struct dapl_rmr *rmr,
DAT_RMR_COOKIE user_cookie,
- DAPL_COOKIE **cookie_ptr);
+ struct dapl_cookie **cookie_ptr);
-extern u32 dapl_dto_cookie_alloc(DAPL_COOKIE_BUFFER *buffer,
+extern u32 dapl_dto_cookie_alloc(struct dapl_cookie_buffer *buffer,
DAPL_DTO_TYPE type, DAT_DTO_COOKIE user_cookie,
- DAPL_COOKIE **cookie_ptr);
+ struct dapl_cookie **cookie_ptr);
-extern void
-dapl_cookie_dealloc(DAPL_COOKIE_BUFFER * buffer, DAPL_COOKIE * cookie);
+extern void dapl_cookie_dealloc(struct dapl_cookie_buffer *buffer,
+ struct dapl_cookie *cookie);
#endif /* DAPL_COOKIE_H */
Index: linux-kernel-resolv/dat-provider/dapl_cr_callback.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_cr_callback.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_cr_callback.c (working copy)
@@ -45,11 +45,13 @@
/*
* Prototypes
*/
-u32 dapl_connection_request(struct dapl_cm_id *ib_cm_handle, DAPL_SP *sp_ptr,
- const void *prd_ptr, DAPL_EVD *evd_ptr);
-
-DAPL_EP *dapl_get_sp_ep(struct dapl_cm_id *ib_cm_handle, DAPL_SP * sp_ptr,
- enum dat_event_number event);
+u32 dapl_connection_request(struct dapl_cm_id *ib_cm_handle,
+ struct dapl_sp *sp_ptr, const void *prd_ptr,
+ struct dapl_evd *evd_ptr);
+
+struct dapl_ep *dapl_get_sp_ep(struct dapl_cm_id *ib_cm_handle,
+ struct dapl_sp *sp_ptr,
+ enum dat_event_number dat_event_num);
/*
* The callback function registered with verbs for passive side of
@@ -60,9 +62,9 @@ void dapl_cr_callback(struct dapl_cm_id
const void *private_data_ptr, /* event data */
const void *context)
{
- DAPL_EP *ep_ptr;
- DAPL_EVD *evd_ptr;
- DAPL_SP *sp_ptr;
+ struct dapl_ep *ep_ptr;
+ struct dapl_evd *evd_ptr;
+ struct dapl_sp *sp_ptr;
u32 dat_status;
dapl_dbg_log(DAPL_DBG_TYPE_CM | DAPL_DBG_TYPE_CALLBACK,
@@ -73,7 +75,7 @@ void dapl_cr_callback(struct dapl_cm_id
* Passive side of the connection, context is a SP and
* we need to look up the EP.
*/
- sp_ptr = (DAPL_SP *) context;
+ sp_ptr = (struct dapl_sp *)context;
/*
* The context pointer could have been cleaned up in a racing
* CM callback, check to see if we should just exit here
@@ -106,7 +108,7 @@ void dapl_cr_callback(struct dapl_cm_id
if (ep_ptr == NULL) {
return;
}
- evd_ptr = (DAPL_EVD *) ep_ptr->param.connect_evd_handle;
+ evd_ptr = (struct dapl_evd *)ep_ptr->param.connect_evd_handle;
/* if something has happened to our EVD, bail. */
if (evd_ptr == NULL) {
return;
@@ -259,13 +261,14 @@ void dapl_cr_callback(struct dapl_cm_id
* Create a CR record and link it on to the SP so we can update it
* and free it later. Create an EP if specified by the PSP flags.
*/
-u32 dapl_connection_request(struct dapl_cm_id *ib_cm_handle, DAPL_SP *sp_ptr,
- const void *prd_ptr, DAPL_EVD *evd_ptr)
+u32 dapl_connection_request(struct dapl_cm_id *ib_cm_handle,
+ struct dapl_sp *sp_ptr, const void *prd_ptr,
+ struct dapl_evd *evd_ptr)
{
u32 dat_status;
- DAPL_CR *cr_ptr;
- DAPL_EP *ep_ptr;
- DAPL_IA *ia_ptr;
+ struct dapl_cr *cr_ptr;
+ struct dapl_ep *ep_ptr;
+ struct dapl_ia *ia_ptr;
DAT_SP_HANDLE sp_handle;
cr_ptr = dapl_cr_alloc(sp_ptr->header.owner_ia);
@@ -295,7 +298,7 @@ u32 dapl_connection_request(struct dapl_
}
/* EP will be NULL unless RSP service point */
- ep_ptr = (DAPL_EP *) sp_ptr->ep_handle;
+ ep_ptr = (struct dapl_ep *)sp_ptr->ep_handle;
if (sp_ptr->psp_flags == DAT_PSP_PROVIDER_FLAG) {
/*
@@ -362,11 +365,12 @@ u32 dapl_connection_request(struct dapl_
* up resources and obtain the EP pointer associated with a CR in
* the SP.
*/
-DAPL_EP *dapl_get_sp_ep(struct dapl_cm_id *ib_cm_handle,
- DAPL_SP * sp_ptr, enum dat_event_number event)
+struct dapl_ep *dapl_get_sp_ep(struct dapl_cm_id *ib_cm_handle,
+ struct dapl_sp *sp_ptr,
+ enum dat_event_number event)
{
- DAPL_CR *cr_ptr;
- DAPL_EP *ep_ptr;
+ struct dapl_cr *cr_ptr;
+ struct dapl_ep *ep_ptr;
/*
* acquire the lock, we may be racing with other threads here
@@ -391,7 +395,7 @@ DAPL_EP *dapl_get_sp_ep(struct dapl_cm_i
return NULL;
}
- ep_ptr = (DAPL_EP *) cr_ptr->param.local_ep_handle;
+ 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))) {
@@ -427,8 +431,7 @@ DAPL_EP *dapl_get_sp_ep(struct dapl_cm_i
sp_ptr);
/* Decrement the ref count on the EVD */
if (sp_ptr->evd_handle) {
- atomic_dec(&
- ((DAPL_EVD *) sp_ptr->
+ atomic_dec(&((struct dapl_evd *)sp_ptr->
evd_handle)->evd_ref_count);
sp_ptr->evd_handle = NULL;
}
@@ -437,7 +440,8 @@ DAPL_EP *dapl_get_sp_ep(struct dapl_cm_i
sp_ptr->header.flags);
(void)dapl_ib_remove_conn_listener(sp_ptr->header.
owner_ia, sp_ptr);
- dapl_ia_unlink_sp((DAPL_IA *) sp_ptr->header.owner_ia,
+ dapl_ia_unlink_sp((struct dapl_ia *)
+ sp_ptr->header.owner_ia,
sp_ptr);
dapl_sp_dealloc(sp_ptr);
dapl_cr_free(cr_ptr);
Index: linux-kernel-resolv/dat-provider/dapl_evd_dto_callb.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_evd_dto_callb.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_evd_dto_callb.c (working copy)
@@ -70,7 +70,7 @@
void dapl_evd_dto_callback(struct ib_cq *cq_handle, void *user_context)
{
- DAPL_EVD *evd_ptr;
+ struct dapl_evd *evd_ptr;
u32 dat_status;
DAPL_EVD_STATE state;
@@ -78,7 +78,7 @@ void dapl_evd_dto_callback(struct ib_cq
"dapl_evd_dto_callback(%p, %p)\n",
cq_handle, user_context);
- evd_ptr = (DAPL_EVD *) user_context;
+ evd_ptr = (struct dapl_evd *)user_context;
dapl_os_assert(evd_ptr->ib_cq_handle == cq_handle);
dapl_os_assert(evd_ptr->header.magic == DAPL_MAGIC_EVD);
Index: linux-kernel-resolv/dat-provider/dapl_rmr_create.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_rmr_create.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_rmr_create.c (working copy)
@@ -55,8 +55,8 @@
*/
u32 dapl_rmr_create(DAT_PZ_HANDLE pz_handle, DAT_RMR_HANDLE *rmr_handle)
{
- DAPL_PZ *pz;
- DAPL_RMR *rmr;
+ struct dapl_pz *pz;
+ struct dapl_rmr *rmr;
u32 dat_status = DAT_SUCCESS;
if (DAPL_BAD_HANDLE(pz_handle, DAPL_MAGIC_PZ)) {
@@ -65,7 +65,7 @@ u32 dapl_rmr_create(DAT_PZ_HANDLE pz_han
goto bail;
}
- pz = (DAPL_PZ *) pz_handle;
+ pz = (struct dapl_pz *)pz_handle;
rmr = dapl_rmr_alloc(pz);
@@ -89,6 +89,6 @@ u32 dapl_rmr_create(DAT_PZ_HANDLE pz_han
*rmr_handle = rmr;
- bail:
+bail:
return dat_status;
}
Index: linux-kernel-resolv/dat-provider/dapl_lmr_sync_rdma_read.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_lmr_sync_rdma_read.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_lmr_sync_rdma_read.c (working copy)
@@ -60,14 +60,14 @@ u32 dapl_lmr_sync_rdma_read(DAT_IA_HANDL
const struct dat_lmr_triplet *local_segments,
u64 num_segments)
{
- DAPL_IA *ia_ptr;
+ struct dapl_ia *ia_ptr;
u32 dat_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_ptr = (DAPL_IA *) ia_handle;
+ ia_ptr = (struct dapl_ia *)ia_handle;
if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
dat_status =
Index: linux-kernel-resolv/dat-provider/dapl_module.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_module.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_module.c (working copy)
@@ -120,7 +120,7 @@ void DAT_PROVIDER_INIT_FUNC_NAME(const s
struct ib_device *device, u8 port)
{
struct dat_provider *provider;
- DAPL_HCA *hca_ptr;
+ struct dapl_hca *hca_ptr;
u32 dat_status;
provider = NULL;
Index: linux-kernel-resolv/dat-provider/dapl_ring_buffer_util.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ring_buffer_util.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ring_buffer_util.c (working copy)
@@ -40,12 +40,12 @@
/*
* dapl_rbuf_alloc
*
- * Given a DAPL_RING_BUFFER, initialize it and provide memory for
+ * Given a struct dapl_ring_buffer, initialize it and provide memory for
* the ringbuf itself. A passed in size will be adjusted to the next
* largest power of two number to simplify management.
*
* Input:
- * rbuf pointer to DAPL_RING_BUFFER
+ * rbuf pointer to struct dapl_ring_buffer
* size number of elements to allocate & manage
*
* Output:
@@ -56,7 +56,7 @@
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_rbuf_alloc(DAPL_RING_BUFFER *rbuf, int size)
+u32 dapl_rbuf_alloc(struct dapl_ring_buffer *rbuf, int size)
{
unsigned int rsize; /* real size */
@@ -86,12 +86,12 @@ u32 dapl_rbuf_alloc(DAPL_RING_BUFFER *rb
/*
* dapl_rbuf_realloc
*
- * Resizes an empty DAPL_RING_BUFFER. This function is not thread safe;
+ * Resizes an empty struct dapl_ring_buffer. This function is not thread safe;
* adding or removing elements from a ring buffer while resizing
* will have indeterminate results.
*
* Input:
- * rbuf pointer to DAPL_RING_BUFFER
+ * rbuf pointer to struct dapl_ring_buffer
* size number of elements to allocate & manage
*
* Output:
@@ -103,10 +103,10 @@ u32 dapl_rbuf_alloc(DAPL_RING_BUFFER *rb
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_rbuf_realloc(DAPL_RING_BUFFER *rbuf, int size)
+u32 dapl_rbuf_realloc(struct dapl_ring_buffer *rbuf, int size)
{
- DAPL_RING_BUFFER new_rbuf;
- void *entry;
+ struct dapl_ring_buffer new_rbuf;
+ void *entry;
u32 dat_status = DAT_SUCCESS;
/* decreasing the size or retaining the old size is not allowed */
@@ -146,10 +146,10 @@ u32 dapl_rbuf_realloc(DAPL_RING_BUFFER *
/*
* dapl_rbuf_destroy
*
- * Release the buffer and reset pointers to a DAPL_RING_BUFFER
+ * Release the buffer and reset pointers to a struct dapl_ring_buffer
*
* Input:
- * rbuf pointer to DAPL_RING_BUFFER
+ * rbuf pointer to struct dapl_ring_buffer
*
* Output:
* none
@@ -158,7 +158,7 @@ u32 dapl_rbuf_realloc(DAPL_RING_BUFFER *
* none
*
*/
-void dapl_rbuf_destroy(DAPL_RING_BUFFER * rbuf)
+void dapl_rbuf_destroy(struct dapl_ring_buffer *rbuf)
{
if ((NULL == rbuf) || (NULL == rbuf->base)) {
return;
@@ -177,7 +177,7 @@ void dapl_rbuf_destroy(DAPL_RING_BUFFER
* Add an entry to the ring buffer
*
* Input:
- * rbuf pointer to DAPL_RING_BUFFER
+ * rbuf pointer to struct dapl_ring_buffer
* entry entry to add
*
* Output:
@@ -188,7 +188,7 @@ void dapl_rbuf_destroy(DAPL_RING_BUFFER
* DAT_INSUFFICIENT_RESOURCES (queue full)
*
*/
-u32 dapl_rbuf_add(DAPL_RING_BUFFER *rbuf, void *entry)
+u32 dapl_rbuf_add(struct dapl_ring_buffer *rbuf, void *entry)
{
int pos;
int val;
@@ -214,7 +214,7 @@ u32 dapl_rbuf_add(DAPL_RING_BUFFER *rbuf
* Remove an entry from the ring buffer
*
* Input:
- * rbuf pointer to DAPL_RING_BUFFER
+ * rbuf pointer to struct dapl_ring_buffer
*
* Output:
* entry entry removed from the ring buffer
@@ -224,7 +224,7 @@ u32 dapl_rbuf_add(DAPL_RING_BUFFER *rbuf
* DAT_QUEUE_EMPTY
*/
-void *dapl_rbuf_remove(DAPL_RING_BUFFER * rbuf)
+void *dapl_rbuf_remove(struct dapl_ring_buffer *rbuf)
{
int pos;
int val;
@@ -250,7 +250,7 @@ void *dapl_rbuf_remove(DAPL_RING_BUFFER
* Return the number of entries in use in the ring buffer
*
* Input:
- * rbuf pointer to DAPL_RING_BUFFER
+ * rbuf pointer to struct dapl_ring_buffer
*
*
* Output:
@@ -260,7 +260,7 @@ void *dapl_rbuf_remove(DAPL_RING_BUFFER
* count of entries
*
*/
-int dapl_rbuf_count(DAPL_RING_BUFFER * rbuf)
+int dapl_rbuf_count(struct dapl_ring_buffer *rbuf)
{
int count, head, tail;
@@ -286,7 +286,7 @@ int dapl_rbuf_count(DAPL_RING_BUFFER * r
* functions).
*
* Input:
- * rbuf pointer to DAPL_RING_BUFFER
+ * rbuf pointer to struct dapl_ring_buffer
* offset offset to adjust elemnt addresss by,
* used for addresses of type void *
* Output:
@@ -295,7 +295,7 @@ int dapl_rbuf_count(DAPL_RING_BUFFER * r
* Returns:
* none
*/
-void dapl_rbuf_adjust(DAPL_RING_BUFFER * rbuf, unsigned long offset)
+void dapl_rbuf_adjust(struct dapl_ring_buffer *rbuf, unsigned long offset)
{
int pos;
Index: linux-kernel-resolv/dat-provider/dapl_psp_create.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_psp_create.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_psp_create.c (working copy)
@@ -71,13 +71,13 @@ u32 dapl_psp_create(DAT_IA_HANDLE ia_han
DAT_EVD_HANDLE evd_handle, enum dat_psp_flags psp_flags,
DAT_PSP_HANDLE *psp_handle)
{
- DAPL_IA *ia_ptr;
- DAPL_SP *sp_ptr;
- DAPL_EVD *evd_ptr;
+ struct dapl_ia *ia_ptr;
+ struct dapl_sp *sp_ptr;
+ struct dapl_evd *evd_ptr;
boolean_t sp_found;
u32 dat_status = DAT_SUCCESS;
- ia_ptr = (DAPL_IA *) ia_handle;
+ ia_ptr = (struct dapl_ia *)ia_handle;
if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
dat_status =
@@ -95,7 +95,7 @@ u32 dapl_psp_create(DAT_IA_HANDLE ia_han
goto bail;
}
- evd_ptr = (DAPL_EVD *) evd_handle;
+ evd_ptr = (struct dapl_evd *)evd_handle;
if (!(evd_ptr->evd_flags & DAT_EVD_CR_FLAG)) {
dat_status =
DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_CR);
@@ -141,7 +141,7 @@ u32 dapl_psp_create(DAT_IA_HANDLE ia_han
/*
* Take a reference on the EVD handle
*/
- atomic_inc(&((DAPL_EVD *) evd_handle)->evd_ref_count);
+ atomic_inc(&((struct dapl_evd *)evd_handle)->evd_ref_count);
/*
* Set up a listener for a connection. Connections can arrive
@@ -168,7 +168,7 @@ u32 dapl_psp_create(DAT_IA_HANDLE ia_han
* Have a problem setting up the connection, something
* wrong! Decrements the EVD refcount & release it.
*/
- atomic_dec(&((DAPL_EVD *) evd_handle)->
+ atomic_dec(&((struct dapl_evd *)evd_handle)->
evd_ref_count);
sp_ptr->evd_handle = NULL;
dapl_ia_unlink_sp(ia_ptr, sp_ptr);
Index: linux-kernel-resolv/dat-provider/dapl_srq_resize.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_srq_resize.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_srq_resize.c (working copy)
@@ -65,8 +65,8 @@
u32 dapl_srq_resize(DAT_SRQ_HANDLE srq_handle, int srq_max_recv_dto)
{
- DAPL_IA *ia_ptr;
- DAPL_SRQ *srq_ptr;
+ struct dapl_ia *ia_ptr;
+ struct dapl_srq *srq_ptr;
u32 dat_status = DAT_SUCCESS;
dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_srq_resize (%p, %d)\n",
@@ -78,7 +78,7 @@ u32 dapl_srq_resize(DAT_SRQ_HANDLE srq_h
goto bail;
}
- srq_ptr = (DAPL_SRQ *) srq_handle;
+ srq_ptr = (struct dapl_srq *)srq_handle;
ia_ptr = srq_ptr->header.owner_ia;
/*
Index: linux-kernel-resolv/dat-provider/dapl_ep_create.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ep_create.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ep_create.c (working copy)
@@ -69,8 +69,8 @@ u32 dapl_ep_create(DAT_IA_HANDLE ia_hand
DAT_EVD_HANDLE connect_evd_handle,
const struct dat_ep_attr *ep_attr, DAT_EP_HANDLE *ep_handle)
{
- DAPL_IA *ia_ptr;
- DAPL_EP *ep_ptr;
+ struct dapl_ia *ia_ptr;
+ struct dapl_ep *ep_ptr;
struct dat_ep_attr *ep_attr_limit;
u32 dat_status = DAT_SUCCESS;
@@ -82,7 +82,7 @@ u32 dapl_ep_create(DAT_IA_HANDLE ia_hand
request_evd_handle,
connect_evd_handle, ep_attr, ep_handle);
- ia_ptr = (DAPL_IA *) ia_handle;
+ ia_ptr = (struct dapl_ia *)ia_handle;
/*
* Verify parameters
@@ -109,7 +109,7 @@ u32 dapl_ep_create(DAT_IA_HANDLE ia_hand
/* 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) ||
- !(((DAPL_EVD *) connect_evd_handle)->
+ !(((struct dapl_evd *)connect_evd_handle)->
evd_flags & DAT_EVD_CONNECTION_FLAG))) {
dat_status =
DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_CONN);
@@ -119,7 +119,7 @@ u32 dapl_ep_create(DAT_IA_HANDLE ia_hand
/* 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) ||
- !(((DAPL_EVD *) recv_evd_handle)->evd_flags & DAT_EVD_DTO_FLAG))) {
+ !(((struct dapl_evd *)recv_evd_handle)->evd_flags & DAT_EVD_DTO_FLAG))) {
dat_status =
DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_RECV);
goto bail;
@@ -128,7 +128,7 @@ u32 dapl_ep_create(DAT_IA_HANDLE ia_hand
/* 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) ||
- !(((DAPL_EVD *) request_evd_handle)->
+ !(((struct dapl_evd *)request_evd_handle)->
evd_flags & DAT_EVD_DTO_FLAG))) {
dat_status =
DAT_ERROR(DAT_INVALID_HANDLE,
@@ -210,13 +210,11 @@ u32 dapl_ep_create(DAT_IA_HANDLE ia_hand
/*
* Make sure we handle the NULL DTO EVDs
*/
- if (recv_evd_handle == DAT_HANDLE_NULL && ep_attr == NULL) {
+ if (recv_evd_handle == DAT_HANDLE_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_handle == DAT_HANDLE_NULL && ep_attr == NULL)
ep_ptr->param.ep_attr.max_request_dtos = 0;
- }
/*
* If the user has specified a PZ handle we allocate a QP for
@@ -226,7 +224,7 @@ u32 dapl_ep_create(DAT_IA_HANDLE ia_hand
*/
if (pz_handle != DAT_HANDLE_NULL) {
/* Take a reference on the PZ handle */
- atomic_inc(&((DAPL_PZ *) pz_handle)->pz_ref_count);
+ atomic_inc(&((struct dapl_pz *)pz_handle)->pz_ref_count);
/*
* Get a QP from the IB provider
@@ -234,14 +232,12 @@ 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(&((DAPL_PZ *) pz_handle)->
- pz_ref_count);
+ atomic_dec(&((struct dapl_pz *)pz_handle)->pz_ref_count);
dapl_ep_dealloc(ep_ptr);
goto bail;
}
- } else {
+ } else
ep_ptr->qp_state = DAPL_QP_STATE_UNATTACHED;
- }
/*
* Update ref counts. See the spec where the endpoint marks
@@ -251,22 +247,20 @@ u32 dapl_ep_create(DAT_IA_HANDLE ia_hand
*
* N.B. This should really be done by a util routine.
*/
- atomic_inc(&((DAPL_EVD *) connect_evd_handle)->evd_ref_count);
+ atomic_inc(&((struct dapl_evd *)connect_evd_handle)->evd_ref_count);
/* Optional handles */
- if (recv_evd_handle != DAT_HANDLE_NULL) {
- atomic_inc(&((DAPL_EVD *) recv_evd_handle)->
+ if (recv_evd_handle != DAT_HANDLE_NULL)
+ atomic_inc(&((struct dapl_evd *)recv_evd_handle)->
evd_ref_count);
- }
- if (request_evd_handle != DAT_HANDLE_NULL) {
- atomic_inc(&((DAPL_EVD *) request_evd_handle)->
+ if (request_evd_handle != DAT_HANDLE_NULL)
+ atomic_inc(&((struct dapl_evd *)request_evd_handle)->
evd_ref_count);
- }
/* Link it onto the IA */
dapl_ia_link_ep(ia_ptr, ep_ptr);
*ep_handle = ep_ptr;
- bail:
+bail:
return dat_status;
}
Index: linux-kernel-resolv/dat-provider/dapl_lmr_util.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_lmr_util.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_lmr_util.c (working copy)
@@ -38,14 +38,12 @@
#include "dapl_lmr_util.h"
#include "dapl_ia_util.h"
-DAPL_LMR *dapl_lmr_alloc(DAPL_IA * ia,
- enum dat_mem_type mem_type,
- DAT_REGION_DESCRIPTION region_desc,
- u64 length,
- DAT_PZ_HANDLE pz_handle,
- enum dat_mem_priv_flags mem_priv)
+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,
+ enum dat_mem_priv_flags mem_priv)
{
- DAPL_LMR *lmr;
+ struct dapl_lmr *lmr;
/* Allocate LMR */
lmr = kmalloc(sizeof *lmr, GFP_ATOMIC);
@@ -82,9 +80,10 @@ DAPL_LMR *dapl_lmr_alloc(DAPL_IA * ia,
return lmr;
}
-void dapl_lmr_dealloc(DAPL_LMR * lmr)
+void dapl_lmr_dealloc(struct dapl_lmr *lmr)
{
- lmr->header.magic = DAPL_MAGIC_INVALID; /* reset magic to prevent reuse */
+ /* reset magic to prevent reuse */
+ lmr->header.magic = DAPL_MAGIC_INVALID;
dapl_ia_unlink_lmr(lmr->header.owner_ia, lmr);
/* no need to destroy lmr->header.lock */
Index: linux-kernel-resolv/dat-provider/dapl_openib_dto.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_openib_dto.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_openib_dto.h (working copy)
@@ -49,7 +49,8 @@
*
* Provider specific Post RECV function
*/
-static inline u32 dapl_ib_post_recv(DAPL_EP *ep_ptr, DAPL_COOKIE *cookie,
+static inline u32 dapl_ib_post_recv(struct dapl_ep *ep_ptr,
+ struct dapl_cookie *cookie,
int num_segments,
struct dat_lmr_triplet *local_iov)
{
@@ -98,8 +99,9 @@ static inline u32 dapl_ib_post_recv(DAPL
*
* Provider specific Post SEND function
*/
-static inline u32 dapl_ib_post_send(DAPL_EP *ep_ptr, enum ib_wr_opcode op_type,
- DAPL_COOKIE *cookie,
+static inline u32 dapl_ib_post_send(struct dapl_ep *ep_ptr,
+ enum ib_wr_opcode op_type,
+ struct dapl_cookie *cookie,
int num_segments,
struct dat_lmr_triplet *local_iov,
const struct dat_rmr_triplet *remote_iov,
Index: linux-kernel-resolv/dat-provider/dapl_hca_util.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_hca_util.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_hca_util.c (working copy)
@@ -56,9 +56,9 @@
* none
*
*/
-DAPL_HCA *dapl_hca_alloc(char *name, struct ib_device *device, u8 port)
+struct dapl_hca *dapl_hca_alloc(char *name, struct ib_device *device, u8 port)
{
- DAPL_HCA *hca_ptr;
+ struct dapl_hca *hca_ptr;
hca_ptr = kmalloc(sizeof *hca_ptr, GFP_ATOMIC);
if (hca_ptr) {
@@ -101,7 +101,7 @@ DAPL_HCA *dapl_hca_alloc(char *name, str
* none
*
*/
-void dapl_hca_free(DAPL_HCA * hca_ptr)
+void dapl_hca_free(struct dapl_hca *hca_ptr)
{
(void)dapl_hash_free(hca_ptr->lmr_hash_table);
kfree(hca_ptr->name);
@@ -124,7 +124,7 @@ void dapl_hca_free(DAPL_HCA * hca_ptr)
* none
*
*/
-void dapl_hca_link_ia(DAPL_HCA * hca_ptr, DAPL_IA * ia_ptr)
+void dapl_hca_link_ia(struct dapl_hca *hca_ptr, struct dapl_ia *ia_ptr)
{
spin_lock_irqsave(&hca_ptr->lock, hca_ptr->flags);
dapl_llist_add_head(&hca_ptr->ia_list_head,
@@ -148,7 +148,7 @@ void dapl_hca_link_ia(DAPL_HCA * hca_ptr
* none
*
*/
-void dapl_hca_unlink_ia(DAPL_HCA * hca_ptr, DAPL_IA * ia_ptr)
+void dapl_hca_unlink_ia(struct dapl_hca *hca_ptr, struct dapl_ia *ia_ptr)
{
spin_lock_irqsave(&hca_ptr->lock, hca_ptr->flags);
/*
Index: linux-kernel-resolv/dat-provider/dapl_srq_create.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_srq_create.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_srq_create.c (working copy)
@@ -68,15 +68,15 @@
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)
{
- DAPL_IA *ia_ptr;
- DAPL_SRQ *srq_ptr;
+ struct dapl_ia *ia_ptr;
+ struct dapl_srq *srq_ptr;
u32 dat_status = DAT_SUCCESS;
dapl_dbg_log(DAPL_DBG_TYPE_API,
"dapl_srq_create (%p, %p, %p, %p)\n",
ia_handle, pz_handle, srq_attr, srq_handle);
- ia_ptr = (DAPL_IA *) ia_handle;
+ ia_ptr = (struct dapl_ia *)ia_handle;
/*
* Verify parameters
Index: linux-kernel-resolv/dat-provider/dapl_evd_connection_callb.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_evd_connection_callb.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_evd_connection_callb.c (working copy)
@@ -65,8 +65,8 @@ void dapl_evd_connection_callback(struct
const void *private_data_ptr,
const void *context)
{
- DAPL_EP *ep_ptr;
- DAPL_EVD *evd_ptr;
+ struct dapl_ep *ep_ptr;
+ struct dapl_evd *evd_ptr;
int private_data_size;
u32 dat_status;
@@ -78,17 +78,15 @@ void dapl_evd_connection_callback(struct
* Determine the type of handle passed back to us in the context
* and sort out key parameters.
*/
- if (context == NULL
- || ((DAPL_HEADER *) context)->magic != DAPL_MAGIC_EP) {
+ if (context == NULL || ((struct dapl_header *) context)->magic != DAPL_MAGIC_EP)
return;
- }
/*
* Active side of the connection, context is an EP and
* PSP is irrelevant.
*/
- ep_ptr = (DAPL_EP *) context;
- evd_ptr = (DAPL_EVD *) ep_ptr->param.connect_evd_handle;
+ ep_ptr = (struct dapl_ep *)context;
+ evd_ptr = (struct dapl_evd *)ep_ptr->param.connect_evd_handle;
private_data_size = 0;
/*
Index: linux-kernel-resolv/dat-provider/dapl_srq_query.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_srq_query.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_srq_query.c (working copy)
@@ -41,7 +41,7 @@
u32 dapl_srq_query(DAT_SRQ_HANDLE srq_handle, struct dat_srq_param *srq_param)
{
- DAPL_SRQ *srq_ptr;
+ struct dapl_srq *srq_ptr;
u32 dat_status = DAT_SUCCESS;
dapl_dbg_log(DAPL_DBG_TYPE_API,
@@ -58,7 +58,7 @@ u32 dapl_srq_query(DAT_SRQ_HANDLE srq_ha
goto bail;
}
- srq_ptr = (DAPL_SRQ *) srq_handle;
+ srq_ptr = (struct dapl_srq *)srq_handle;
/*
* XXX Need to calculate available_dto_count and outstanding_dto_count
Index: linux-kernel-resolv/dat-provider/dapl_ring_buffer_util.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ring_buffer_util.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ring_buffer_util.h (working copy)
@@ -42,19 +42,19 @@
/*
* Prototypes
*/
-u32 dapl_rbuf_alloc(DAPL_RING_BUFFER *rbuf, int size);
+u32 dapl_rbuf_alloc(struct dapl_ring_buffer *rbuf, int size);
-u32 dapl_rbuf_realloc(DAPL_RING_BUFFER *rbuf, int size);
+u32 dapl_rbuf_realloc(struct dapl_ring_buffer *rbuf, int size);
-void dapl_rbuf_destroy(DAPL_RING_BUFFER * rbuf);
+void dapl_rbuf_destroy(struct dapl_ring_buffer *rbuf);
-u32 dapl_rbuf_add(DAPL_RING_BUFFER *rbuf, void *entry);
+u32 dapl_rbuf_add(struct dapl_ring_buffer *rbuf, void *entry);
-void *dapl_rbuf_remove(DAPL_RING_BUFFER * rbuf);
+void *dapl_rbuf_remove(struct dapl_ring_buffer *rbuf);
-int dapl_rbuf_count(DAPL_RING_BUFFER *rbuf);
+int dapl_rbuf_count(struct dapl_ring_buffer *rbuf);
-void dapl_rbuf_adjust(DAPL_RING_BUFFER * rbuf, unsigned long offset);
+void dapl_rbuf_adjust(struct dapl_ring_buffer *rbuf, unsigned long offset);
/*
* Simple functions
Index: linux-kernel-resolv/dat-provider/dapl_psp_create_any.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_psp_create_any.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_psp_create_any.c (working copy)
@@ -74,15 +74,15 @@ u32 dapl_psp_create_any(DAT_IA_HANDLE ia
DAT_EVD_HANDLE evd_handle, enum dat_psp_flags psp_flags,
DAT_PSP_HANDLE *psp_handle)
{
- DAPL_IA *ia_ptr;
- DAPL_SP *sp_ptr;
- DAPL_EVD *evd_ptr;
+ struct dapl_ia *ia_ptr;
+ struct dapl_sp *sp_ptr;
+ struct dapl_evd *evd_ptr;
u32 dat_status = DAT_SUCCESS;
static DAT_CONN_QUAL hint_conn_qual = 1000; /* seed value */
DAT_CONN_QUAL lcl_conn_qual;
DAT_CONN_QUAL limit_conn_qual;
- ia_ptr = (DAPL_IA *) ia_handle;
+ ia_ptr = (struct dapl_ia *)ia_handle;
if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
dat_status =
@@ -104,7 +104,7 @@ u32 dapl_psp_create_any(DAT_IA_HANDLE ia
goto bail;
}
- evd_ptr = (DAPL_EVD *) evd_handle;
+ evd_ptr = (struct dapl_evd *)evd_handle;
if (!(evd_ptr->evd_flags & DAT_EVD_CR_FLAG)) {
dat_status =
DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_CR);
@@ -136,7 +136,7 @@ u32 dapl_psp_create_any(DAT_IA_HANDLE ia
/*
* Take a reference on the EVD handle
*/
- atomic_inc(&((DAPL_EVD *) evd_handle)->evd_ref_count);
+ atomic_inc(&((struct dapl_evd *)evd_handle)->evd_ref_count);
/* Link it onto the IA */
dapl_ia_link_psp(ia_ptr, sp_ptr);
@@ -176,7 +176,7 @@ u32 dapl_psp_create_any(DAT_IA_HANDLE ia
/*
* Have a problem setting up the connection, something wrong!
*/
- atomic_dec(&((DAPL_EVD *) evd_handle)->evd_ref_count);
+ atomic_dec(&((struct dapl_evd *)evd_handle)->evd_ref_count);
sp_ptr->evd_handle = NULL;
dapl_ia_unlink_sp(ia_ptr, sp_ptr);
dapl_sp_dealloc(sp_ptr);
Index: linux-kernel-resolv/dat-provider/dapl_lmr_util.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_lmr_util.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_lmr_util.h (working copy)
@@ -39,19 +39,12 @@
#include "dapl_mr_util.h"
-/*********************************************************************
- * *
- * Function Prototypes *
- * *
- *********************************************************************/
+extern 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,
+ enum dat_mem_priv_flags mem_priv);
-extern DAPL_LMR *dapl_lmr_alloc(DAPL_IA * ia,
- enum dat_mem_type mem_type,
- DAT_REGION_DESCRIPTION region_desc,
- u64 length,
- DAT_PZ_HANDLE pz_handle,
- enum dat_mem_priv_flags mem_priv);
+extern void dapl_lmr_dealloc(struct dapl_lmr *lmr);
-extern void dapl_lmr_dealloc(DAPL_LMR * lmr);
-
-#endif /* DAPL_LMR_UTIL_H */
+#endif /* DAPL_LMR_UTIL_H */
Index: linux-kernel-resolv/dat-provider/dapl_hca_util.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_hca_util.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_hca_util.h (working copy)
@@ -39,12 +39,12 @@
#include "dapl.h"
-DAPL_HCA *dapl_hca_alloc(char *, struct ib_device *, u8 port);
+struct dapl_hca *dapl_hca_alloc(char *name, struct ib_device *device, u8 port);
-void dapl_hca_free(DAPL_HCA * hca_ptr);
+void dapl_hca_free(struct dapl_hca *hca_ptr);
-void dapl_hca_link_ia(DAPL_HCA * hca_ptr, DAPL_IA * ia_info);
+void dapl_hca_link_ia(struct dapl_hca *hca_ptr, struct dapl_ia *ia_info);
-void dapl_hca_unlink_ia(DAPL_HCA * hca_ptr, DAPL_IA * ia_info);
+void dapl_hca_unlink_ia(struct dapl_hca *hca_ptr, struct dapl_ia *ia_info);
#endif
Index: linux-kernel-resolv/dat-provider/dapl_get_consumer_context.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_get_consumer_context.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_get_consumer_context.c (working copy)
@@ -58,9 +58,9 @@
u32 dapl_get_consumer_context(DAT_HANDLE dat_handle, DAT_CONTEXT *context)
{
u32 dat_status = DAT_SUCCESS;
- DAPL_HEADER *header;
+ struct dapl_header *header;
- header = (DAPL_HEADER *) dat_handle;
+ header = (struct dapl_header *)dat_handle;
if (((header) == NULL) ||
((unsigned long)(header) & 3) ||
(header->magic != DAPL_MAGIC_IA &&
Index: linux-kernel-resolv/dat-provider/dapl_evd_resize.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_evd_resize.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_evd_resize.c (working copy)
@@ -65,8 +65,8 @@
u32 dapl_evd_resize(DAT_EVD_HANDLE evd_handle, int evd_qlen)
{
- DAPL_IA *ia_ptr;
- DAPL_EVD *evd_ptr;
+ struct dapl_ia *ia_ptr;
+ struct dapl_evd *evd_ptr;
int pend_cnt;
u32 status;
@@ -78,7 +78,7 @@ u32 dapl_evd_resize(DAT_EVD_HANDLE evd_h
goto bail;
}
- evd_ptr = (DAPL_EVD *) evd_handle;
+ evd_ptr = (struct dapl_evd *)evd_handle;
ia_ptr = evd_ptr->header.owner_ia;
if (evd_qlen == evd_ptr->qlen) {
Index: linux-kernel-resolv/dat-provider/dapl_cr_util.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_cr_util.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_cr_util.c (working copy)
@@ -37,9 +37,9 @@
/*
* Create a CR. Part of the passive side of a connection
*/
-DAPL_CR *dapl_cr_alloc(DAPL_IA * ia_ptr)
+struct dapl_cr *dapl_cr_alloc(struct dapl_ia *ia_ptr)
{
- DAPL_CR *cr_ptr;
+ struct dapl_cr *cr_ptr;
/* Allocate EP */
cr_ptr = kmalloc(sizeof *cr_ptr, GFP_ATOMIC);
@@ -67,11 +67,11 @@ DAPL_CR *dapl_cr_alloc(DAPL_IA * ia_ptr)
/*
* Free the passed in EP structure.
*/
-void dapl_cr_free(DAPL_CR * cr_ptr)
+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);
-
- cr_ptr->header.magic = DAPL_MAGIC_INVALID; /* reset magic to prevent reuse */
+ /* reset magic to prevent reuse */
+ cr_ptr->header.magic = DAPL_MAGIC_INVALID;
kfree(cr_ptr);
}
Index: linux-kernel-resolv/dat-provider/dapl_rmr_free.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_rmr_free.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_rmr_free.c (working copy)
@@ -55,7 +55,7 @@
*/
u32 dapl_rmr_free(DAT_RMR_HANDLE rmr_handle)
{
- DAPL_RMR *rmr;
+ struct dapl_rmr *rmr;
u32 dat_status = DAT_SUCCESS;
if (DAPL_BAD_HANDLE(rmr_handle, DAPL_MAGIC_RMR)) {
@@ -64,7 +64,7 @@ u32 dapl_rmr_free(DAT_RMR_HANDLE rmr_han
goto bail;
}
- rmr = (DAPL_RMR *) rmr_handle;
+ rmr = (struct dapl_rmr *)rmr_handle;
/*
* If the user did not perform an unbind op, release
@@ -77,14 +77,13 @@ u32 dapl_rmr_free(DAT_RMR_HANDLE rmr_han
dat_status = dapl_ib_mw_free(rmr);
- if (dat_status != DAT_SUCCESS) {
+ if (dat_status != DAT_SUCCESS)
goto bail;
- }
atomic_dec(&rmr->pz->pz_ref_count);
dapl_rmr_dealloc(rmr);
- bail:
+bail:
return dat_status;
}
Index: linux-kernel-resolv/dat-provider/dapl_srq_util.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_srq_util.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_srq_util.c (working copy)
@@ -54,9 +54,10 @@
* pointer to srq
*
*/
-DAPL_SRQ *dapl_srq_alloc(DAPL_IA * ia_ptr, const struct dat_srq_attr *srq_attr)
+struct dapl_srq *dapl_srq_alloc(struct dapl_ia *ia_ptr,
+ const struct dat_srq_attr *srq_attr)
{
- DAPL_SRQ *srq_ptr;
+ struct dapl_srq *srq_ptr;
/* Allocate SRQ */
srq_ptr = kmalloc(sizeof *srq_ptr, GFP_ATOMIC);
@@ -89,14 +90,15 @@ DAPL_SRQ *dapl_srq_alloc(DAPL_IA * ia_pt
srq_ptr->param.low_watermark = srq_attr->low_watermark;
/* Get a cookie buffer to track outstanding recvs */
- if (DAT_SUCCESS != dapl_cb_create(&srq_ptr->recv_buffer, (DAPL_EP *) srq_ptr, /* just saves the value */
+ if (DAT_SUCCESS != dapl_cb_create(&srq_ptr->recv_buffer,
+ (struct dapl_ep *)srq_ptr,
srq_ptr->param.max_recv_dtos)) {
dapl_srq_dealloc(srq_ptr);
srq_ptr = NULL;
goto bail;
}
- bail:
+bail:
return srq_ptr;
}
@@ -115,11 +117,12 @@ DAPL_SRQ *dapl_srq_alloc(DAPL_IA * ia_pt
* none
*
*/
-void dapl_srq_dealloc(DAPL_SRQ * srq_ptr)
+void dapl_srq_dealloc(struct dapl_srq *srq_ptr)
{
dapl_os_assert(srq_ptr->header.magic == DAPL_MAGIC_SRQ);
- srq_ptr->header.magic = DAPL_MAGIC_INVALID; /* reset magic to prevent reuse */
+ /* reset magic to prevent reuse */
+ srq_ptr->header.magic = DAPL_MAGIC_INVALID;
dapl_ia_unlink_srq(srq_ptr->header.owner_ia, srq_ptr);
dapl_cb_free(&srq_ptr->recv_buffer);
/* no need to destroy srq_ptr->header.lock */
Index: linux-kernel-resolv/dat-provider/dapl_psp_free.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_psp_free.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_psp_free.c (working copy)
@@ -60,12 +60,12 @@
*/
u32 dapl_psp_free(DAT_PSP_HANDLE psp_handle)
{
- DAPL_IA *ia_ptr;
- DAPL_SP *sp_ptr;
+ struct dapl_ia *ia_ptr;
+ struct dapl_sp *sp_ptr;
DAPL_SP_STATE save_state;
u32 dat_status = DAT_SUCCESS;
- sp_ptr = (DAPL_SP *) psp_handle;
+ sp_ptr = (struct dapl_sp *)psp_handle;
/*
* Verify handle
*/
@@ -77,7 +77,7 @@ u32 dapl_psp_free(DAT_PSP_HANDLE psp_han
goto bail;
}
- /* ia_ptr = (DAPL_IA *)sp_ptr->header.owner_ia; */
+ /* ia_ptr = (struct dapl_ia *)sp_ptr->header.owner_ia; */
ia_ptr = sp_ptr->header.owner_ia;
/*
* Remove the connection listener if it has been established
@@ -94,7 +94,7 @@ u32 dapl_psp_free(DAT_PSP_HANDLE psp_han
* free the evd_handle will be NULL
*/
if (sp_ptr->evd_handle) {
- atomic_dec(&((DAPL_EVD *) sp_ptr->evd_handle)->
+ atomic_dec(&((struct dapl_evd *)sp_ptr->evd_handle)->
evd_ref_count);
sp_ptr->evd_handle = NULL;
}
Index: linux-kernel-resolv/dat-provider/dapl_ep_free.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ep_free.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ep_free.c (working copy)
@@ -63,15 +63,15 @@
*/
u32 dapl_ep_free(DAT_EP_HANDLE ep_handle)
{
- DAPL_EP *ep_ptr;
- DAPL_IA *ia_ptr;
+ struct dapl_ep *ep_ptr;
+ struct dapl_ia *ia_ptr;
struct dat_ep_param *param;
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);
- ep_ptr = (DAPL_EP *) ep_handle;
+ ep_ptr = (struct dapl_ep *)ep_handle;
param = &ep_ptr->param;
/*
@@ -129,22 +129,21 @@ u32 dapl_ep_free(DAT_EP_HANDLE ep_handle
* is idempotent.
*/
if (param->pz_handle != NULL) {
- atomic_dec(&((DAPL_PZ *) param->pz_handle)->
- pz_ref_count);
+ atomic_dec(&((struct dapl_pz *)param->pz_handle)->pz_ref_count);
param->pz_handle = NULL;
}
if (param->recv_evd_handle != NULL) {
- atomic_dec(&((DAPL_EVD *) param->recv_evd_handle)->
+ atomic_dec(&((struct dapl_evd *)param->recv_evd_handle)->
evd_ref_count);
param->recv_evd_handle = NULL;
}
if (param->request_evd_handle != NULL) {
- atomic_dec(&((DAPL_EVD *) param->request_evd_handle)->
+ atomic_dec(&((struct dapl_evd *)param->request_evd_handle)->
evd_ref_count);
param->request_evd_handle = NULL;
}
if (param->connect_evd_handle != NULL) {
- atomic_dec(&((DAPL_EVD *) param->connect_evd_handle)->
+ atomic_dec(&((struct dapl_evd *)param->connect_evd_handle)->
evd_ref_count);
param->connect_evd_handle = NULL;
}
@@ -181,7 +180,7 @@ u32 dapl_ep_free(DAT_EP_HANDLE ep_handle
/* Free the resource */
dapl_ep_dealloc(ep_ptr);
- bail:
+bail:
return dat_status;
}
Index: linux-kernel-resolv/dat-provider/dapl_ep_get_status.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ep_get_status.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ep_get_status.c (working copy)
@@ -62,14 +62,14 @@
u32 dapl_ep_get_status(DAT_EP_HANDLE ep_handle, enum dat_ep_state *ep_state,
boolean_t *in_dto_idle, boolean_t *out_dto_idle)
{
- DAPL_EP *ep_ptr;
+ struct dapl_ep *ep_ptr;
u32 dat_status = DAT_SUCCESS;
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_ptr = (DAPL_EP *) ep_handle;
+ ep_ptr = (struct dapl_ep *)ep_handle;
/*
* Verify parameter & state
Index: linux-kernel-resolv/dat-provider/dapl_cr_util.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_cr_util.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_cr_util.h (working copy)
@@ -36,12 +36,12 @@
#include "dapl.h"
-DAPL_CR *dapl_cr_alloc(DAPL_IA * ia_ptr);
+struct dapl_cr *dapl_cr_alloc(struct dapl_ia *ia_ptr);
-void dapl_cr_free(DAPL_CR * cr_ptr);
+void dapl_cr_free(struct dapl_cr *cr_ptr);
void dapl_cr_callback(struct dapl_cm_id *ib_cm_handle,
const enum dat_event_number event,
const void *instant_data_p, const void *context);
-#endif /* DAPL_CR_UTIL_H */
+#endif /* DAPL_CR_UTIL_H */
Index: linux-kernel-resolv/dat-provider/dapl_srq_util.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_srq_util.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_srq_util.h (working copy)
@@ -39,11 +39,9 @@
#include "dapl.h"
-/* function prototypes */
+extern struct dapl_srq *dapl_srq_alloc(struct dapl_ia *ia,
+ const struct dat_srq_attr *srq_attr);
-extern DAPL_SRQ *dapl_srq_alloc(DAPL_IA * ia,
- const struct dat_srq_attr *srq_attr);
+extern void dapl_srq_dealloc(struct dapl_srq *srq_ptr);
-extern void dapl_srq_dealloc(DAPL_SRQ * srq_ptr);
-
-#endif /* DAPL_SRQ_UTIL_H */
+#endif /* DAPL_SRQ_UTIL_H */
Index: linux-kernel-resolv/dat-provider/dapl_evd_post_se.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_evd_post_se.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_evd_post_se.c (working copy)
@@ -61,10 +61,10 @@
u32 dapl_evd_post_se(DAT_EVD_HANDLE evd_handle, const struct dat_event *event)
{
- DAPL_EVD *evd_ptr;
+ struct dapl_evd *evd_ptr;
u32 dat_status = DAT_SUCCESS;
- evd_ptr = (DAPL_EVD *) evd_handle;
+ evd_ptr = (struct dapl_evd *)evd_handle;
if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) {
dat_status = DAT_ERROR(DAT_INVALID_HANDLE, 0);
Index: linux-kernel-resolv/dat-provider/dapl_set_consumer_context.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_set_consumer_context.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_set_consumer_context.c (working copy)
@@ -59,9 +59,9 @@
u32 dapl_set_consumer_context(DAT_HANDLE dat_handle, DAT_CONTEXT context)
{
u32 dat_status = DAT_SUCCESS;
- DAPL_HEADER *header;
+ struct dapl_header *header;
- header = (DAPL_HEADER *) dat_handle;
+ header = (struct dapl_header *)dat_handle;
if (((header) == NULL) ||
((unsigned long)(header) & 3) ||
(header->magic != DAPL_MAGIC_IA &&
Index: linux-kernel-resolv/dat-provider/dapl_mr_util.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_mr_util.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_mr_util.c (working copy)
@@ -58,13 +58,13 @@
u64 dapl_mr_get_address(DAT_REGION_DESCRIPTION desc, enum dat_mem_type type)
{
- DAPL_LMR *lmr;
+ struct dapl_lmr *lmr;
switch (type) {
case DAT_MEM_TYPE_VIRTUAL:
return (u64) (unsigned long) desc.for_va;
case DAT_MEM_TYPE_LMR:
- lmr = (DAPL_LMR *) desc.for_lmr_handle;
+ lmr = (struct dapl_lmr *)desc.for_lmr_handle;
/* Since this function is recoursive we cannot inline it */
return dapl_mr_get_address(lmr->param.region_desc,
Index: linux-kernel-resolv/dat-provider/dapl_pz_create.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_pz_create.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_pz_create.c (working copy)
@@ -57,8 +57,8 @@
*/
u32 dapl_pz_create(DAT_IA_HANDLE ia_handle, DAT_PZ_HANDLE *pz_handle)
{
- DAPL_IA *ia;
- DAPL_PZ *pz;
+ struct dapl_ia *ia;
+ struct dapl_pz *pz;
u32 dat_status = DAT_SUCCESS;
dapl_dbg_log(DAPL_DBG_TYPE_API,
@@ -75,7 +75,7 @@ u32 dapl_pz_create(DAT_IA_HANDLE ia_hand
goto bail;
}
- ia = (DAPL_IA *) ia_handle;
+ ia = (struct dapl_ia *)ia_handle;
pz = dapl_pz_alloc(ia);
if (NULL == pz) {
Index: linux-kernel-resolv/dat-provider/dapl_ia_query.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ia_query.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ia_query.c (working copy)
@@ -62,7 +62,7 @@ u32 dapl_ia_query(DAT_IA_HANDLE ia_handl
struct dat_ia_attr *ia_attr,
struct dat_provider_attr *provider_attr)
{
- DAPL_IA *ia_ptr;
+ struct dapl_ia *ia_ptr;
u32 dat_status = DAT_SUCCESS;
struct evd_merge_type {
boolean_t array[6][6];
@@ -78,7 +78,7 @@ u32 dapl_ia_query(DAT_IA_HANDLE ia_handl
ia_attr,
provider_attr);
- ia_ptr = (DAPL_IA *) ia_handle;
+ ia_ptr = (struct dapl_ia *)ia_handle;
if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
dat_status =
Index: linux-kernel-resolv/dat-provider/dapl_pz_query.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_pz_query.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_pz_query.c (working copy)
@@ -38,7 +38,7 @@
u32 dapl_pz_query(DAT_PZ_HANDLE pz_handle, struct dat_pz_param *pz_param)
{
- DAPL_PZ *pz;
+ struct dapl_pz *pz;
u32 status;
dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_pz_query (%p, %x, %p)\n",
@@ -53,7 +53,7 @@ u32 dapl_pz_query(DAT_PZ_HANDLE pz_handl
goto bail;
}
- pz = (DAPL_PZ *) pz_handle;
+ pz = (struct dapl_pz *)pz_handle;
pz_param->ia_handle = (DAT_IA_HANDLE) pz->header.owner_ia;
status = DAT_SUCCESS;
Index: linux-kernel-resolv/dat-provider/dapl_evd_free.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_evd_free.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_evd_free.c (working copy)
@@ -41,13 +41,13 @@
*/
u32 dapl_evd_free(DAT_EVD_HANDLE evd_handle)
{
- DAPL_EVD *evd_ptr;
- DAPL_CNO *cno_ptr;
+ struct dapl_evd *evd_ptr;
+ struct dapl_cno *cno_ptr;
u32 dat_status = DAT_SUCCESS;
dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_evd_free (%p)\n", evd_handle);
- evd_ptr = (DAPL_EVD *) evd_handle;
+ evd_ptr = (struct dapl_evd *)evd_handle;
if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) {
dat_status = DAT_ERROR(DAT_INVALID_HANDLE, 0);
@@ -72,10 +72,10 @@ u32 dapl_evd_free(DAT_EVD_HANDLE evd_han
dapl_ia_link_evd(evd_ptr->header.owner_ia, evd_ptr);
}
- if (cno_ptr != NULL)
- dapl_cno_dealloc (cno_ptr);
+ if (cno_ptr)
+ dapl_cno_dealloc(cno_ptr);
- bail:
+bail:
dapl_dbg_log(DAPL_DBG_TYPE_RTN,
"dapl_evd_free () returns 0x%x\n", dat_status);
Index: linux-kernel-resolv/dat-provider/dapl_lmr_query.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_lmr_query.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_lmr_query.c (working copy)
@@ -38,7 +38,7 @@
u32 dapl_lmr_query(DAT_LMR_HANDLE lmr_handle, struct dat_lmr_param *lmr_param)
{
- DAPL_LMR *lmr;
+ struct dapl_lmr *lmr;
u32 dat_status;
dapl_dbg_log(DAPL_DBG_TYPE_API,
@@ -56,10 +56,10 @@ u32 dapl_lmr_query(DAT_LMR_HANDLE lmr_ha
}
dat_status = DAT_SUCCESS;
- lmr = (DAPL_LMR *) lmr_handle;
+ lmr = (struct dapl_lmr *)lmr_handle;
memcpy(lmr_param, &lmr->param, sizeof *lmr_param);
- bail:
+bail:
return dat_status;
}
Index: linux-kernel-resolv/dat-provider/dapl_rmr_query.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_rmr_query.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_rmr_query.c (working copy)
@@ -40,7 +40,7 @@
u32 dapl_rmr_query(DAT_RMR_HANDLE rmr_handle, struct dat_rmr_param *rmr_param)
{
- DAPL_RMR *rmr;
+ struct dapl_rmr *rmr;
u32 dat_status = DAT_SUCCESS;
if (DAPL_BAD_HANDLE(rmr_handle, DAPL_MAGIC_RMR)) {
@@ -53,10 +53,10 @@ u32 dapl_rmr_query(DAT_RMR_HANDLE rmr_ha
goto bail;
}
- rmr = (DAPL_RMR *) rmr_handle;
+ rmr = (struct dapl_rmr *)rmr_handle;
memcpy(rmr_param, &rmr->param, sizeof *rmr_param);
- bail:
+bail:
return dat_status;
}
Index: linux-kernel-resolv/dat-provider/dapl_evd_modify_upcall.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_evd_modify_upcall.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_evd_modify_upcall.c (working copy)
@@ -47,14 +47,14 @@ u32 dapl_evd_modify_upcall(DAT_EVD_HANDL
enum dat_upcall_policy upcall_policy, /* ignore */
const struct dat_upcall_object *upcall)
{
- DAPL_EVD *evd_ptr;
- DAPL_CNO *cno_ptr;
+ struct dapl_evd *evd_ptr;
+ struct dapl_cno *cno_ptr;
u32 dat_status = DAT_SUCCESS;
dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_modify_upcall (%p)\n",
evd_handle);
- evd_ptr = (DAPL_EVD *) evd_handle;
+ evd_ptr = (struct dapl_evd *)evd_handle;
cno_ptr = evd_ptr->cno_ptr;
if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) {
@@ -62,12 +62,11 @@ u32 dapl_evd_modify_upcall(DAT_EVD_HANDL
goto bail;
}
- if (cno_ptr != NULL)
- {
+ if (cno_ptr != NULL) {
cno_ptr->cno_upcall_policy = upcall_policy;
cno_ptr->cno_upcall = *upcall;
}
- bail:
+bail:
return dat_status;
}
Index: linux-kernel-resolv/dat-provider/dapl_ia_util.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ia_util.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ia_util.c (working copy)
@@ -58,9 +58,10 @@
* none
*
*/
-DAPL_IA *dapl_ia_alloc(struct dat_provider *provider, DAPL_HCA * hca_ptr)
+struct dapl_ia *dapl_ia_alloc(struct dat_provider *provider,
+ struct dapl_hca *hca_ptr)
{
- DAPL_IA *ia_ptr;
+ struct dapl_ia *ia_ptr;
/* Allocate IA */
ia_ptr = kmalloc(sizeof *ia_ptr, GFP_ATOMIC);
@@ -106,17 +107,17 @@ DAPL_IA *dapl_ia_alloc(struct dat_provid
* Performs an abrupt close of the IA
*/
-u32 dapl_ia_abrupt_close(DAPL_IA *ia_ptr)
+u32 dapl_ia_abrupt_close(struct dapl_ia *ia_ptr)
{
u32 dat_status = DAT_SUCCESS;
- DAPL_EP *ep_ptr, *next_ep_ptr;
- DAPL_LMR *lmr_ptr, *next_lmr_ptr;
- DAPL_RMR *rmr_ptr, *next_rmr_ptr;
- DAPL_PZ *pz_ptr, *next_pz_ptr;
- DAPL_EVD *evd_ptr, *next_evd_ptr;
- DAPL_SP *sp_ptr, *next_sp_ptr; /* for PSP and RSP queues */
- DAPL_CR *cr_ptr, *next_cr_ptr;
- DAPL_HCA *hca_ptr;
+ struct dapl_ep *ep_ptr, *next_ep_ptr;
+ struct dapl_lmr *lmr_ptr, *next_lmr_ptr;
+ struct dapl_rmr *rmr_ptr, *next_rmr_ptr;
+ struct dapl_pz *pz_ptr, *next_pz_ptr;
+ struct dapl_evd *evd_ptr, *next_evd_ptr;
+ struct dapl_sp *sp_ptr, *next_sp_ptr; /* for PSP and RSP queues */
+ struct dapl_cr *cr_ptr, *next_cr_ptr;
+ struct dapl_hca *hca_ptr;
/*
* clear all the data structures associated with the IA.
@@ -135,11 +136,10 @@ u32 dapl_ia_abrupt_close(DAPL_IA *ia_ptr
&rmr_ptr->header.
ia_list_entry);
dat_status = dapl_rmr_free(rmr_ptr);
- if (dat_status != DAT_SUCCESS) {
+ if (dat_status != DAT_SUCCESS)
dapl_dbg_log(DAPL_DBG_TYPE_WARN,
"ia_close(ABRUPT): rmr_free(%p) returns %x\n",
rmr_ptr, dat_status);
- }
rmr_ptr = next_rmr_ptr;
}
@@ -150,11 +150,10 @@ u32 dapl_ia_abrupt_close(DAPL_IA *ia_ptr
&sp_ptr->header.
ia_list_entry);
dat_status = dapl_rsp_free(sp_ptr);
- if (dat_status != DAT_SUCCESS) {
+ if (dat_status != DAT_SUCCESS)
dapl_dbg_log(DAPL_DBG_TYPE_WARN,
"ia_close(ABRUPT): rsp_free(%p) returns %x\n",
sp_ptr, dat_status);
- }
sp_ptr = next_sp_ptr;
}
@@ -176,21 +175,19 @@ u32 dapl_ia_abrupt_close(DAPL_IA *ia_ptr
DAT_EP_STATE_DISCONNECT_PENDING) {
dat_status =
dapl_ep_disconnect(ep_ptr, DAT_CLOSE_ABRUPT_FLAG);
- if (dat_status != DAT_SUCCESS) {
+ 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_handle);
dat_status = dapl_ep_free(ep_ptr);
- if (dat_status != DAT_SUCCESS) {
+ if (dat_status != DAT_SUCCESS)
dapl_dbg_log(DAPL_DBG_TYPE_WARN,
"ia_close(ABRUPT): ep_free(%p) returns %x\n",
ep_ptr, dat_status);
- }
ep_ptr = next_ep_ptr;
}
@@ -201,11 +198,10 @@ u32 dapl_ia_abrupt_close(DAPL_IA *ia_ptr
&lmr_ptr->header.
ia_list_entry);
dat_status = dapl_lmr_free(lmr_ptr);
- if (dat_status != DAT_SUCCESS) {
+ if (dat_status != DAT_SUCCESS)
dapl_dbg_log(DAPL_DBG_TYPE_WARN,
"ia_close(ABRUPT): lmr_free(%p) returns %x\n",
lmr_ptr, dat_status);
- }
lmr_ptr = next_lmr_ptr;
}
@@ -217,11 +213,10 @@ u32 dapl_ia_abrupt_close(DAPL_IA *ia_ptr
* should be no competing threads after this.
*/
dat_status = dapl_ib_remove_conn_listener(ia_ptr, sp_ptr);
- if (dat_status != DAT_SUCCESS) {
+ if (dat_status != DAT_SUCCESS)
dapl_dbg_log(DAPL_DBG_TYPE_WARN,
"ia_close(ABRUPT): psp cannot remove listener, returns %x\n",
dat_status);
- }
next_sp_ptr = dapl_llist_next_entry(&ia_ptr->psp_list_head,
&sp_ptr->header.
@@ -245,11 +240,10 @@ u32 dapl_ia_abrupt_close(DAPL_IA *ia_ptr
}
dat_status = dapl_psp_free(sp_ptr);
- if (dat_status != DAT_SUCCESS) {
+ if (dat_status != DAT_SUCCESS)
dapl_dbg_log(DAPL_DBG_TYPE_WARN,
"ia_close(ABRUPT): psp_free(%p) returns %x\n",
sp_ptr, dat_status);
- }
sp_ptr = next_sp_ptr;
}
@@ -261,11 +255,10 @@ u32 dapl_ia_abrupt_close(DAPL_IA *ia_ptr
&pz_ptr->header.
ia_list_entry);
dat_status = dapl_pz_free(pz_ptr);
- if (dat_status != DAT_SUCCESS) {
+ if (dat_status != DAT_SUCCESS)
dapl_dbg_log(DAPL_DBG_TYPE_WARN,
"ia_close(ABRUPT): pz_free(%p) returns %x\n",
pz_ptr, dat_status);
- }
pz_ptr = next_pz_ptr;
}
@@ -284,11 +277,10 @@ u32 dapl_ia_abrupt_close(DAPL_IA *ia_ptr
if (evd_ptr != ia_ptr->async_error_evd) {
/* it isn't the async EVD; delete it. */
dat_status = dapl_evd_free(evd_ptr);
- if (dat_status != DAT_SUCCESS) {
+ if (dat_status != DAT_SUCCESS)
dapl_dbg_log(DAPL_DBG_TYPE_WARN,
"ia_close(ABRUPT): evd_free(%p) returns %x\n",
evd_ptr, dat_status);
- }
}
evd_ptr = next_evd_ptr;
}
@@ -305,11 +297,10 @@ u32 dapl_ia_abrupt_close(DAPL_IA *ia_ptr
atomic_dec(&ia_ptr->async_error_evd->evd_ref_count);
dat_status = dapl_evd_free(ia_ptr->async_error_evd);
- if (DAT_SUCCESS != dat_status) {
+ if (DAT_SUCCESS != dat_status)
dapl_dbg_log(DAPL_DBG_TYPE_WARN,
"ia_close(ABRUPT): evd_free(%p) returns %x\n",
ia_ptr->async_error_evd, dat_status);
- }
ia_ptr->async_error_evd = NULL;
}
@@ -337,13 +328,13 @@ u32 dapl_ia_abrupt_close(DAPL_IA *ia_ptr
*
*/
-u32 dapl_ia_graceful_close(DAPL_IA *ia_ptr)
+u32 dapl_ia_graceful_close(struct dapl_ia *ia_ptr)
{
u32 dat_status = DAT_SUCCESS;
u32 cur_dat_status;
- DAPL_EVD *evd_ptr;
- DAPL_LLIST_ENTRY *entry;
- DAPL_HCA *hca_ptr;
+ struct dapl_evd *evd_ptr;
+ struct dapl_llist_entry *entry;
+ struct dapl_hca *hca_ptr;
if (!dapl_llist_is_empty(&ia_ptr->rmr_list_head) ||
!dapl_llist_is_empty(&ia_ptr->rsp_list_head) ||
@@ -416,14 +407,12 @@ u32 dapl_ia_graceful_close(DAPL_IA *ia_p
if (ia_ptr->async_error_evd &&
(TRUE == ia_ptr->cleanup_async_error_evd)) {
cur_dat_status = dapl_ia_teardown_callbacks(ia_ptr);
- if (DAT_SUCCESS != cur_dat_status) {
+ 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);
- if (DAT_SUCCESS != cur_dat_status) {
+ if (DAT_SUCCESS != cur_dat_status)
dat_status = cur_dat_status;
- }
ia_ptr->async_error_evd = NULL;
}
@@ -432,14 +421,14 @@ u32 dapl_ia_graceful_close(DAPL_IA *ia_p
dapl_ia_free(ia_ptr);
- bail:
+bail:
return dat_status;
}
/*
* free an IA INFO struct
*/
-void dapl_ia_free(DAPL_IA * ia_ptr)
+void dapl_ia_free(struct dapl_ia *ia_ptr)
{
dapl_os_assert(ia_ptr->header.magic == DAPL_MAGIC_IA);
@@ -464,7 +453,7 @@ void dapl_ia_free(DAPL_IA * ia_ptr)
/*
* Add an ep to the IA structure
*/
-void dapl_ia_link_ep(DAPL_IA * ia_ptr, DAPL_EP * ep_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);
dapl_llist_add_head(&ia_ptr->ep_list_head,
@@ -475,7 +464,7 @@ void dapl_ia_link_ep(DAPL_IA * ia_ptr, D
/*
* Remove an ep from the ia info structure
*/
-void dapl_ia_unlink_ep(DAPL_IA * ia_ptr, DAPL_EP * ep_ptr)
+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);
dapl_llist_remove_entry(&ia_ptr->ep_list_head,
@@ -486,7 +475,7 @@ void dapl_ia_unlink_ep(DAPL_IA * ia_ptr,
/*
* Add an srq to the IA structure
*/
-void dapl_ia_link_srq(DAPL_IA * ia_ptr, DAPL_SRQ * srq_ptr)
+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);
dapl_llist_add_head(&ia_ptr->srq_list_head,
@@ -497,7 +486,7 @@ void dapl_ia_link_srq(DAPL_IA * ia_ptr,
/*
* Remove an srq from the ia info structure
*/
-void dapl_ia_unlink_srq(DAPL_IA * ia_ptr, DAPL_SRQ * srq_ptr)
+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);
dapl_llist_remove_entry(&ia_ptr->srq_list_head,
@@ -508,7 +497,7 @@ void dapl_ia_unlink_srq(DAPL_IA * ia_ptr
/*
* Add an lmr to the IA structure
*/
-void dapl_ia_link_lmr(DAPL_IA * ia_ptr, DAPL_LMR * lmr_ptr)
+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);
dapl_llist_add_head(&ia_ptr->lmr_list_head,
@@ -519,7 +508,7 @@ void dapl_ia_link_lmr(DAPL_IA * ia_ptr,
/*
* Remove an lmr from the ia info structure
*/
-void dapl_ia_unlink_lmr(DAPL_IA * ia_ptr, DAPL_LMR * lmr_ptr)
+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);
dapl_llist_remove_entry(&ia_ptr->lmr_list_head,
@@ -530,7 +519,7 @@ void dapl_ia_unlink_lmr(DAPL_IA * ia_ptr
/*
* Add an rmr to the IA structure
*/
-void dapl_ia_link_rmr(DAPL_IA * ia_ptr, DAPL_RMR * rmr_ptr)
+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);
dapl_llist_add_head(&ia_ptr->rmr_list_head,
@@ -541,7 +530,7 @@ void dapl_ia_link_rmr(DAPL_IA * ia_ptr,
/*
* Remove an rmr from the ia info structure
*/
-void dapl_ia_unlink_rmr(DAPL_IA * ia_ptr, DAPL_RMR * rmr_ptr)
+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);
dapl_llist_remove_entry(&ia_ptr->rmr_list_head,
@@ -552,7 +541,7 @@ void dapl_ia_unlink_rmr(DAPL_IA * ia_ptr
/*
* Add an pz to the IA structure
*/
-void dapl_ia_link_pz(DAPL_IA * ia_ptr, DAPL_PZ * pz_ptr)
+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);
dapl_llist_add_head(&ia_ptr->pz_list_head,
@@ -563,7 +552,7 @@ void dapl_ia_link_pz(DAPL_IA * ia_ptr, D
/*
* Remove an pz from the ia info structure
*/
-void dapl_ia_unlink_pz(DAPL_IA * ia_ptr, DAPL_PZ * pz_ptr)
+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);
dapl_llist_remove_entry(&ia_ptr->pz_list_head,
@@ -574,7 +563,7 @@ void dapl_ia_unlink_pz(DAPL_IA * ia_ptr,
/*
* Add an evd to the IA structure
*/
-void dapl_ia_link_evd(DAPL_IA * ia_ptr, DAPL_EVD * evd_ptr)
+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);
dapl_llist_add_head(&ia_ptr->evd_list_head,
@@ -585,7 +574,7 @@ void dapl_ia_link_evd(DAPL_IA * ia_ptr,
/*
* Remove an evd from the ia info structure
*/
-void dapl_ia_unlink_evd(DAPL_IA * ia_ptr, DAPL_EVD * evd_ptr)
+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);
dapl_llist_remove_entry(&ia_ptr->evd_list_head,
@@ -596,7 +585,7 @@ void dapl_ia_unlink_evd(DAPL_IA * ia_ptr
/*
* Add an psp to the IA structure
*/
-void dapl_ia_link_psp(DAPL_IA * ia_ptr, DAPL_SP * sp_ptr)
+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);
dapl_llist_add_head(&ia_ptr->psp_list_head,
@@ -607,9 +596,9 @@ void dapl_ia_link_psp(DAPL_IA * ia_ptr,
/*
* Remove an sp from the appropriate ia rsp or psp queue
*/
-void dapl_ia_unlink_sp(DAPL_IA * ia_ptr, DAPL_SP * sp_ptr)
+void dapl_ia_unlink_sp(struct dapl_ia *ia_ptr, struct dapl_sp *sp_ptr)
{
- DAPL_LLIST_HEAD *list_head;
+ struct dapl_llist_entry **list_head;
if (sp_ptr->header.handle_type == DAT_HANDLE_TYPE_PSP) {
list_head = &ia_ptr->psp_list_head;
@@ -640,17 +629,16 @@ void dapl_ia_unlink_sp(DAPL_IA * ia_ptr,
* none
*
*/
-DAPL_SP *dapl_ia_sp_search(DAPL_IA * ia_ptr,
- DAT_CONN_QUAL conn_qual, boolean_t is_psp)
+struct dapl_sp *dapl_ia_sp_search(struct dapl_ia *ia_ptr,
+ DAT_CONN_QUAL conn_qual, boolean_t is_psp)
{
- DAPL_SP *sp_ptr;
- DAPL_LLIST_HEAD *list_head;
+ struct dapl_sp *sp_ptr;
+ struct dapl_llist_entry **list_head;
- if (is_psp) {
+ if (is_psp)
list_head = &ia_ptr->psp_list_head;
- } else {
+ else
list_head = &ia_ptr->rsp_list_head;
- }
spin_lock_irqsave(&ia_ptr->header.lock, ia_ptr->header.flags);
@@ -686,7 +674,7 @@ DAPL_SP *dapl_ia_sp_search(DAPL_IA * ia_
* none
*
*/
-void dapl_ia_link_rsp(DAPL_IA * ia_ptr, DAPL_SP * sp_ptr)
+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);
dapl_llist_add_head(&ia_ptr->rsp_list_head,
@@ -694,7 +682,8 @@ void dapl_ia_link_rsp(DAPL_IA * ia_ptr,
spin_unlock_irqrestore(&ia_ptr->header.lock, ia_ptr->header.flags);
}
-u32 dapl_ia_setup_callbacks(DAPL_IA * ia_ptr, DAPL_EVD * async_evd_ptr)
+u32 dapl_ia_setup_callbacks(struct dapl_ia *ia_ptr,
+ struct dapl_evd *async_evd_ptr)
{
u32 dat_status = DAT_SUCCESS;
@@ -717,7 +706,7 @@ u32 dapl_ia_setup_callbacks(DAPL_IA * ia
return dat_status;
}
-u32 dapl_ia_teardown_callbacks(DAPL_IA * ia_ptr)
+u32 dapl_ia_teardown_callbacks(struct dapl_ia *ia_ptr)
{
u32 dat_status = DAT_SUCCESS;
Index: linux-kernel-resolv/dat-provider/dapl_pz_util.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_pz_util.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_pz_util.c (working copy)
@@ -52,13 +52,13 @@
* none
*
*/
-DAPL_PZ *dapl_pz_alloc(DAPL_IA * ia)
+struct dapl_pz *dapl_pz_alloc(struct dapl_ia *ia)
{
- DAPL_PZ *pz;
+ struct dapl_pz *pz;
/* Allocate PZ */
pz = kmalloc(sizeof *pz, GFP_ATOMIC);
- if (!pz)
+ if (!pz)
return NULL;
/* zero the structure */
@@ -100,9 +100,10 @@ DAPL_PZ *dapl_pz_alloc(DAPL_IA * ia)
* none
*
*/
-void dapl_pz_dealloc(DAPL_PZ * pz)
+void dapl_pz_dealloc(struct dapl_pz *pz)
{
- pz->header.magic = DAPL_MAGIC_INVALID; /* reset magic to prevent reuse */
+ /* reset magic to prevent reuse */
+ pz->header.magic = DAPL_MAGIC_INVALID;
dapl_ia_unlink_pz(pz->header.owner_ia, pz);
/* no need to destroy pz->header.lock */
Index: linux-kernel-resolv/dat-provider/dapl_ep_query.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ep_query.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ep_query.c (working copy)
@@ -59,14 +59,14 @@
*/
u32 dapl_ep_query(DAT_EP_HANDLE ep_handle, struct dat_ep_param *ep_param)
{
- DAPL_EP *ep_ptr;
+ 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_ptr = (DAPL_EP *) ep_handle;
+ ep_ptr = (struct dapl_ep *)ep_handle;
/*
* Verify parameter & state
Index: linux-kernel-resolv/dat-provider/dapl_pz_util.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_pz_util.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_pz_util.h (working copy)
@@ -39,8 +39,8 @@
#include "dapl.h"
-extern DAPL_PZ *dapl_pz_alloc(DAPL_IA * ia);
+extern struct dapl_pz *dapl_pz_alloc(struct dapl_ia *ia);
-extern void dapl_pz_dealloc(DAPL_PZ * pz);
+extern void dapl_pz_dealloc(struct dapl_pz *pz);
-#endif /* DAPL_PZ_UTIL_H */
+#endif /* DAPL_PZ_UTIL_H */
Index: linux-kernel-resolv/dat-provider/dapl_evd_dequeue.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_evd_dequeue.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_evd_dequeue.c (working copy)
@@ -64,14 +64,14 @@
u32 dapl_evd_dequeue(DAT_EVD_HANDLE evd_handle, struct dat_event *event)
{
- DAPL_EVD *evd_ptr;
+ struct dapl_evd *evd_ptr;
struct dat_event *local_event;
u32 dat_status = DAT_SUCCESS;
dapl_dbg_log(DAPL_DBG_TYPE_API,
"dapl_evd_dequeue (%p, %p)\n", evd_handle, event);
- evd_ptr = (DAPL_EVD *) evd_handle;
+ evd_ptr = (struct dapl_evd *)evd_handle;
if (DAPL_BAD_HANDLE(evd_handle, DAPL_MAGIC_EVD)) {
dat_status = DAT_ERROR(DAT_INVALID_HANDLE, 0);
Index: linux-kernel-resolv/dat-provider/dapl_openib_cm.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_openib_cm.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_openib_cm.c (working copy)
@@ -399,12 +399,12 @@ u32 dapl_ib_connect(DAT_EP_HANDLE ep_han
DAT_CONN_QUAL remote_conn_qual,
int private_data_size, void *private_data)
{
- DAPL_IA *ia_ptr;
- DAPL_EP *ep_ptr;
+ struct dapl_ia *ia_ptr;
+ struct dapl_ep *ep_ptr;
struct dapl_cm_id *conn;
int status;
- ep_ptr = (DAPL_EP *)ep_handle;
+ ep_ptr = (struct dapl_ep *)ep_handle;
if (ep_ptr->qp_handle == NULL) {
printk(KERN_ERR "dapl_ib_connect: qp handle invalid\n");
return DAT_INTERNAL_ERROR;
@@ -486,7 +486,7 @@ u32 dapl_ib_connect(DAT_EP_HANDLE ep_han
* DAT_INVALID_PARAMETER
*
*/
-u32 dapl_ib_disconnect(DAPL_EP *ep_ptr, enum dat_close_flags close_flags)
+u32 dapl_ib_disconnect(struct dapl_ep *ep_ptr, enum dat_close_flags close_flags)
{
struct dapl_cm_id *conn = ep_ptr->cm_handle;
int status;
@@ -510,24 +510,24 @@ u32 dapl_ib_disconnect(DAPL_EP *ep_ptr,
return DAT_SUCCESS;
}
-/*
- * dapl_ib_disconnect_clean
- *
- * Clean up outstanding connection data. This routine is invoked
+/*
+ * dapl_ib_disconnect_clean
+ *
+ * Clean up outstanding connection data. This routine is invoked
* after the final disconnect callback has occurred.
- *
- * Input:
- * ep_ptr DAPL_EP
- * active Indicates active side of connection
- *
- * Output:
- * none
- *
- * Returns:
- * void
- *
+ *
+ * Input:
+ * ep_ptr struct dapl_ep
+ * active Indicates active side of connection
+ *
+ * Output:
+ * none
+ *
+ * Returns:
+ * void
+ *
*/
-void dapl_ib_disconnect_clean(DAPL_EP * ep_ptr, boolean_t active)
+void dapl_ib_disconnect_clean(struct dapl_ep *ep_ptr, boolean_t active)
{
int status;
@@ -566,9 +566,9 @@ void dapl_ib_disconnect_clean(DAPL_EP *
* void
*
*/
-void dapl_ib_reinit_ep(DAPL_EP * ep_ptr)
+void dapl_ib_reinit_ep(struct dapl_ep *ep_ptr)
{
- DAPL_IA *ia_ptr;
+ struct dapl_ia *ia_ptr;
int ib_status;
ia_ptr = ep_ptr->header.owner_ia;
@@ -615,7 +615,8 @@ void dapl_ib_reinit_ep(DAPL_EP * ep_ptr)
* DAT_INVALID_PARAMETER
*
*/
-u32 dapl_ib_setup_conn_listener(DAPL_IA *ia_ptr, u64 ServiceID, DAPL_SP *sp_ptr)
+u32 dapl_ib_setup_conn_listener(struct dapl_ia *ia_ptr, u64 ServiceID,
+ struct dapl_sp *sp_ptr)
{
int status;
@@ -658,7 +659,7 @@ u32 dapl_ib_setup_conn_listener(DAPL_IA
* DAT_INVALID_PARAMETER
*
*/
-u32 dapl_ib_remove_conn_listener(DAPL_IA *ia_ptr, DAPL_SP *sp_ptr)
+u32 dapl_ib_remove_conn_listener(struct dapl_ia *ia_ptr, struct dapl_sp *sp_ptr)
{
//*** This will hang if called from CM thread context...
//*** Move back to using WQ...
@@ -731,16 +732,16 @@ u32 dapl_ib_accept_connection(DAT_CR_HAN
int private_data_size,
const void *prd_ptr)
{
- DAPL_CR *cr_ptr;
- DAPL_EP *ep_ptr;
- DAPL_IA *ia_ptr;
+ struct dapl_cr *cr_ptr;
+ struct dapl_ep *ep_ptr;
+ struct dapl_ia *ia_ptr;
u32 dat_status;
int status;
struct ib_cm_rep_param passive_params;
struct dapl_cm_id *conn;
- cr_ptr = (DAPL_CR *) cr_handle;
- ep_ptr = (DAPL_EP *) ep_handle;
+ cr_ptr = (struct dapl_cr *)cr_handle;
+ ep_ptr = (struct dapl_ep *)ep_handle;
ia_ptr = ep_ptr->header.owner_ia;
conn = cr_ptr->ib_cm_handle;
@@ -833,13 +834,13 @@ static int ib_cm_get_remote_gid(struct d
u32 dapl_ib_cm_remote_addr(DAT_HANDLE dat_handle,
struct sockaddr_in6 *remote_ia_address)
{
- DAPL_IA *ia_ptr;
+ struct dapl_ia *ia_ptr;
int rc;
union ib_gid remote_gid;
- DAPL_CR *cr_ptr = (DAPL_CR *) dat_handle;
+ struct dapl_cr *cr_ptr = (struct dapl_cr *)dat_handle;
- ia_ptr = (DAPL_IA *) cr_ptr->sp_ptr->ia_handle;
+ ia_ptr = (struct dapl_ia *)cr_ptr->sp_ptr->ia_handle;
rc = ib_cm_get_remote_gid(cr_ptr->ib_cm_handle, (u8 *) & remote_gid);
if (rc < 0)
Index: linux-kernel-resolv/dat-provider/dapl_ia_util.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ia_util.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ia_util.h (working copy)
@@ -39,49 +39,51 @@
#include "dapl.h"
-DAPL_IA *dapl_ia_alloc(struct dat_provider *provider, DAPL_HCA * hca_ptr);
+struct dapl_ia *dapl_ia_alloc(struct dat_provider *provider,
+ struct dapl_hca *hca_ptr);
-u32 dapl_ia_abrupt_close(DAPL_IA *ia_ptr);
+u32 dapl_ia_abrupt_close(struct dapl_ia *ia_ptr);
-u32 dapl_ia_graceful_close(DAPL_IA *ia_ptr);
+u32 dapl_ia_graceful_close(struct dapl_ia *ia_ptr);
-void dapl_ia_free(DAPL_IA * ia_ptr);
+void dapl_ia_free(struct dapl_ia *ia_ptr);
-void dapl_ia_link_ep(DAPL_IA * ia_ptr, DAPL_EP * ep_info);
+void dapl_ia_link_ep(struct dapl_ia *ia_ptr, struct dapl_ep *ep_info);
-void dapl_ia_unlink_ep(DAPL_IA * ia_ptr, DAPL_EP * ep_info);
+void dapl_ia_unlink_ep(struct dapl_ia *ia_ptr, struct dapl_ep *ep_info);
-void dapl_ia_link_srq(DAPL_IA * ia_ptr, DAPL_SRQ * srq_ptr);
+void dapl_ia_link_srq(struct dapl_ia *ia_ptr, struct dapl_srq *srq_ptr);
-void dapl_ia_unlink_srq(DAPL_IA * ia_ptr, DAPL_SRQ * srq_ptr);
+void dapl_ia_unlink_srq(struct dapl_ia *ia_ptr, struct dapl_srq *srq_ptr);
-void dapl_ia_link_lmr(DAPL_IA * ia_ptr, DAPL_LMR * lmr_info);
+void dapl_ia_link_lmr(struct dapl_ia *ia_ptr, struct dapl_lmr *lmr_info);
-void dapl_ia_unlink_lmr(DAPL_IA * ia_ptr, DAPL_LMR * lmr_info);
+void dapl_ia_unlink_lmr(struct dapl_ia *ia_ptr, struct dapl_lmr *lmr_info);
-void dapl_ia_link_rmr(DAPL_IA * ia_ptr, DAPL_RMR * rmr_info);
+void dapl_ia_link_rmr(struct dapl_ia *ia_ptr, struct dapl_rmr *rmr_info);
-void dapl_ia_unlink_rmr(DAPL_IA * ia_ptr, DAPL_RMR * rmr_info);
+void dapl_ia_unlink_rmr(struct dapl_ia *ia_ptr, struct dapl_rmr *rmr_info);
-void dapl_ia_link_pz(DAPL_IA * ia_ptr, DAPL_PZ * pz_info);
+void dapl_ia_link_pz(struct dapl_ia *ia_ptr, struct dapl_pz *pz_info);
-void dapl_ia_unlink_pz(DAPL_IA * ia_ptr, DAPL_PZ * pz_info);
+void dapl_ia_unlink_pz(struct dapl_ia *ia_ptr, struct dapl_pz *pz_info);
-void dapl_ia_link_evd(DAPL_IA * ia_ptr, DAPL_EVD * evd_info);
+void dapl_ia_link_evd(struct dapl_ia *ia_ptr, struct dapl_evd *evd_info);
-void dapl_ia_unlink_evd(DAPL_IA * ia_ptr, DAPL_EVD * evd_info);
+void dapl_ia_unlink_evd(struct dapl_ia *ia_ptr, struct dapl_evd *evd_info);
-void dapl_ia_link_psp(DAPL_IA * ia_ptr, DAPL_SP * sp_info);
+void dapl_ia_link_psp(struct dapl_ia *ia_ptr, struct dapl_sp *sp_info);
-void dapl_ia_unlink_sp(DAPL_IA * ia_ptr, DAPL_SP * sp_info);
+void dapl_ia_unlink_sp(struct dapl_ia *ia_ptr, struct dapl_sp *sp_info);
-void dapl_ia_link_rsp(DAPL_IA * ia_ptr, DAPL_SP * sp_info);
+void dapl_ia_link_rsp(struct dapl_ia *ia_ptr, struct dapl_sp *sp_info);
-DAPL_SP *dapl_ia_sp_search(DAPL_IA * ia_ptr,
+struct dapl_sp *dapl_ia_sp_search(struct dapl_ia *ia_ptr,
DAT_CONN_QUAL conn_qual, boolean_t is_psp);
-u32 dapl_ia_setup_callbacks(DAPL_IA *ia_ptr, DAPL_EVD *async_evd_ptr);
+u32 dapl_ia_setup_callbacks(struct dapl_ia *ia_ptr,
+ struct dapl_evd *async_evd_ptr);
-u32 dapl_ia_teardown_callbacks(DAPL_IA *ia_ptr);
+u32 dapl_ia_teardown_callbacks(struct dapl_ia *ia_ptr);
#endif
Index: linux-kernel-resolv/dat-provider/dapl_rmr_bind.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_rmr_bind.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_rmr_bind.c (working copy)
@@ -46,16 +46,16 @@
* *
*********************************************************************/
-static inline u32 dapl_rmr_bind_fuse(DAPL_RMR *rmr,
+static inline u32 dapl_rmr_bind_fuse(struct dapl_rmr *rmr,
const struct dat_lmr_triplet *lmr_triplet,
enum dat_mem_priv_flags mem_priv,
- DAPL_EP *ep_ptr,
+ struct dapl_ep *ep_ptr,
DAT_RMR_COOKIE user_cookie,
enum dat_completion_flags completion_flags,
DAT_RMR_CONTEXT *rmr_context)
{
- DAPL_LMR *lmr;
- DAPL_COOKIE *cookie;
+ struct dapl_lmr *lmr;
+ struct dapl_cookie *cookie;
u32 status;
boolean_t is_signaled;
@@ -152,15 +152,16 @@ static inline u32 dapl_rmr_bind_fuse(DAP
if (NULL != rmr_context)
*rmr_context = rmr->param.rmr_context;
- bail:
+bail:
return status;
}
-static inline u32 dapl_rmr_bind_unfuse(DAPL_RMR *rmr, DAPL_EP *ep_ptr,
+static inline u32 dapl_rmr_bind_unfuse(struct dapl_rmr *rmr,
+ struct dapl_ep *ep_ptr,
DAT_RMR_COOKIE user_cookie,
enum dat_completion_flags cflags)
{
- DAPL_COOKIE *cookie;
+ struct dapl_cookie *cookie;
u32 status = DAT_SUCCESS;
boolean_t is_signaled;
@@ -232,7 +233,7 @@ static inline u32 dapl_rmr_bind_unfuse(D
rmr->ep = ep_ptr;
rmr->lmr = NULL;
- bail1:
+bail1:
return status;
}
@@ -254,8 +255,8 @@ u32 dapl_rmr_bind(DAT_RMR_HANDLE rmr_han
enum dat_completion_flags completion_flags,
DAT_RMR_CONTEXT *rmr_context)
{
- DAPL_RMR *rmr;
- DAPL_EP *ep_ptr;
+ struct dapl_rmr *rmr;
+ struct dapl_ep *ep_ptr;
if (DAPL_BAD_HANDLE(rmr_handle, DAPL_MAGIC_RMR))
return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_RMR);
@@ -263,16 +264,15 @@ u32 dapl_rmr_bind(DAT_RMR_HANDLE rmr_han
if (DAPL_BAD_HANDLE(ep_handle, DAPL_MAGIC_EP))
return DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EP);
- rmr = (DAPL_RMR *) rmr_handle;
- ep_ptr = (DAPL_EP *) ep_handle;
+ rmr = (struct dapl_rmr *)rmr_handle;
+ ep_ptr = (struct dapl_ep *)ep_handle;
/* if the rmr should be bound */
- if (0 != lmr_triplet->segment_length) {
+ if (0 != lmr_triplet->segment_length)
return dapl_rmr_bind_fuse(rmr, lmr_triplet, mem_priv, ep_ptr,
user_cookie, completion_flags,
rmr_context);
- } else { /* the rmr should be unbound */
+ else /* the rmr should be unbound */
return dapl_rmr_bind_unfuse(rmr, ep_ptr, user_cookie,
completion_flags);
- }
}
Index: linux-kernel-resolv/dat-provider/dapl_cr_reject.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_cr_reject.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_cr_reject.c (working copy)
@@ -42,11 +42,11 @@
*/
u32 dapl_cr_reject(DAT_CR_HANDLE cr_handle)
{
- DAPL_CR *cr_ptr;
- DAPL_EP *ep_ptr;
+ struct dapl_cr *cr_ptr;
+ struct dapl_ep *ep_ptr;
enum dat_ep_state entry_ep_state;
DAT_EP_HANDLE entry_ep_handle;
- DAPL_SP *sp_ptr;
+ struct dapl_sp *sp_ptr;
u32 dat_status;
dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_cr_reject (%p)\n", cr_handle);
@@ -57,16 +57,16 @@ u32 dapl_cr_reject(DAT_CR_HANDLE cr_hand
goto bail;
}
- cr_ptr = (DAPL_CR *) cr_handle;
+ cr_ptr = (struct dapl_cr *)cr_handle;
/*
* Clean up provider created EP if there is one: only if
* DAT_PSP_PROVIDER_FLAG was set on the PSP
*/
- ep_ptr = (DAPL_EP *) cr_ptr->param.local_ep_handle;
+ ep_ptr = (struct dapl_ep *)cr_ptr->param.local_ep_handle;
entry_ep_handle = cr_ptr->param.local_ep_handle;
entry_ep_state = 0;
- if (ep_ptr != NULL) {
+ 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;
@@ -87,10 +87,8 @@ u32 dapl_cr_reject(DAT_CR_HANDLE cr_hand
* RSP and user-provided EPs are in the control of the user.
*/
sp_ptr = cr_ptr->sp_ptr;
- if (ep_ptr != NULL &&
- sp_ptr->psp_flags == DAT_PSP_PROVIDER_FLAG) {
+ if (ep_ptr && sp_ptr->psp_flags == DAT_PSP_PROVIDER_FLAG)
(void)dapl_ep_free(ep_ptr);
- }
/* Remove the CR from the queue, then free it */
spin_lock_irqsave(&sp_ptr->header.lock, sp_ptr->header.flags);
@@ -101,6 +99,6 @@ u32 dapl_cr_reject(DAT_CR_HANDLE cr_hand
dapl_cr_free(cr_ptr);
}
- bail:
+bail:
return dat_status;
}
Index: linux-kernel-resolv/dat-provider/dapl_ep_reset.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ep_reset.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ep_reset.c (working copy)
@@ -63,10 +63,10 @@
*/
u32 dapl_ep_reset(DAT_EP_HANDLE ep_handle)
{
- DAPL_EP *ep_ptr;
+ struct dapl_ep *ep_ptr;
u32 dat_status = DAT_SUCCESS;
- ep_ptr = (DAPL_EP *) ep_handle;
+ ep_ptr = (struct dapl_ep *)ep_handle;
/*
* Verify parameter & state
Index: linux-kernel-resolv/dat-provider/dapl_ep_recv_query.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ep_recv_query.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ep_recv_query.c (working copy)
@@ -57,13 +57,13 @@
u32 dapl_ep_recv_query(DAT_EP_HANDLE ep_handle,
int *nbufs_allocate, int *bufs_alloc_span)
{
- DAPL_EP *ep_ptr;
+ 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_ptr = (DAPL_EP *) ep_handle;
+ ep_ptr = (struct dapl_ep *)ep_handle;
/*
* Verify parameter & state
Index: linux-kernel-resolv/dat-provider/dapl_openib_util.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_openib_util.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_openib_util.c (working copy)
@@ -159,7 +159,7 @@ static inline int dapl_ib_convert_mem_pr
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_ib_open_hca(char *name, DAPL_HCA * hca_ptr)
+u32 dapl_ib_open_hca(char *name, struct dapl_hca *hca_ptr)
{
u32 dat_ret;
@@ -196,7 +196,7 @@ u32 dapl_ib_open_hca(char *name, DAPL_HC
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_ib_close_hca(DAPL_HCA *hca_ptr)
+u32 dapl_ib_close_hca(struct dapl_hca *hca_ptr)
{
return DAT_SUCCESS;
}
@@ -219,8 +219,8 @@ u32 dapl_ib_close_hca(DAPL_HCA *hca_ptr)
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_ib_cq_alloc(DAPL_IA *ia_ptr, DAPL_EVD *evd_ptr, int *cqlen,
- ib_comp_handler callback)
+u32 dapl_ib_cq_alloc(struct dapl_ia *ia_ptr, struct dapl_evd *evd_ptr,
+ int *cqlen, ib_comp_handler callback)
{
int ib_status;
@@ -253,7 +253,7 @@ u32 dapl_ib_cq_alloc(DAPL_IA *ia_ptr, DA
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_ib_cq_free(DAPL_IA *ia_ptr, DAPL_EVD *evd_ptr)
+u32 dapl_ib_cq_free(struct dapl_ia *ia_ptr, struct dapl_evd *evd_ptr)
{
int ib_status;
@@ -261,7 +261,8 @@ u32 dapl_ib_cq_free(DAPL_IA *ia_ptr, DAP
return dapl_ib_status_convert(ib_status);
}
-u32 dapl_ib_cq_resize(DAPL_IA *ia_ptr, DAPL_EVD *evd_ptr, int *cqlen)
+u32 dapl_ib_cq_resize(struct dapl_ia *ia_ptr, struct dapl_evd *evd_ptr,
+ int *cqlen)
{
int ib_status;
@@ -293,7 +294,7 @@ u32 dapl_ib_cq_resize(DAPL_IA *ia_ptr, D
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_set_cq_notify(DAPL_IA *ia_ptr, DAPL_EVD *evd_ptr)
+u32 dapl_set_cq_notify(struct dapl_ia *ia_ptr, struct dapl_evd *evd_ptr)
{
int ib_status;
@@ -318,7 +319,7 @@ u32 dapl_set_cq_notify(DAPL_IA *ia_ptr,
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_ib_pd_alloc(DAPL_IA *ia, DAPL_PZ *pz)
+u32 dapl_ib_pd_alloc(struct dapl_ia *ia, struct dapl_pz *pz)
{
struct ib_pd *pd;
int ib_status;
@@ -353,7 +354,7 @@ u32 dapl_ib_pd_alloc(DAPL_IA *ia, DAPL_P
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_ib_pd_free(DAPL_PZ *pz)
+u32 dapl_ib_pd_free(struct dapl_pz *pz)
{
int ib_status;
@@ -388,14 +389,15 @@ u32 dapl_ib_pd_free(DAPL_PZ *pz)
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_ib_mr_register(DAPL_IA *ia, DAPL_LMR *lmr, void *virt_addr,
- u64 length, enum dat_mem_priv_flags privileges)
+u32 dapl_ib_mr_register(struct dapl_ia *ia, struct dapl_lmr *lmr,
+ void *virt_addr, u64 length,
+ enum dat_mem_priv_flags privileges)
{
/* ITBD virtual memory registration ??? */
return DAT_SUCCESS;
}
-u32 dapl_ib_mr_register_physical(DAPL_IA *ia_ptr, DAPL_LMR *lmr,
+u32 dapl_ib_mr_register_physical(struct dapl_ia *ia_ptr, struct dapl_lmr *lmr,
void *phys_addr, u64 length,
enum dat_mem_priv_flags privileges)
{
@@ -421,7 +423,7 @@ u32 dapl_ib_mr_register_physical(DAPL_IA
iova = buf_list[0].addr;
acl = dapl_ib_convert_mem_privileges(privileges);
acl |= IB_ACCESS_MW_BIND;
- mr = ib_reg_phys_mr((struct ib_pd *)((DAPL_PZ *) lmr->param.pz_handle)->
+ mr = ib_reg_phys_mr((struct ib_pd *)((struct dapl_pz *)lmr->param.pz_handle)->
pd_handle, buf_list, length, acl, &iova);
kfree(buf_list);
if (IS_ERR(mr)) {
@@ -469,7 +471,7 @@ u32 dapl_ib_mr_register_physical(DAPL_IA
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_ib_mr_deregister(DAPL_LMR *lmr)
+u32 dapl_ib_mr_deregister(struct dapl_lmr *lmr)
{
int ib_status;
@@ -503,12 +505,12 @@ u32 dapl_ib_mr_deregister(DAPL_LMR *lmr)
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_ib_mw_alloc(DAPL_RMR *rmr)
+u32 dapl_ib_mw_alloc(struct dapl_rmr *rmr)
{
int ib_status;
struct ib_mw *mw;
- mw = ib_alloc_mw((struct ib_pd *)((DAPL_PZ *) rmr->param.pz_handle)->
+ mw = ib_alloc_mw((struct ib_pd *)((struct dapl_pz *)rmr->param.pz_handle)->
pd_handle);
if (IS_ERR(mw)) {
ib_status = PTR_ERR(mw);
@@ -540,7 +542,7 @@ u32 dapl_ib_mw_alloc(DAPL_RMR *rmr)
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_ib_mw_free(DAPL_RMR *rmr)
+u32 dapl_ib_mw_free(struct dapl_rmr *rmr)
{
int ib_status;
@@ -573,10 +575,10 @@ u32 dapl_ib_mw_free(DAPL_RMR *rmr)
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_ib_mw_bind(DAPL_RMR *rmr, DAPL_LMR *lmr, DAPL_EP *ep,
- DAPL_COOKIE *cookie, u64 virtual_address,
- u64 length, enum dat_mem_priv_flags mem_priv,
- boolean_t is_signaled)
+u32 dapl_ib_mw_bind(struct dapl_rmr *rmr, struct dapl_lmr *lmr,
+ struct dapl_ep *ep, struct dapl_cookie *cookie,
+ u64 virtual_address, u64 length,
+ enum dat_mem_priv_flags mem_priv, boolean_t is_signaled)
{
int ib_status;
struct ib_mw_bind mw_bind_prop;
@@ -624,8 +626,8 @@ u32 dapl_ib_mw_bind(DAPL_RMR *rmr, DAPL_
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_ib_mw_unbind(DAPL_RMR *rmr, DAPL_EP *ep, DAPL_COOKIE *cookie,
- boolean_t is_signaled)
+u32 dapl_ib_mw_unbind(struct dapl_rmr *rmr, struct dapl_ep *ep,
+ struct dapl_cookie *cookie, boolean_t is_signaled)
{
int ib_status;
struct ib_mw_bind mw_bind_prop;
@@ -671,7 +673,7 @@ u32 dapl_ib_mw_unbind(DAPL_RMR *rmr, DAP
* DAT_INVALID_PARAMETER
*
*/
-u32 dapl_ib_setup_async_callback(DAPL_IA *ia_ptr,
+u32 dapl_ib_setup_async_callback(struct dapl_ia *ia_ptr,
DAPL_ASYNC_HANDLER_TYPE handler_type,
ib_async_handler_t callback, void *context)
{
@@ -696,7 +698,7 @@ u32 dapl_ib_setup_async_callback(DAPL_IA
* DAT_SUCCESS
* DAT_INVALID_PARAMETER
*/
-u32 dapl_ib_query_hca(DAPL_HCA *hca_ptr, struct dat_ia_attr *ia_attr,
+u32 dapl_ib_query_hca(struct dapl_hca *hca_ptr, struct dat_ia_attr *ia_attr,
struct dat_ep_attr *ep_attr, struct sockaddr_in6 *ip_addr)
{
int ib_status;
@@ -797,7 +799,7 @@ u32 dapl_ib_query_hca(DAPL_HCA *hca_ptr,
return DAT_SUCCESS;
}
-u32 dapl_ib_completion_poll(DAPL_HCA *hca_ptr, DAPL_EVD *evd_ptr,
+u32 dapl_ib_completion_poll(struct dapl_hca *hca_ptr, struct dapl_evd *evd_ptr,
struct ib_wc *cqe_ptr)
{
int ib_status;
@@ -810,7 +812,7 @@ u32 dapl_ib_completion_poll(DAPL_HCA *hc
return dapl_ib_status_convert(ib_status);
}
-u32 dapl_ib_completion_notify(DAPL_EVD *evd_ptr)
+u32 dapl_ib_completion_notify(struct dapl_evd *evd_ptr)
{
int ib_status;
Index: linux-kernel-resolv/dat-provider/dapl_ep_modify.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ep_modify.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ep_modify.c (working copy)
@@ -56,12 +56,12 @@ static inline u32
dapl_ep_modify_validate_parameters(DAT_EP_HANDLE ep_handle,
enum dat_ep_param_mask mask,
const struct dat_ep_param *ep_param,
- DAPL_IA ** ia_ptr,
- DAPL_EP ** ep_ptr,
+ struct dapl_ia **ia_ptr,
+ struct dapl_ep **ep_ptr,
struct dat_ep_attr *ep_attr_ptr)
{
- DAPL_IA *ia;
- DAPL_EP *ep;
+ struct dapl_ia *ia;
+ struct dapl_ep *ep;
struct dat_ep_attr ep_attr;
struct dat_ep_attr ep_attr_limit;
struct dat_ep_attr ep_attr_request;
@@ -76,7 +76,7 @@ dapl_ep_modify_validate_parameters(DAT_E
goto bail;
}
- ep = (DAPL_EP *) ep_handle;
+ ep = (struct dapl_ep *)ep_handle;
ia = ep->header.owner_ia;
/*
@@ -139,7 +139,7 @@ dapl_ep_modify_validate_parameters(DAT_E
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)
- || !((DAPL_EVD *) ep_param->recv_evd_handle)->
+ || !((struct dapl_evd *)ep_param->recv_evd_handle)->
evd_flags & DAT_EVD_DTO_FLAG)) {
dat_status =
DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3);
@@ -161,7 +161,7 @@ dapl_ep_modify_validate_parameters(DAT_E
if (ep_param->connect_evd_handle != NULL &&
DAPL_BAD_HANDLE(ep_param->connect_evd_handle,
DAPL_MAGIC_EVD)
- && !(((DAPL_EVD *) ep_param->connect_evd_handle)->
+ && !(((struct dapl_evd *)ep_param->connect_evd_handle)->
evd_flags & DAT_EVD_CONNECTION_FLAG)) {
dat_status =
DAT_ERROR(DAT_INVALID_PARAMETER, DAT_INVALID_ARG3);
@@ -298,13 +298,13 @@ dapl_ep_modify_validate_parameters(DAT_E
u32 dapl_ep_modify(DAT_EP_HANDLE ep_handle, enum dat_ep_param_mask mask,
const struct dat_ep_param *ep_param)
{
- DAPL_IA *ia;
- DAPL_EP *ep1, *ep2;
+ struct dapl_ia *ia;
+ struct dapl_ep *ep1, *ep2;
struct dat_ep_attr ep_attr1, ep_attr2;
- DAPL_EP new_ep, copy_of_old_ep;
- DAPL_EP alloc_ep; /* Holder for resources. */
- DAPL_PZ *tmp_pz;
- DAPL_EVD *tmp_evd;
+ struct dapl_ep new_ep, copy_of_old_ep;
+ struct dapl_ep alloc_ep; /* Holder for resources. */
+ struct dapl_pz *tmp_pz;
+ struct dapl_evd *tmp_evd;
u32 dat_status;
/* Flag indicating we've allocated a new one of these. */
@@ -325,9 +325,8 @@ u32 dapl_ep_modify(DAT_EP_HANDLE ep_hand
mask,
ep_param,
&ia, &ep1, &ep_attr1);
- if (DAT_SUCCESS != dat_status) {
+ if (DAT_SUCCESS != dat_status)
goto bail;
- }
/*
* Setup the alloc_ep with the appropriate parameters (primarily
@@ -335,23 +334,17 @@ 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) {
+ if (mask & DAT_EP_FIELD_PZ_HANDLE)
alloc_ep.param.pz_handle = ep_param->pz_handle;
- }
- if (mask & DAT_EP_FIELD_RECV_EVD_HANDLE) {
+ if (mask & DAT_EP_FIELD_RECV_EVD_HANDLE)
alloc_ep.param.recv_evd_handle = ep_param->recv_evd_handle;
- }
- if (mask & DAT_EP_FIELD_REQUEST_EVD_HANDLE) {
- alloc_ep.param.request_evd_handle =
- ep_param->request_evd_handle;
- }
+ if (mask & DAT_EP_FIELD_REQUEST_EVD_HANDLE)
+ alloc_ep.param.request_evd_handle = ep_param->request_evd_handle;
- if (mask & DAT_EP_FIELD_CONNECT_EVD_HANDLE) {
- alloc_ep.param.connect_evd_handle =
- ep_param->connect_evd_handle;
- }
+ if (mask & DAT_EP_FIELD_CONNECT_EVD_HANDLE)
+ alloc_ep.param.connect_evd_handle = ep_param->connect_evd_handle;
/*
* Allocate everything that might be needed.
@@ -364,16 +357,14 @@ u32 dapl_ep_modify(DAT_EP_HANDLE ep_hand
*/
dat_status = dapl_cb_create(&alloc_ep.req_buffer, ep1, /* For pointer in buffer bool. */
ep_attr1.max_request_dtos);
- if (DAT_SUCCESS != dat_status) {
+ if (DAT_SUCCESS != dat_status)
goto bail;
- }
rqst_cb_allocated = TRUE;
dat_status = dapl_cb_create(&alloc_ep.recv_buffer, ep1, /* For pointer in buffer bool. */
ep_attr1.max_recv_dtos);
- if (DAT_SUCCESS != dat_status) {
+ if (DAT_SUCCESS != dat_status)
goto bail;
- }
recv_cb_allocated = TRUE;
alloc_ep.send_iov_num = ep_attr1.max_request_iov;
@@ -397,9 +388,8 @@ u32 dapl_ep_modify(DAT_EP_HANDLE ep_hand
recv_iov_allocated = TRUE;
dat_status = dapl_ib_qp_alloc(ia, &alloc_ep, ep1);
- if (dat_status != DAT_SUCCESS) {
+ if (dat_status != DAT_SUCCESS)
goto bail;
- }
qp_allocated = TRUE;
/*
@@ -527,92 +517,79 @@ u32 dapl_ep_modify(DAT_EP_HANDLE ep_hand
* and then decrementing old ones (so if they're the same
* the refcount never drops to zero).
*/
- tmp_pz = (DAPL_PZ *) new_ep.param.pz_handle;
- if (NULL != tmp_pz) {
+ tmp_pz = (struct dapl_pz *)new_ep.param.pz_handle;
+ if (tmp_pz)
atomic_inc(&tmp_pz->pz_ref_count);
- }
- tmp_evd = (DAPL_EVD *) new_ep.param.recv_evd_handle;
- if (NULL != tmp_evd) {
+ tmp_evd = (struct dapl_evd *)new_ep.param.recv_evd_handle;
+ if (tmp_evd)
atomic_inc(&tmp_evd->evd_ref_count);
- }
- tmp_evd = (DAPL_EVD *) new_ep.param.request_evd_handle;
- if (NULL != tmp_evd) {
+ tmp_evd = (struct dapl_evd *)new_ep.param.request_evd_handle;
+ if (tmp_evd)
atomic_inc(&tmp_evd->evd_ref_count);
- }
- tmp_evd = (DAPL_EVD *) new_ep.param.connect_evd_handle;
- if (NULL != tmp_evd) {
+ tmp_evd = (struct dapl_evd *)new_ep.param.connect_evd_handle;
+ if (tmp_evd)
atomic_inc(&tmp_evd->evd_ref_count);
- }
/* decreament the old reference counts */
- tmp_pz = (DAPL_PZ *) copy_of_old_ep.param.pz_handle;
- if (NULL != tmp_pz) {
+ tmp_pz = (struct dapl_pz *)copy_of_old_ep.param.pz_handle;
+ if (tmp_pz)
atomic_dec(&tmp_pz->pz_ref_count);
- }
- tmp_evd = (DAPL_EVD *) copy_of_old_ep.param.recv_evd_handle;
- if (NULL != tmp_evd) {
+ tmp_evd = (struct dapl_evd *)copy_of_old_ep.param.recv_evd_handle;
+ if (tmp_evd)
atomic_dec(&tmp_evd->evd_ref_count);
- }
- tmp_evd = (DAPL_EVD *) copy_of_old_ep.param.request_evd_handle;
- if (NULL != tmp_evd) {
+ tmp_evd = (struct dapl_evd *)copy_of_old_ep.param.request_evd_handle;
+ if (tmp_evd)
atomic_dec(&tmp_evd->evd_ref_count);
- }
- tmp_evd = (DAPL_EVD *) copy_of_old_ep.param.connect_evd_handle;
- if (NULL != tmp_evd) {
+ tmp_evd = (struct dapl_evd *)copy_of_old_ep.param.connect_evd_handle;
+ if (tmp_evd)
atomic_dec(&tmp_evd->evd_ref_count);
- }
- bail:
+bail:
if (qp_allocated) {
u32 local_dat_status;
- if (dat_status != DAT_SUCCESS || !qp_used) {
+ if (dat_status != DAT_SUCCESS || !qp_used)
local_dat_status = dapl_ib_qp_free(ia, &alloc_ep);
- } else {
+ else
local_dat_status = dapl_ib_qp_free(ia, ©_of_old_ep);
- }
- if (local_dat_status != DAT_SUCCESS) {
+ if (local_dat_status != DAT_SUCCESS)
dapl_dbg_log(DAPL_DBG_TYPE_WARN,
"ep_modify: Failed to free QP; status %x\n",
local_dat_status);
- }
}
if (rqst_cb_allocated) {
- if (dat_status != DAT_SUCCESS || !rqst_cb_used) {
+ if (dat_status != DAT_SUCCESS || !rqst_cb_used)
dapl_cb_free(&alloc_ep.req_buffer);
- } else {
+ else
dapl_cb_free(©_of_old_ep.req_buffer);
- }
}
if (recv_cb_allocated) {
- if (dat_status != DAT_SUCCESS || !recv_cb_used) {
+ if (dat_status != DAT_SUCCESS || !recv_cb_used)
dapl_cb_free(&alloc_ep.recv_buffer);
- } else {
+ else
dapl_cb_free(©_of_old_ep.recv_buffer);
- }
}
if (rqst_iov_allocated) {
- if (dat_status != DAT_SUCCESS || !rqst_iov_used) {
+ if (dat_status != DAT_SUCCESS || !rqst_iov_used)
kfree(alloc_ep.send_iov);
- } else {
+ else
kfree(copy_of_old_ep.send_iov);
- }
}
if (recv_iov_allocated) {
- if (dat_status != DAT_SUCCESS || !recv_iov_used) {
+ if (dat_status != DAT_SUCCESS || !recv_iov_used)
kfree(alloc_ep.recv_iov);
- } else {
+ else
kfree(copy_of_old_ep.recv_iov);
- }
}
+
return dat_status;
}
Index: linux-kernel-resolv/dat-provider/dapl_openib_qp.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_openib_qp.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_openib_qp.c (working copy)
@@ -44,7 +44,8 @@
#include "dapl_evd_util.h"
#include "dapl_openib_util.h"
-struct ib_cq * dapl_get_dto_cq(DAPL_IA * ia_ptr, DAPL_EVD * recv_evd_ptr);
+struct ib_cq *dapl_get_dto_cq(struct dapl_ia *ia_ptr,
+ struct dapl_evd *recv_evd_ptr);
/*
* dapl_ib_qp_alloc
@@ -66,7 +67,8 @@ struct ib_cq * dapl_get_dto_cq(DAPL_IA *
* DAT_INSUFFICIENT_RESOURCES
*
*/
-u32 dapl_ib_qp_alloc(DAPL_IA *ia_ptr, DAPL_EP *ep_ptr, DAPL_EP *ep_ctx_ptr)
+u32 dapl_ib_qp_alloc(struct dapl_ia *ia_ptr, struct dapl_ep *ep_ptr,
+ struct dapl_ep *ep_ctx_ptr)
{
struct dat_ep_attr *attr;
int ib_status;
@@ -80,15 +82,15 @@ u32 dapl_ib_qp_alloc(DAPL_IA *ia_ptr, DA
dapl_os_assert(ep_ptr->param.pz_handle != NULL);
ib_pd_handle =
- (struct ib_pd *)((DAPL_PZ *) ep_ptr->param.pz_handle)->pd_handle;
+ (struct ib_pd *)((struct dapl_pz *)ep_ptr->param.pz_handle)->pd_handle;
ib_hca_handle = ia_ptr->hca_ptr->ib_hca_handle;
cq_recv = NULL;
cq_send = NULL;
cq_recv = dapl_get_dto_cq(ia_ptr,
- (DAPL_EVD *) ep_ptr->param.recv_evd_handle);
+ (struct dapl_evd *)ep_ptr->param.recv_evd_handle);
cq_send = dapl_get_dto_cq(ia_ptr,
- (DAPL_EVD *) ep_ptr->param.
+ (struct dapl_evd *)ep_ptr->param.
request_evd_handle);
qp_attr.send_cq = cq_send;
@@ -151,7 +153,7 @@ u32 dapl_ib_qp_alloc(DAPL_IA *ia_ptr, DA
* Status of destroy operation.
*
*/
-u32 dapl_ib_qp_free(DAPL_IA *ia_ptr, DAPL_EP *ep_ptr)
+u32 dapl_ib_qp_free(struct dapl_ia *ia_ptr, struct dapl_ep *ep_ptr)
{
int ib_status;
@@ -178,7 +180,7 @@ u32 dapl_ib_qp_free(DAPL_IA *ia_ptr, DAP
* Returns
* A valid CQ handle
*/
-struct ib_cq * dapl_get_dto_cq(DAPL_IA * ia_ptr, DAPL_EVD * evd_ptr)
+struct ib_cq *dapl_get_dto_cq(struct dapl_ia *ia_ptr, struct dapl_evd *evd_ptr)
{
struct ib_cq *cq_handle;
int cq_entries;
@@ -232,7 +234,7 @@ struct ib_cq * dapl_get_dto_cq(DAPL_IA *
* DAT_INVALID_PARAMETER
*
*/
-u32 dapl_ib_qp_modify(DAPL_IA *ia_ptr, DAPL_EP *ep_ptr,
+u32 dapl_ib_qp_modify(struct dapl_ia *ia_ptr, struct dapl_ep *ep_ptr,
struct dat_ep_attr *ep_attr)
{
struct ib_qp_attr qp_attr;
Index: linux-kernel-resolv/dat-provider/dapl_evd_kcreate.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_evd_kcreate.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_evd_kcreate.c (working copy)
@@ -53,9 +53,9 @@ u32 dapl_evd_kcreate(DAT_IA_HANDLE ia_ha
const struct dat_upcall_object *upcall,
enum dat_evd_flags evd_flags, DAT_EVD_HANDLE *evd_handle)
{
- DAPL_IA *ia_ptr;
- DAPL_EVD *evd_ptr;
- DAPL_CNO *cno_ptr;
+ struct dapl_ia *ia_ptr;
+ struct dapl_evd *evd_ptr;
+ struct dapl_cno *cno_ptr;
u32 dat_status = DAT_SUCCESS;
DAT_EVD_HANDLE evdhandle = (DAT_EVD_HANDLE) NULL;
@@ -64,7 +64,7 @@ u32 dapl_evd_kcreate(DAT_IA_HANDLE ia_ha
ia_handle,
evd_min_qlen, upcall_policy, evd_flags, evd_handle);
- ia_ptr = (DAPL_IA *) ia_handle;
+ ia_ptr = (struct dapl_ia *)ia_handle;
cno_ptr = NULL;
evd_ptr = NULL;
*evd_handle = NULL;
@@ -94,38 +94,31 @@ u32 dapl_evd_kcreate(DAT_IA_HANDLE ia_ha
goto bail;
}
- cno_ptr = dapl_cno_alloc (ia_ptr, upcall);
+ cno_ptr = dapl_cno_alloc(ia_ptr, upcall);
- if (!cno_ptr)
- {
+ if (!cno_ptr) {
dat_status = DAT_INSUFFICIENT_RESOURCES;
goto bail;
}
- cno_ptr->cno_upcall_policy = upcall_policy;
-
+ cno_ptr->cno_upcall_policy = upcall_policy;
dat_status = dapl_evd_internal_create(ia_ptr,
cno_ptr,
evd_min_qlen,
evd_flags, &evd_ptr);
- if (dat_status != DAT_SUCCESS) {
+ if (dat_status != DAT_SUCCESS)
goto bail;
- }
evdhandle = *evd_handle = (DAT_EVD_HANDLE) evd_ptr;
- bail:
+bail:
if (dat_status != DAT_SUCCESS && cno_ptr != NULL)
- {
dapl_cno_dealloc (cno_ptr);
- }
- if (dat_status != DAT_SUCCESS) {
- if (evd_ptr) {
+ if (dat_status != DAT_SUCCESS)
+ if (evd_ptr)
dapl_evd_free(evd_ptr);
- }
- }
return dat_status;
}
Index: linux-kernel-resolv/dat-provider/dapl_cno_util.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_cno_util.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_cno_util.c (working copy)
@@ -38,9 +38,10 @@
/*
* alloc and initialize an EVD struct
*/
-DAPL_CNO *dapl_cno_alloc(DAPL_IA *ia_ptr, const struct dat_upcall_object *upcall)
+struct dapl_cno *dapl_cno_alloc(struct dapl_ia *ia_ptr,
+ const struct dat_upcall_object *upcall)
{
- DAPL_CNO *cno_ptr;
+ struct dapl_cno *cno_ptr;
cno_ptr = kmalloc(sizeof *cno_ptr, GFP_ATOMIC);
if (!cno_ptr)
@@ -71,7 +72,7 @@ DAPL_CNO *dapl_cno_alloc(DAPL_IA *ia_ptr
/*
* Free the passed in CNO structure.
*/
-void dapl_cno_dealloc(DAPL_CNO *cno_ptr)
+void dapl_cno_dealloc(struct dapl_cno *cno_ptr)
{
dapl_os_assert(cno_ptr->header.magic == DAPL_MAGIC_CNO);
@@ -98,7 +99,7 @@ void dapl_cno_dealloc(DAPL_CNO *cno_ptr)
* Returns:
* None
*/
-void dapl_cno_trigger(DAPL_CNO *cno_ptr, DAPL_EVD *evd_ptr)
+void dapl_cno_trigger(struct dapl_cno *cno_ptr, struct dapl_evd *evd_ptr)
{
u32 dat_status = DAT_SUCCESS;
struct dat_event event;
Index: linux-kernel-resolv/dat-provider/dapl_timer_util.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_timer_util.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_timer_util.c (working copy)
@@ -53,7 +53,7 @@
#include "dapl_timer_util.h"
struct dapl_timer_head {
- DAPL_LLIST_HEAD timer_list_head;
+ struct dapl_llist_entry *timer_list_head;
spinlock_t lock;
unsigned long flags;
DAPL_OS_WAIT_OBJECT wait_object;
@@ -129,7 +129,8 @@ u32 dapl_timer_set(struct dapl_timer_ent
if (dapl_llist_is_empty(&g_dapl_timer_head.timer_list_head)) {
/* Case 1: add entry to head of list */
dapl_llist_add_head(&g_dapl_timer_head.timer_list_head,
- (DAPL_LLIST_ENTRY *) & timer->list_entry,
+ (struct dapl_llist_entry *)
+ &timer->list_entry,
timer);
wakeup_tmo_thread = TRUE;
} else {
@@ -139,42 +140,41 @@ u32 dapl_timer_set(struct dapl_timer_ent
if (timer->expires < list_ptr->expires) {
/* Case 2: add entry to head of list */
dapl_llist_add_head(&g_dapl_timer_head.timer_list_head,
- (DAPL_LLIST_ENTRY *) & timer->
- list_entry, timer);
+ (struct dapl_llist_entry *)
+ &timer->list_entry, timer);
wakeup_tmo_thread = TRUE;
} else {
/* Case 3: figure out where entry goes in sorted list */
list_ptr =
dapl_llist_next_entry(&g_dapl_timer_head.
timer_list_head,
- (DAPL_LLIST_ENTRY *) &
- list_ptr->list_entry);
+ (struct dapl_llist_entry *)
+ &list_ptr->list_entry);
while (list_ptr != NULL) {
if (timer->expires < list_ptr->expires) {
dapl_llist_add_entry(&g_dapl_timer_head.
timer_list_head,
- (DAPL_LLIST_ENTRY
- *) & list_ptr->
- list_entry,
- (DAPL_LLIST_ENTRY
- *) & timer->
- list_entry, timer);
+ (struct dapl_llist_entry *)
+ &list_ptr->list_entry,
+ (struct dapl_llist_entry *)
+ &timer->list_entry,
+ timer);
break;
}
list_ptr =
dapl_llist_next_entry(&g_dapl_timer_head.
timer_list_head,
- (DAPL_LLIST_ENTRY *) &
- list_ptr->list_entry);
+ (struct dapl_llist_entry *)
+ &list_ptr->list_entry);
}
if (list_ptr == NULL) {
/* entry goes to the end of the list */
dapl_llist_add_tail(&g_dapl_timer_head.
timer_list_head,
- (DAPL_LLIST_ENTRY *) &
- timer->list_entry, timer);
+ (struct dapl_llist_entry *)
+ &timer->list_entry, timer);
}
}
@@ -209,8 +209,8 @@ void dapl_timer_cancel(struct dapl_timer
if (!dapl_llist_is_empty(&g_dapl_timer_head.timer_list_head) &&
timer->list_entry.list_head == &g_dapl_timer_head.timer_list_head) {
dapl_llist_remove_entry(&g_dapl_timer_head.timer_list_head,
- (DAPL_LLIST_ENTRY *) & timer->
- list_entry);
+ (struct dapl_llist_entry *)
+ &timer->list_entry);
}
/*
* If this was the first entry on the queue we could awaken the
Index: linux-kernel-resolv/dat-provider/dapl_openib_util.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_openib_util.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_openib_util.h (working copy)
@@ -62,15 +62,16 @@ u32 dapl_ib_enum_hcas(const char *vendor
u32 dapl_ib_get_instance_data(DAPL_HCA_NAME hca_name, char *instance);
-u32 dapl_ib_open_hca(char *namestr, DAPL_HCA *hca_ptr);
+u32 dapl_ib_open_hca(char *namestr, struct dapl_hca *hca_ptr);
-u32 dapl_ib_close_hca(DAPL_HCA *hca_ptr);
+u32 dapl_ib_close_hca(struct dapl_hca *hca_ptr);
-u32 dapl_ib_qp_alloc(DAPL_IA *ia_ptr, DAPL_EP *ep_ptr, DAPL_EP *ep_ctx_ptr);
+u32 dapl_ib_qp_alloc(struct dapl_ia *ia_ptr, struct dapl_ep *ep_ptr,
+ struct dapl_ep *ep_ctx_ptr);
-u32 dapl_ib_qp_free(DAPL_IA *ia_ptr, DAPL_EP *ep_ptr);
+u32 dapl_ib_qp_free(struct dapl_ia *ia_ptr, struct dapl_ep *ep_ptr);
-u32 dapl_ib_qp_modify(DAPL_IA *ia_ptr, DAPL_EP *ep_ptr,
+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,
@@ -78,12 +79,12 @@ u32 dapl_ib_connect(DAT_EP_HANDLE ep_han
DAT_CONN_QUAL remote_conn_qual,
int private_data_size, void *private_data);
-u32 dapl_ib_disconnect(DAPL_EP *ep_ptr, enum dat_close_flags close_flags);
+u32 dapl_ib_disconnect(struct dapl_ep *ep_ptr, enum dat_close_flags close_flags);
-u32 dapl_ib_setup_conn_listener(DAPL_IA *ia_ptr, u64 ServiceID,
- DAPL_SP *sp_ptr);
+u32 dapl_ib_setup_conn_listener(struct dapl_ia *ia_ptr, u64 ServiceID,
+ struct dapl_sp *sp_ptr);
-u32 dapl_ib_remove_conn_listener(DAPL_IA *ia_ptr, DAPL_SP *sp_ptr);
+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,
@@ -92,61 +93,63 @@ u32 dapl_ib_accept_connection(DAT_CR_HAN
u32 dapl_ib_reject_connection(struct dapl_cm_id *cm_handle);
-u32 dapl_ib_setup_async_callback(DAPL_IA *ia_ptr,
+u32 dapl_ib_setup_async_callback(struct dapl_ia *ia_ptr,
DAPL_ASYNC_HANDLER_TYPE handler_type,
ib_async_handler_t callback, void *context);
-u32 dapl_ib_cq_alloc(DAPL_IA *ia_ptr, DAPL_EVD *evd_ptr, int *cqlen,
- ib_comp_handler callback);
+u32 dapl_ib_cq_alloc(struct dapl_ia *ia_ptr, struct dapl_evd *evd_ptr,
+ int *cqlen, ib_comp_handler callback);
-u32 dapl_ib_cq_free(DAPL_IA *ia_ptr, DAPL_EVD *evd_ptr);
+u32 dapl_ib_cq_free(struct dapl_ia *ia_ptr, struct dapl_evd *evd_ptr);
-u32 dapl_set_cq_notify(DAPL_IA *ia_ptr, DAPL_EVD *evd_ptr);
+u32 dapl_set_cq_notify(struct dapl_ia *ia_ptr, struct dapl_evd *evd_ptr);
-u32 dapl_ib_cq_resize(DAPL_IA *ia_ptr, DAPL_EVD *evd_ptr, int *cqlen);
+u32 dapl_ib_cq_resize(struct dapl_ia *ia_ptr, struct dapl_evd *evd_ptr,
+ int *cqlen);
-u32 dapl_ib_pd_alloc(DAPL_IA *ia_ptr, DAPL_PZ *pz);
+u32 dapl_ib_pd_alloc(struct dapl_ia *ia_ptr, struct dapl_pz *pz);
-u32 dapl_ib_pd_free(DAPL_PZ *pz);
+u32 dapl_ib_pd_free(struct dapl_pz *pz);
-u32 dapl_ib_mr_register(DAPL_IA *ia_ptr, DAPL_LMR *lmr, void *virt_addr,
- u64 length, enum dat_mem_priv_flags privileges);
+u32 dapl_ib_mr_register(struct dapl_ia *ia_ptr, struct dapl_lmr *lmr,
+ void *virt_addr, u64 length,
+ enum dat_mem_priv_flags privileges);
-u32 dapl_ib_mr_register_physical(DAPL_IA *ia_ptr, DAPL_LMR *lmr,
+u32 dapl_ib_mr_register_physical(struct dapl_ia *ia_ptr, struct dapl_lmr *lmr,
void *phys_addr, u64 length,
enum dat_mem_priv_flags privileges);
-u32 dapl_ib_mr_deregister(DAPL_LMR *lmr);
+u32 dapl_ib_mr_deregister(struct dapl_lmr *lmr);
-u32 dapl_ib_mr_register_shared(DAPL_IA *ia_ptr, DAPL_LMR *lmr,
+u32 dapl_ib_mr_register_shared(struct dapl_ia *ia_ptr, struct dapl_lmr *lmr,
enum dat_mem_priv_flags privileges);
-u32 dapl_ib_mw_alloc(DAPL_RMR *rmr);
+u32 dapl_ib_mw_alloc(struct dapl_rmr *rmr);
-u32 dapl_ib_mw_free(DAPL_RMR *rmr);
+u32 dapl_ib_mw_free(struct dapl_rmr *rmr);
-u32 dapl_ib_mw_bind(DAPL_RMR *rmr, DAPL_LMR *lmr, DAPL_EP *ep,
- DAPL_COOKIE *cookie, u64 virtual_address,
- u64 length, enum dat_mem_priv_flags mem_priv,
- boolean_t is_signaled);
+u32 dapl_ib_mw_bind(struct dapl_rmr *rmr, struct dapl_lmr *lmr,
+ struct dapl_ep *ep, struct dapl_cookie *cookie,
+ u64 virtual_address, u64 length,
+ enum dat_mem_priv_flags mem_priv, boolean_t is_signaled);
-u32 dapl_ib_mw_unbind(DAPL_RMR *rmr, DAPL_EP *ep, DAPL_COOKIE *cookie,
- boolean_t is_signaled);
+u32 dapl_ib_mw_unbind(struct dapl_rmr *rmr, struct dapl_ep *ep,
+ struct dapl_cookie *cookie, boolean_t is_signaled);
-u32 dapl_ib_query_hca(DAPL_HCA *hca_ptr, struct dat_ia_attr *ia_attr,
+u32 dapl_ib_query_hca(struct dapl_hca *hca_ptr, struct dat_ia_attr *ia_attr,
struct dat_ep_attr *ep_attr,
struct sockaddr_in6 *ip_addr);
-u32 dapl_ib_completion_poll(DAPL_HCA *hca_ptr, DAPL_EVD *evd_ptr,
+u32 dapl_ib_completion_poll(struct dapl_hca *hca_ptr, struct dapl_evd *evd_ptr,
struct ib_wc *cqe_ptr);
-u32 dapl_ib_completion_notify(DAPL_EVD *evd_ptr);
+u32 dapl_ib_completion_notify(struct dapl_evd *evd_ptr);
enum dat_dto_completion_status dapl_ib_get_dto_status(struct ib_wc *cqe_ptr);
-void dapl_ib_reinit_ep(DAPL_EP * ep_ptr);
+void dapl_ib_reinit_ep(struct dapl_ep * ep_ptr);
-void dapl_ib_disconnect_clean(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);
Index: linux-kernel-resolv/dat-provider/dapl_evd_kquery.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_evd_kquery.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_evd_kquery.c (working copy)
@@ -40,7 +40,7 @@
u32 dapl_evd_kquery(DAT_EVD_HANDLE evd_handle, struct dat_evd_param *evd_param)
{
- DAPL_EVD *evd_ptr;
+ struct dapl_evd *evd_ptr;
u32 dat_status = DAT_SUCCESS;
if (NULL == evd_param) {
@@ -58,7 +58,7 @@ u32 dapl_evd_kquery(DAT_EVD_HANDLE evd_h
goto bail;
}
- evd_ptr = (DAPL_EVD *) evd_handle;
+ evd_ptr = (struct dapl_evd *)evd_handle;
/*
* We may be racing against the thread safe modify
* calls here (dat_evd_{enable,disable,{set,clear}_unwaitable}).
Index: linux-kernel-resolv/dat-provider/dapl_ia_close.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ia_close.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ia_close.c (working copy)
@@ -59,13 +59,13 @@
*/
u32 dapl_ia_close(DAT_IA_HANDLE ia_handle, enum dat_close_flags ia_flags)
{
- DAPL_IA *ia_ptr;
+ 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);
- ia_ptr = (DAPL_IA *) ia_handle;
+ ia_ptr = (struct dapl_ia *)ia_handle;
if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
dat_status =
Index: linux-kernel-resolv/dat-provider/dapl_evd_qp_async_error_callb.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_evd_qp_async_error_callb.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_evd_qp_async_error_callb.c (working copy)
@@ -54,13 +54,13 @@
void dapl_evd_qp_async_error_callback(struct ib_event *cause, void *context)
{
- DAPL_EP *ep_ptr;
- DAPL_EVD *async_evd;
+ struct dapl_ep *ep_ptr;
+ struct dapl_evd *async_evd;
enum dat_event_number async_event;
u32 dat_status;
- ep_ptr = (DAPL_EP *) context;
- async_evd = (DAPL_EVD *) ep_ptr->header.owner_ia->async_error_evd;
+ ep_ptr = (struct dapl_ep *)context;
+ async_evd = (struct dapl_evd *)ep_ptr->header.owner_ia->async_error_evd;
dapl_dbg_log(DAPL_DBG_TYPE_CALLBACK | DAPL_DBG_TYPE_EXCEPTION,
"--> dapl_evd_qp_async_error_callback: ep %p qp %p (%x) state %d\n",
Index: linux-kernel-resolv/dat-provider/dapl_cno_util.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_cno_util.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_cno_util.h (working copy)
@@ -36,16 +36,11 @@
#include "dapl.h"
-DAPL_CNO *
-dapl_cno_alloc(DAPL_IA *ia_ptr, const struct dat_upcall_object *upcall);
+struct dapl_cno *dapl_cno_alloc(struct dapl_ia *ia_ptr,
+ const struct dat_upcall_object *upcall);
-void
-dapl_cno_dealloc (
- DAPL_CNO *cno_ptr) ;
+void dapl_cno_dealloc(struct dapl_cno *cno_ptr);
-void
-dapl_cno_trigger(
- DAPL_CNO *cno_ptr,
- DAPL_EVD *evd_ptr);
+void dapl_cno_trigger(struct dapl_cno *cno_ptr, struct dapl_evd *evd_ptr);
#endif
Index: linux-kernel-resolv/dat-provider/dapl_srq_set_lw.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_srq_set_lw.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_srq_set_lw.c (working copy)
@@ -65,7 +65,7 @@
u32 dapl_srq_set_lw(DAT_SRQ_HANDLE srq_handle, int low_watermark)
{
- DAPL_SRQ *srq_ptr;
+ struct dapl_srq *srq_ptr;
u32 dat_status = DAT_SUCCESS;
dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_srq_set_lw (%p, %d)\n",
@@ -77,7 +77,7 @@ u32 dapl_srq_set_lw(DAT_SRQ_HANDLE srq_h
goto bail;
}
- srq_ptr = (DAPL_SRQ *) srq_handle;
+ srq_ptr = (struct dapl_srq *)srq_handle;
/* XXX Put implementation here XXX */
Index: linux-kernel-resolv/dat-provider/dapl_evd_un_async_error_callb.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_evd_un_async_error_callb.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_evd_un_async_error_callb.c (working copy)
@@ -46,7 +46,7 @@
void dapl_evd_un_async_error_callback(struct ib_event *cause, void *context)
{
- DAPL_EVD *async_evd;
+ struct dapl_evd *async_evd;
enum dat_event_number async_event;
u32 dat_status;
@@ -59,7 +59,7 @@ void dapl_evd_un_async_error_callback(st
return;
}
- async_evd = (DAPL_EVD *) context;
+ async_evd = (struct dapl_evd *)context;
dat_status = dapl_ib_get_async_event(cause, &async_event);
if (dat_status == DAT_SUCCESS) {
Index: linux-kernel-resolv/dat-provider/dapl_cr_accept.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_cr_accept.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_cr_accept.c (working copy)
@@ -42,9 +42,9 @@
u32 dapl_cr_accept(DAT_CR_HANDLE cr_handle, DAT_EP_HANDLE ep_handle,
int private_data_size, const void *private_data)
{
- DAPL_EP *ep_ptr;
+ struct dapl_ep *ep_ptr;
u32 dat_status;
- DAPL_CR *cr_ptr;
+ struct dapl_cr *cr_ptr;
enum dat_ep_state entry_ep_state;
DAT_EP_HANDLE entry_ep_handle;
@@ -58,7 +58,7 @@ u32 dapl_cr_accept(DAT_CR_HANDLE cr_hand
goto bail;
}
- cr_ptr = (DAPL_CR *) cr_handle;
+ cr_ptr = (struct dapl_cr *)cr_handle;
/*
* Return an error if we have an ep_handle and the CR already has an
@@ -91,21 +91,21 @@ u32 dapl_cr_accept(DAT_CR_HANDLE cr_hand
*/
if (ep_handle == NULL) {
ep_handle = cr_ptr->param.local_ep_handle;
- if ((((DAPL_EP *) ep_handle)->param.ep_state !=
+ if ((((struct dapl_ep *)ep_handle)->param.ep_state !=
DAT_EP_STATE_TENTATIVE_CONNECTION_PENDING)
- && (((DAPL_EP *) ep_handle)->param.ep_state !=
+ && (((struct dapl_ep *)ep_handle)->param.ep_state !=
DAT_EP_STATE_PASSIVE_CONNECTION_PENDING)) {
return DAT_INVALID_STATE;
}
} else {
/* ensure this EP isn't connected or in use */
- if (((DAPL_EP *) ep_handle)->param.ep_state !=
+ if (((struct dapl_ep *)ep_handle)->param.ep_state !=
DAT_EP_STATE_UNCONNECTED) {
return DAT_INVALID_STATE;
}
}
- ep_ptr = (DAPL_EP *) ep_handle;
+ ep_ptr = (struct dapl_ep *)ep_handle;
/*
* Verify the attributes of the EP handle before we connect it. Test
@@ -124,7 +124,7 @@ u32 dapl_cr_accept(DAT_CR_HANDLE cr_hand
/* test connect handle */
|| ep_ptr->param.connect_evd_handle == NULL
|| DAPL_BAD_HANDLE(ep_ptr->param.connect_evd_handle, DAPL_MAGIC_EVD)
- || !(((DAPL_EVD *) ep_ptr->param.connect_evd_handle)->
+ || !(((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 &&
Index: linux-kernel-resolv/dat-provider/dapl_rsp_create.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_rsp_create.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_rsp_create.c (working copy)
@@ -72,14 +72,14 @@ u32 dapl_rsp_create(DAT_IA_HANDLE ia_han
DAT_EP_HANDLE ep_handle, DAT_EVD_HANDLE evd_handle,
DAT_RSP_HANDLE *rsp_handle)
{
- DAPL_IA *ia_ptr;
- DAPL_SP *sp_ptr;
- DAPL_EVD *evd_ptr;
- DAPL_EP *ep_ptr;
+ struct dapl_ia *ia_ptr;
+ struct dapl_sp *sp_ptr;
+ struct dapl_evd *evd_ptr;
+ struct dapl_ep *ep_ptr;
boolean_t sp_found;
u32 dat_status = DAT_SUCCESS;
- ia_ptr = (DAPL_IA *) ia_handle;
+ ia_ptr = (struct dapl_ia *)ia_handle;
dapl_dbg_log(DAPL_DBG_TYPE_CM,
">>> dapl_rsp_free conn_qual: %x EP: %p\n",
@@ -106,14 +106,14 @@ u32 dapl_rsp_create(DAT_IA_HANDLE ia_han
goto bail;
}
- ep_ptr = (DAPL_EP *) ep_handle;
+ ep_ptr = (struct dapl_ep *)ep_handle;
if (ep_ptr->param.ep_state != DAT_EP_STATE_UNCONNECTED) {
dat_status =
DAT_ERROR(DAT_INVALID_STATE, dapl_ep_state_subtype(ep_ptr));
goto bail;
}
- evd_ptr = (DAPL_EVD *) evd_handle;
+ evd_ptr = (struct dapl_evd *)evd_handle;
if (!(evd_ptr->evd_flags & DAT_EVD_CR_FLAG)) {
dat_status =
DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_CR);
@@ -147,7 +147,7 @@ u32 dapl_rsp_create(DAT_IA_HANDLE ia_han
/*
* Take a reference on the EVD handle
*/
- atomic_inc(&((DAPL_EVD *) evd_handle)->evd_ref_count);
+ atomic_inc(&((struct dapl_evd *)evd_handle)->evd_ref_count);
/*
* Update the EP state indicating the provider now owns it
@@ -174,7 +174,7 @@ u32 dapl_rsp_create(DAT_IA_HANDLE ia_han
* wrong! Decrements the EVD refcount & release it. Set
* the state to FREE, so we know the call failed.
*/
- atomic_dec(&((DAPL_EVD *) evd_handle)->
+ atomic_dec(&((struct dapl_evd *)evd_handle)->
evd_ref_count);
sp_ptr->evd_handle = NULL;
sp_ptr->state = DAPL_SP_STATE_FREE;
Index: linux-kernel-resolv/dat-provider/dapl_srq_post_recv.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_srq_post_recv.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_srq_post_recv.c (working copy)
@@ -71,8 +71,8 @@ u32 dapl_srq_post_recv(DAT_SRQ_HANDLE sr
struct dat_lmr_triplet *local_iov,
DAT_DTO_COOKIE user_cookie)
{
- DAPL_SRQ *srq_ptr;
- DAPL_COOKIE *cookie;
+ struct dapl_srq *srq_ptr;
+ struct dapl_cookie *cookie;
u32 dat_status;
dapl_dbg_log(DAPL_DBG_TYPE_API,
@@ -85,7 +85,7 @@ u32 dapl_srq_post_recv(DAT_SRQ_HANDLE sr
goto bail;
}
- srq_ptr = (DAPL_SRQ *) srq_handle;
+ srq_ptr = (struct dapl_srq *)srq_handle;
/*
* Synchronization ok since this buffer is only used for receive
Index: linux-kernel-resolv/dat-provider/dapl_lmr_free.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_lmr_free.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_lmr_free.c (working copy)
@@ -59,7 +59,7 @@
u32 dapl_lmr_free(DAT_LMR_HANDLE lmr_handle)
{
- DAPL_LMR *lmr;
+ struct dapl_lmr *lmr;
u32 dat_status;
dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_lmr_free (%p)\n", lmr_handle);
@@ -70,36 +70,34 @@ u32 dapl_lmr_free(DAT_LMR_HANDLE lmr_han
goto bail;
}
- lmr = (DAPL_LMR *) lmr_handle;
+ lmr = (struct dapl_lmr *)lmr_handle;
switch (lmr->param.mem_type) {
case DAT_MEM_TYPE_PHYSICAL:
case DAT_MEM_TYPE_VIRTUAL:
case DAT_MEM_TYPE_LMR:
{
- DAPL_PZ *pz;
+ struct dapl_pz *pz;
- if (0 != atomic_read(&lmr->lmr_ref_count)) {
+ if (0 != atomic_read(&lmr->lmr_ref_count))
return DAT_INVALID_STATE;
- }
dat_status =
dapl_hash_remove(lmr->header.owner_ia->hca_ptr->
lmr_hash_table,
lmr->param.lmr_context, NULL);
- if (dat_status != DAT_SUCCESS) {
+ if (dat_status != DAT_SUCCESS)
goto bail;
- }
dat_status = dapl_ib_mr_deregister(lmr);
if (dat_status == DAT_SUCCESS) {
- pz = (DAPL_PZ *) lmr->param.pz_handle;
+ pz = (struct dapl_pz *)lmr->param.pz_handle;
atomic_dec(&pz->pz_ref_count);
dapl_lmr_dealloc(lmr);
- } else {
+ } else
/*
* Deregister failed; put it back in the
* hash table.
@@ -107,7 +105,6 @@ u32 dapl_lmr_free(DAT_LMR_HANDLE lmr_han
dapl_hash_insert(lmr->header.owner_ia->
hca_ptr->lmr_hash_table,
lmr->param.lmr_context, lmr);
- }
break;
}
@@ -124,6 +121,6 @@ u32 dapl_lmr_free(DAT_LMR_HANDLE lmr_han
break;
}
}
- bail:
+bail:
return dat_status;
}
Index: linux-kernel-resolv/dat-provider/dapl_get_handle_type.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_get_handle_type.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_get_handle_type.c (working copy)
@@ -59,9 +59,9 @@
u32 dapl_get_handle_type(DAT_HANDLE dat_handle, enum dat_handle_type *type)
{
u32 dat_status = DAT_SUCCESS;
- DAPL_HEADER *header;
+ struct dapl_header *header;
- header = (DAPL_HEADER *) dat_handle;
+ header = (struct dapl_header *)dat_handle;
if (((header) == NULL) ||
((unsigned long)(header) & 3) ||
(header->magic != DAPL_MAGIC_IA &&
Index: linux-kernel-resolv/dat-provider/dapl_rmr_util.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_rmr_util.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_rmr_util.c (working copy)
@@ -28,9 +28,9 @@
#include "dapl_rmr_util.h"
#include "dapl_ia_util.h"
-DAPL_RMR *dapl_rmr_alloc(DAPL_PZ * pz)
+struct dapl_rmr *dapl_rmr_alloc(struct dapl_pz *pz)
{
- DAPL_RMR *rmr;
+ struct dapl_rmr *rmr;
/* Allocate LMR */
rmr = kmalloc(sizeof *rmr, GFP_ATOMIC);
@@ -70,9 +70,10 @@ DAPL_RMR *dapl_rmr_alloc(DAPL_PZ * pz)
return rmr;
}
-void dapl_rmr_dealloc(DAPL_RMR * rmr)
+void dapl_rmr_dealloc(struct dapl_rmr *rmr)
{
- rmr->header.magic = DAPL_MAGIC_INVALID; /* reset magic to prevent reuse */
+ /* 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 */
Index: linux-kernel-resolv/dat-provider/dapl_ep_util.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ep_util.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ep_util.c (working copy)
@@ -55,9 +55,10 @@
* none
*
*/
-DAPL_EP *dapl_ep_alloc(DAPL_IA * ia_ptr, const struct dat_ep_attr *ep_attr)
+struct dapl_ep *dapl_ep_alloc(struct dapl_ia *ia_ptr,
+ const struct dat_ep_attr *ep_attr)
{
- DAPL_EP *ep_ptr;
+ struct dapl_ep *ep_ptr;
/* Allocate EP */
ep_ptr = kmalloc(sizeof *ep_ptr + sizeof (struct sockaddr), GFP_ATOMIC);
@@ -94,8 +95,7 @@ DAPL_EP *dapl_ep_alloc(DAPL_IA * ia_ptr,
(ep_ptr->param.ep_attr.max_request_dtos / 256) + 1;
ep_ptr->param.ep_attr.max_recv_dtos =
(ep_ptr->param.ep_attr.max_recv_dtos / 256) + 1;
- }
- else
+ } else
ep_ptr->param.ep_attr = *ep_attr;
ep_ptr->qp_handle = NULL;
@@ -139,7 +139,7 @@ DAPL_EP *dapl_ep_alloc(DAPL_IA * ia_ptr,
goto bail;
}
- bail:
+bail:
return ep_ptr;
}
@@ -158,26 +158,24 @@ DAPL_EP *dapl_ep_alloc(DAPL_IA * ia_ptr,
* none
*
*/
-void dapl_ep_dealloc(DAPL_EP * ep_ptr)
+void dapl_ep_dealloc(struct dapl_ep *ep_ptr)
{
dapl_os_assert(ep_ptr->header.magic == DAPL_MAGIC_EP);
- ep_ptr->header.magic = DAPL_MAGIC_INVALID; /* reset magic to prevent reuse */
+ /* 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);
- if (NULL != ep_ptr->recv_iov) {
+ if (ep_ptr->recv_iov)
kfree(ep_ptr->recv_iov);
- }
- if (NULL != ep_ptr->send_iov) {
+ if (ep_ptr->send_iov)
kfree(ep_ptr->send_iov);
- }
- if (NULL != ep_ptr->cxn_timer) {
+ if (ep_ptr->cxn_timer)
kfree(ep_ptr->cxn_timer);
- }
kfree(ep_ptr);
}
@@ -194,9 +192,8 @@ u32 dapl_ep_check_recv_completion_flags(
* an EVD completes, even though the dapl handler is invoked.
*/
- if (flags & DAT_COMPLETION_SUPPRESS_FLAG) {
+ if (flags & DAT_COMPLETION_SUPPRESS_FLAG)
return DAT_INVALID_PARAMETER;
- }
return DAT_SUCCESS;
}
@@ -208,8 +205,8 @@ u32 dapl_ep_post_send_req(DAT_EP_HANDLE
enum dat_completion_flags completion_flags,
DAPL_DTO_TYPE dto_type, enum ib_wr_opcode op_type)
{
- DAPL_EP *ep_ptr;
- DAPL_COOKIE *cookie;
+ struct dapl_ep *ep_ptr;
+ struct dapl_cookie *cookie;
u32 dat_status;
if (DAPL_BAD_HANDLE(ep_handle, DAPL_MAGIC_EP)) {
@@ -218,7 +215,7 @@ u32 dapl_ep_post_send_req(DAT_EP_HANDLE
goto bail;
}
- ep_ptr = (DAPL_EP *) ep_handle;
+ ep_ptr = (struct dapl_ep *)ep_handle;
/*
* Synchronization ok since this buffer is only used for send
@@ -226,9 +223,8 @@ u32 dapl_ep_post_send_req(DAT_EP_HANDLE
*/
dat_status = dapl_dto_cookie_alloc(&ep_ptr->req_buffer, dto_type,
user_cookie, &cookie);
- if (dat_status != DAT_SUCCESS) {
+ if (dat_status != DAT_SUCCESS)
goto bail;
- }
/*
* Take reference before posting to avoid race conditions with
@@ -247,7 +243,7 @@ u32 dapl_ep_post_send_req(DAT_EP_HANDLE
dapl_cookie_dealloc(&ep_ptr->req_buffer, cookie);
}
- bail:
+bail:
return dat_status;
}
@@ -259,11 +255,11 @@ u32 dapl_ep_post_send_req(DAT_EP_HANDLE
*/
void dapl_ep_timeout(void *arg)
{
- DAPL_EP *ep_ptr;
+ struct dapl_ep *ep_ptr;
dapl_dbg_log(DAPL_DBG_TYPE_CM, "--> dapl_ep_timeout! ep %lx\n", arg);
- ep_ptr = (DAPL_EP *) arg;
+ ep_ptr = (struct dapl_ep *)arg;
/* reset the EP state */
ep_ptr->param.ep_state = DAT_EP_STATE_DISCONNECTED;
@@ -271,7 +267,7 @@ void dapl_ep_timeout(void *arg)
/* Clean up the EP and put the underlying QP into the ERROR state. */
dapl_ib_disconnect_clean(ep_ptr, TRUE);
- (void)dapl_evd_post_connection_event((DAPL_EVD *) ep_ptr->param.
+ (void)dapl_evd_post_connection_event((struct dapl_evd *)ep_ptr->param.
connect_evd_handle,
DAT_CONNECTION_EVENT_TIMED_OUT,
(DAT_HANDLE) ep_ptr, 0, NULL);
@@ -283,7 +279,7 @@ void dapl_ep_timeout(void *arg)
* Return the INVALID_STATE connection subtype associated with an
* INVALID_STATE on an EP. Strictly for error reporting.
*/
-enum dat_return_subtype dapl_ep_state_subtype(DAPL_EP * ep_ptr)
+enum dat_return_subtype dapl_ep_state_subtype(struct dapl_ep *ep_ptr)
{
enum dat_return_subtype dat_status;
Index: linux-kernel-resolv/dat-provider/dapl_rmr_util.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_rmr_util.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_rmr_util.h (working copy)
@@ -39,15 +39,9 @@
#include "dapl_mr_util.h"
-/*********************************************************************
- * *
- * Function Prototypes *
- * *
- *********************************************************************/
+extern struct dapl_rmr *dapl_rmr_alloc(struct dapl_pz *pz);
-extern DAPL_RMR *dapl_rmr_alloc(DAPL_PZ * pz);
-
-extern void dapl_rmr_dealloc(DAPL_RMR * rmr);
+extern void dapl_rmr_dealloc(struct dapl_rmr *rmr);
static inline boolean_t
dapl_rmr_validate_completion_flag(enum dat_completion_flags mask,
Index: linux-kernel-resolv/dat-provider/dapl_lmr_sync_rdma_write.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_lmr_sync_rdma_write.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_lmr_sync_rdma_write.c (working copy)
@@ -45,14 +45,14 @@ u32 dapl_lmr_sync_rdma_write(DAT_IA_HAND
const struct dat_lmr_triplet *local_segments,
u64 num_segments)
{
- DAPL_IA *ia_ptr;
+ struct dapl_ia *ia_ptr;
u32 dat_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_ptr = (DAPL_IA *) ia_handle;
+ ia_ptr = (struct dapl_ia *)ia_handle;
if (DAPL_BAD_HANDLE(ia_ptr, DAPL_MAGIC_IA)) {
dat_status =
Index: linux-kernel-resolv/dat-provider/dapl_rsp_free.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_rsp_free.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_rsp_free.c (working copy)
@@ -60,12 +60,12 @@
*/
u32 dapl_rsp_free(DAT_RSP_HANDLE rsp_handle)
{
- DAPL_IA *ia_ptr;
- DAPL_SP *sp_ptr;
- DAPL_EP *ep_ptr;
+ struct dapl_ia *ia_ptr;
+ struct dapl_sp *sp_ptr;
+ struct dapl_ep *ep_ptr;
u32 dat_status = DAT_SUCCESS;
- sp_ptr = (DAPL_SP *) rsp_handle;
+ sp_ptr = (struct dapl_sp *)rsp_handle;
/*
* Verify handle
*/
@@ -76,7 +76,7 @@ u32 dapl_rsp_free(DAT_RSP_HANDLE rsp_han
goto bail;
}
- /* ia_ptr = (DAPL_IA *)sp_ptr->header.owner_ia; */
+ /* ia_ptr = (struct dapl_ia *)sp_ptr->header.owner_ia; */
ia_ptr = sp_ptr->header.owner_ia;
/*
@@ -90,17 +90,16 @@ u32 dapl_rsp_free(DAT_RSP_HANDLE rsp_han
* Make sure we don't leave a dangling EP. If the state is still
* RESERVED then the RSP still owns it.
*/
- ep_ptr = (DAPL_EP *) sp_ptr->ep_handle;
- if (ep_ptr != NULL && ep_ptr->param.ep_state == DAT_EP_STATE_RESERVED) {
+ ep_ptr = (struct dapl_ep *)sp_ptr->ep_handle;
+ 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;
/* Release reference on EVD. If an error was encountered in a previous
* free the evd_handle will be NULL
*/
if (sp_ptr->evd_handle) {
- atomic_dec(&((DAPL_EVD *) sp_ptr->evd_handle)->
+ atomic_dec(&((struct dapl_evd *)sp_ptr->evd_handle)->
evd_ref_count);
sp_ptr->evd_handle = NULL;
}
@@ -138,6 +137,6 @@ u32 dapl_rsp_free(DAT_RSP_HANDLE rsp_han
sp_ptr->header.flags);
}
- bail:
+bail:
return dat_status;
}
Index: linux-kernel-resolv/dat-provider/dapl_srq_free.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_srq_free.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_srq_free.c (working copy)
@@ -61,14 +61,14 @@
*/
u32 dapl_srq_free(DAT_SRQ_HANDLE srq_handle)
{
- DAPL_SRQ *srq_ptr;
- DAPL_IA *ia_ptr;
+ struct dapl_srq *srq_ptr;
+ struct dapl_ia *ia_ptr;
struct dat_srq_param *param;
u32 dat_status = DAT_SUCCESS;
dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_srq_free (%p)\n", srq_handle);
- srq_ptr = (DAPL_SRQ *) srq_handle;
+ srq_ptr = (struct dapl_srq *)srq_handle;
param = &srq_ptr->param;
/*
Index: linux-kernel-resolv/dat-provider/dapl_ep_util.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ep_util.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ep_util.h (working copy)
@@ -42,9 +42,10 @@
/* function prototypes */
-extern DAPL_EP *dapl_ep_alloc(DAPL_IA * ia, const struct dat_ep_attr *ep_attr);
+extern struct dapl_ep *dapl_ep_alloc(struct dapl_ia *ia,
+ const struct dat_ep_attr *ep_attr);
-extern void dapl_ep_dealloc(DAPL_EP * ep_ptr);
+extern void dapl_ep_dealloc(struct dapl_ep *ep_ptr);
extern u32 dapl_ep_check_recv_completion_flags(enum dat_completion_flags flags);
@@ -58,6 +59,6 @@ extern u32 dapl_ep_post_send_req(DAT_EP_
void dapl_ep_timeout(void *arg);
-enum dat_return_subtype dapl_ep_state_subtype(DAPL_EP * ep_ptr);
+enum dat_return_subtype dapl_ep_state_subtype(struct dapl_ep *ep_ptr);
#endif /* DAPL_EP_UTIL_H */
Index: linux-kernel-resolv/dat-provider/dapl_ep_create_with_srq.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ep_create_with_srq.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ep_create_with_srq.c (working copy)
@@ -77,8 +77,8 @@ u32 dapl_ep_create_with_srq(DAT_IA_HANDL
const struct dat_ep_attr *ep_attr,
DAT_EP_HANDLE *ep_handle)
{
- DAPL_IA *ia_ptr;
- DAPL_EP *ep_ptr;
+ struct dapl_ia *ia_ptr;
+ struct dapl_ep *ep_ptr;
struct dat_ep_attr *ep_attr_limit;
u32 dat_status = DAT_SUCCESS;
@@ -90,7 +90,7 @@ u32 dapl_ep_create_with_srq(DAT_IA_HANDL
request_evd_handle,
connect_evd_handle, srq_handle, ep_attr, ep_handle);
- ia_ptr = (DAPL_IA *) ia_handle;
+ ia_ptr = (struct dapl_ia *)ia_handle;
/*
* Verify parameters
@@ -116,7 +116,7 @@ u32 dapl_ep_create_with_srq(DAT_IA_HANDL
/* 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) ||
- !(((DAPL_EVD *) connect_evd_handle)->
+ !(((struct dapl_evd *)connect_evd_handle)->
evd_flags & DAT_EVD_CONNECTION_FLAG))) {
dat_status =
DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_CONN);
@@ -125,7 +125,7 @@ u32 dapl_ep_create_with_srq(DAT_IA_HANDL
/* 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) ||
- !(((DAPL_EVD *) recv_evd_handle)->evd_flags & DAT_EVD_DTO_FLAG))) {
+ !(((struct dapl_evd *)recv_evd_handle)->evd_flags & DAT_EVD_DTO_FLAG))) {
dat_status =
DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_EVD_RECV);
goto bail;
@@ -134,7 +134,7 @@ u32 dapl_ep_create_with_srq(DAT_IA_HANDL
/* 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) ||
- !(((DAPL_EVD *) request_evd_handle)->
+ !(((struct dapl_evd *)request_evd_handle)->
evd_flags & DAT_EVD_DTO_FLAG))) {
dat_status =
DAT_ERROR(DAT_INVALID_HANDLE,
@@ -253,7 +253,7 @@ u32 dapl_ep_create_with_srq(DAT_IA_HANDL
*/
if (pz_handle != DAT_HANDLE_NULL) {
/* Take a reference on the PZ handle */
- atomic_inc(&((DAPL_PZ *) pz_handle)->pz_ref_count);
+ atomic_inc(&((struct dapl_pz *)pz_handle)->pz_ref_count);
/*
* Get a QP from the IB provider
@@ -261,14 +261,12 @@ 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(&((DAPL_PZ *) pz_handle)->
- pz_ref_count);
+ atomic_dec(&((struct dapl_pz *)pz_handle)->pz_ref_count);
dapl_ep_dealloc(ep_ptr);
goto bail;
}
- } else {
+ } else
ep_ptr->qp_state = DAPL_QP_STATE_UNATTACHED;
- }
/*
* Update ref counts. See the spec where the endpoint marks
@@ -278,16 +276,14 @@ u32 dapl_ep_create_with_srq(DAT_IA_HANDL
*
* N.B. This should really be done by a util routine.
*/
- atomic_inc(&((DAPL_EVD *) connect_evd_handle)->evd_ref_count);
+ atomic_inc(&((struct dapl_evd *)connect_evd_handle)->evd_ref_count);
/* Optional handles */
- if (recv_evd_handle != DAT_HANDLE_NULL) {
- atomic_inc(&((DAPL_EVD *) recv_evd_handle)->
+ if (recv_evd_handle != DAT_HANDLE_NULL)
+ atomic_inc(&((struct dapl_evd *)recv_evd_handle)->
evd_ref_count);
- }
- if (request_evd_handle != DAT_HANDLE_NULL) {
- atomic_inc(&((DAPL_EVD *) request_evd_handle)->
+ if (request_evd_handle != DAT_HANDLE_NULL)
+ atomic_inc(&((struct dapl_evd *)request_evd_handle)->
evd_ref_count);
- }
/* Link it onto the IA */
dapl_ia_link_ep(ia_ptr, ep_ptr);
@@ -296,6 +292,6 @@ u32 dapl_ep_create_with_srq(DAT_IA_HANDL
#endif /* notdef */
- bail:
+bail:
return dat_status;
}
Index: linux-kernel-resolv/dat-provider/dapl_ia_open.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ia_open.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ia_open.c (working copy)
@@ -57,12 +57,9 @@ u32 dapl_ia_open(const char *name, int a
{
u32 dat_status = DAT_SUCCESS;
struct dat_provider *provider;
- DAPL_HCA *hca_ptr;
- DAPL_IA *ia_ptr;
- DAPL_EVD *evd_ptr;
-
- hca_ptr = NULL;
- ia_ptr = NULL;
+ struct dapl_hca *hca_ptr = NULL;
+ struct dapl_ia *ia_ptr = NULL;
+ struct dapl_evd *evd_ptr;
dapl_dbg_log(DAPL_DBG_TYPE_API,
"dapl_ia_open (%s, %d, %p, %p)\n",
@@ -87,7 +84,7 @@ u32 dapl_ia_open(const char *name, int a
/* initialize the caller's param */
*ia_handle_ptr = DAT_HANDLE_NULL;
- hca_ptr = (DAPL_HCA *) provider->extension;
+ hca_ptr = (struct dapl_hca *)provider->extension;
atomic_inc(&hca_ptr->handle_ref_count);
/* Allocate and initialize ia structure */
@@ -103,7 +100,7 @@ u32 dapl_ia_open(const char *name, int a
* use the one passed in (if non-NULL) or create one
*/
- evd_ptr = (DAPL_EVD *) * async_evd_handle_ptr;
+ 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)) {
Index: linux-kernel-resolv/dat-provider/dapl_evd_util.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_evd_util.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_evd_util.c (working copy)
@@ -41,7 +41,7 @@
static inline void dapl_evd_eh_print_cqe(struct ib_wc *cqe);
-u32 dapl_evd_event_alloc(DAPL_EVD *evd_ptr, int qlen);
+u32 dapl_evd_event_alloc(struct dapl_evd *evd_ptr, int qlen);
/*
* actually create the evd. this is called after all parameter checking
@@ -49,11 +49,11 @@ u32 dapl_evd_event_alloc(DAPL_EVD *evd_p
* to create the default async evd.
*/
-u32 dapl_evd_internal_create(DAPL_IA *ia_ptr, DAPL_CNO *cno_ptr,
+u32 dapl_evd_internal_create(struct dapl_ia *ia_ptr, struct dapl_cno *cno_ptr,
int min_qlen, enum dat_evd_flags evd_flags,
- DAPL_EVD **evd_ptr_ptr)
+ struct dapl_evd **evd_ptr_ptr)
{
- DAPL_EVD *evd_ptr;
+ struct dapl_evd *evd_ptr;
int cq_len;
u32 dat_status = DAT_SUCCESS;
@@ -117,10 +117,11 @@ bail:
/*
* alloc and initialize an EVD struct
*/
-DAPL_EVD *dapl_evd_alloc(DAPL_IA * ia_ptr, DAPL_CNO * cno_ptr,
- enum dat_evd_flags evd_flags, int qlen)
+struct dapl_evd *dapl_evd_alloc(struct dapl_ia *ia_ptr,
+ struct dapl_cno *cno_ptr,
+ enum dat_evd_flags evd_flags, int qlen)
{
- DAPL_EVD *evd_ptr;
+ struct dapl_evd *evd_ptr;
/* Allocate EVD */
evd_ptr = kmalloc(sizeof *evd_ptr, GFP_ATOMIC);
@@ -161,7 +162,7 @@ bail:
/*
* alloc events into an EVD.
*/
-u32 dapl_evd_event_alloc(DAPL_EVD *evd_ptr, int qlen)
+u32 dapl_evd_event_alloc(struct dapl_evd *evd_ptr, int qlen)
{
struct dat_event *event_ptr;
int i;
@@ -201,7 +202,7 @@ bail:
/*
* realloc events into an EVD.
*/
-u32 dapl_evd_event_realloc(DAPL_EVD *evd_ptr, int qlen)
+u32 dapl_evd_event_realloc(struct dapl_evd *evd_ptr, int qlen)
{
struct dat_event *events;
int i, old_qlen, diff;
@@ -251,10 +252,10 @@ bail:
* will clean up all of the internal data structures and report the
* error.
*/
-u32 dapl_evd_dealloc(DAPL_EVD *evd_ptr)
+u32 dapl_evd_dealloc(struct dapl_evd *evd_ptr)
{
u32 dat_status = DAT_SUCCESS;
- DAPL_IA *ia_ptr;
+ struct dapl_ia *ia_ptr;
dapl_os_assert(evd_ptr->header.magic == DAPL_MAGIC_EVD);
dapl_os_assert(atomic_read(&evd_ptr->evd_ref_count) == 0);
@@ -363,7 +364,7 @@ void dapl_evd_eh_print_cqe(struct ib_wc
* that the lock is held.
*/
-static struct dat_event *dapl_evd_get_event(DAPL_EVD * evd_ptr)
+static struct dat_event *dapl_evd_get_event(struct dapl_evd *evd_ptr)
{
struct dat_event *event;
@@ -389,11 +390,11 @@ static struct dat_event *dapl_evd_get_ev
* entry to this function.
*/
-static void dapl_evd_post_event(DAPL_EVD *evd_ptr,
+static void dapl_evd_post_event(struct dapl_evd *evd_ptr,
const struct dat_event *event_ptr)
{
u32 dat_status;
- DAPL_CNO * cno_to_trigger = NULL;
+ struct dapl_cno *cno_to_trigger = NULL;
dapl_dbg_log(DAPL_DBG_TYPE_EVD,
"dapl_evd_post_event: Called with event # %x\n",
@@ -420,10 +421,10 @@ static void dapl_evd_post_event(DAPL_EVD
/*
* format an overflow event for posting
*/
-static void
-dapl_evd_format_overflow_event(DAPL_EVD * evd_ptr, struct dat_event * event_ptr)
+static void dapl_evd_format_overflow_event(struct dapl_evd *evd_ptr,
+ struct dat_event *event_ptr)
{
- DAPL_IA *ia_ptr;
+ struct dapl_ia *ia_ptr;
ia_ptr = evd_ptr->header.owner_ia;
@@ -436,9 +437,8 @@ dapl_evd_format_overflow_event(DAPL_EVD
/*
* post an overflow event
*/
-static void
-dapl_evd_post_overflow_event(DAPL_EVD * async_evd_ptr,
- DAPL_EVD * overflow_evd_ptr)
+static void dapl_evd_post_overflow_event(struct dapl_evd *async_evd_ptr,
+ struct dapl_evd *overflow_evd_ptr)
{
struct dat_event *overflow_event;
@@ -464,7 +464,7 @@ dapl_evd_post_overflow_event(DAPL_EVD *
return;
}
-static struct dat_event *dapl_evd_get_and_init_event(DAPL_EVD *evd_ptr,
+static struct dat_event *dapl_evd_get_and_init_event(struct dapl_evd *evd_ptr,
enum dat_event_number evno)
{
struct dat_event *event_ptr;
@@ -481,7 +481,7 @@ static struct dat_event *dapl_evd_get_an
return event_ptr;
}
-u32 dapl_evd_post_cr_arrival_event(DAPL_EVD *evd_ptr,
+u32 dapl_evd_post_cr_arrival_event(struct dapl_evd *evd_ptr,
DAT_SP_HANDLE sp_handle,
struct sockaddr *ia_address_ptr,
DAT_CONN_QUAL conn_qual,
@@ -511,7 +511,7 @@ u32 dapl_evd_post_cr_arrival_event(DAPL_
return DAT_SUCCESS;
}
-u32 dapl_evd_post_connection_event(DAPL_EVD *evd_ptr,
+u32 dapl_evd_post_connection_event(struct dapl_evd *evd_ptr,
enum dat_event_number event_number,
DAT_EP_HANDLE ep_handle,
int private_data_size,
@@ -540,9 +540,9 @@ u32 dapl_evd_post_connection_event(DAPL_
return DAT_SUCCESS;
}
-u32 dapl_evd_post_async_error_event(DAPL_EVD *evd_ptr,
+u32 dapl_evd_post_async_error_event(struct dapl_evd *evd_ptr,
enum dat_event_number event_number,
- DAPL_IA *ia_ptr)
+ struct dapl_ia *ia_ptr)
{
struct dat_event *event_ptr;
event_ptr = dapl_evd_get_and_init_event(evd_ptr, event_number);
@@ -564,7 +564,7 @@ u32 dapl_evd_post_async_error_event(DAPL
return DAT_SUCCESS;
}
-u32 dapl_evd_post_software_event(DAPL_EVD *evd_ptr,
+u32 dapl_evd_post_software_event(struct dapl_evd *evd_ptr,
enum dat_event_number event_number,
void *pointer)
{
@@ -604,12 +604,12 @@ u32 dapl_evd_post_software_event(DAPL_EV
* none
*
*/
-static void
-dapl_evd_cqe_to_event(DAPL_EVD * evd_ptr, struct ib_wc *cqe_ptr,
- struct dat_event *event_ptr)
+static void dapl_evd_cqe_to_event(struct dapl_evd *evd_ptr,
+ struct ib_wc *cqe_ptr,
+ struct dat_event *event_ptr)
{
- DAPL_EP *ep_ptr;
- DAPL_COOKIE *cookie;
+ struct dapl_ep *ep_ptr;
+ struct dapl_cookie *cookie;
enum dat_dto_completion_status dto_status;
/*
@@ -618,7 +618,7 @@ dapl_evd_cqe_to_event(DAPL_EVD * evd_ptr
*/
dto_status = dapl_ib_get_dto_status(cqe_ptr);
- cookie = (DAPL_COOKIE *) (unsigned long) cqe_ptr->wr_id;
+ cookie = (struct dapl_cookie *) (unsigned long) cqe_ptr->wr_id;
dapl_os_assert((NULL != cookie));
ep_ptr = cookie->ep;
@@ -633,7 +633,7 @@ dapl_evd_cqe_to_event(DAPL_EVD * evd_ptr
switch (cookie->type) {
case DAPL_COOKIE_TYPE_DTO:
{
- DAPL_COOKIE_BUFFER *buffer;
+ struct dapl_cookie_buffer *buffer;
if (DAPL_DTO_TYPE_RECV == cookie->val.dto.type) {
atomic_dec(&ep_ptr->recv_count);
@@ -740,7 +740,7 @@ dapl_evd_cqe_to_event(DAPL_EVD * evd_ptr
* Status of operation
*
*/
-u32 dapl_evd_cq_poll_to_event(DAPL_EVD *evd_ptr, struct dat_event *event)
+u32 dapl_evd_cq_poll_to_event(struct dapl_evd *evd_ptr, struct dat_event *event)
{
u32 dat_status;
struct ib_wc cur_cqe;
Index: linux-kernel-resolv/dat-provider/dapl_ep_disconnect.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ep_disconnect.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ep_disconnect.c (working copy)
@@ -66,16 +66,16 @@
u32 dapl_ep_disconnect(DAT_EP_HANDLE ep_handle,
enum dat_close_flags disconnect_flags)
{
- DAPL_EP *ep_ptr;
- DAPL_EVD *evd_ptr;
- DAPL_CR *cr_ptr;
+ struct dapl_ep *ep_ptr;
+ struct dapl_evd *evd_ptr;
+ struct dapl_cr *cr_ptr;
u32 dat_status;
dapl_dbg_log(DAPL_DBG_TYPE_API | DAPL_DBG_TYPE_CM,
"dapl_ep_disconnect (%p, %x)\n",
ep_handle, disconnect_flags);
- ep_ptr = (DAPL_EP *) ep_handle;
+ ep_ptr = (struct dapl_ep *)ep_handle;
/*
* Verify parameter & state
@@ -144,7 +144,7 @@ u32 dapl_ep_disconnect(DAT_EP_HANDLE ep_
/* clean up connection state */
dapl_sp_remove_ep(ep_ptr);
- evd_ptr = (DAPL_EVD *) ep_ptr->param.connect_evd_handle;
+ evd_ptr = (struct dapl_evd *)ep_ptr->param.connect_evd_handle;
dapl_evd_post_connection_event(evd_ptr,
DAT_CONNECTION_EVENT_DISCONNECTED,
(DAT_HANDLE) ep_ptr, 0, NULL);
Index: linux-kernel-resolv/dat-provider/dapl_sp_util.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_sp_util.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_sp_util.c (working copy)
@@ -59,13 +59,13 @@
* pointer to sp info struct
*
*/
-DAPL_SP *dapl_sp_alloc(DAPL_IA * ia_ptr, boolean_t is_psp)
+struct dapl_sp *dapl_sp_alloc(struct dapl_ia *ia_ptr, boolean_t is_psp)
{
- DAPL_SP *sp_ptr;
+ struct dapl_sp *sp_ptr;
/* Allocate EP */
sp_ptr = kmalloc(sizeof *sp_ptr, GFP_ATOMIC);
- if (!sp_ptr)
+ if (!sp_ptr)
return NULL;
/* zero the structure */
@@ -111,7 +111,7 @@ DAPL_SP *dapl_sp_alloc(DAPL_IA * ia_ptr,
* none
*
*/
-void dapl_sp_dealloc(DAPL_SP * sp_ptr)
+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);
@@ -138,7 +138,7 @@ void dapl_sp_dealloc(DAPL_SP * sp_ptr)
* none
*
*/
-void dapl_sp_link_cr(DAPL_SP *sp_ptr, DAPL_CR *cr_ptr)
+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);
dapl_llist_add_tail(&sp_ptr->cr_list_head,
@@ -166,14 +166,15 @@ void dapl_sp_link_cr(DAPL_SP *sp_ptr, DA
* cr_ptr Pointer to matching DAPL_CR
*
*/
-DAPL_CR *dapl_sp_search_cr(DAPL_SP * sp_ptr, struct dapl_cm_id *ib_cm_handle)
+struct dapl_cr *dapl_sp_search_cr(struct dapl_sp *sp_ptr,
+ struct dapl_cm_id *ib_cm_handle)
{
- DAPL_CR *cr_ptr;
+ struct dapl_cr *cr_ptr;
if (dapl_llist_is_empty(&sp_ptr->cr_list_head))
return NULL;
- cr_ptr = (DAPL_CR *) dapl_llist_peek_head(&sp_ptr->cr_list_head);
+ cr_ptr = (struct dapl_cr *)dapl_llist_peek_head(&sp_ptr->cr_list_head);
do {
if (cr_ptr->ib_cm_handle == ib_cm_handle)
@@ -203,7 +204,7 @@ DAPL_CR *dapl_sp_search_cr(DAPL_SP * sp_
* void
*
*/
-void dapl_sp_remove_cr(DAPL_SP * sp_ptr, DAPL_CR * cr_ptr)
+void dapl_sp_remove_cr(struct dapl_sp *sp_ptr, struct dapl_cr *cr_ptr)
{
if (dapl_llist_is_empty(&sp_ptr->cr_list_head)) {
dapl_dbg_log(DAPL_DBG_TYPE_ERR,
@@ -233,10 +234,10 @@ void dapl_sp_remove_cr(DAPL_SP * sp_ptr,
* void
*
*/
-void dapl_sp_remove_ep(DAPL_EP * ep_ptr)
+void dapl_sp_remove_ep(struct dapl_ep *ep_ptr)
{
- DAPL_SP *sp_ptr;
- DAPL_CR *cr_ptr;
+ struct dapl_sp *sp_ptr;
+ struct dapl_cr *cr_ptr;
cr_ptr = ep_ptr->cr_ptr;
@@ -253,7 +254,5 @@ void dapl_sp_remove_ep(DAPL_EP * ep_ptr)
/* free memory outside of the lock */
dapl_cr_free(cr_ptr);
-
- return;
}
}
Index: linux-kernel-resolv/dat-provider/dapl_evd_util.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_evd_util.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_evd_util.h (working copy)
@@ -40,16 +40,17 @@
#include "dapl.h"
-u32 dapl_evd_internal_create(DAPL_IA *ia_ptr, DAPL_CNO *cno_ptr,
+u32 dapl_evd_internal_create(struct dapl_ia *ia_ptr, struct dapl_cno *cno_ptr,
int min_qlen, enum dat_evd_flags evd_flags,
- DAPL_EVD **evd_ptr_ptr);
+ struct dapl_evd **evd_ptr_ptr);
-DAPL_EVD *dapl_evd_alloc(DAPL_IA * ia_ptr, DAPL_CNO * cno_ptr,
- enum dat_evd_flags evd_flags, int qlen);
+struct dapl_evd *dapl_evd_alloc(struct dapl_ia *ia_ptr,
+ struct dapl_cno *cno_ptr,
+ enum dat_evd_flags evd_flags, int qlen);
-u32 dapl_evd_dealloc(DAPL_EVD *evd_ptr);
+u32 dapl_evd_dealloc(struct dapl_evd *evd_ptr);
-u32 dapl_evd_event_realloc(DAPL_EVD *evd_ptr, int qlen);
+u32 dapl_evd_event_realloc(struct dapl_evd *evd_ptr, int qlen);
/*
* Each of these functions will retrieve a free event from
@@ -62,23 +63,23 @@ u32 dapl_evd_event_realloc(DAPL_EVD *evd
* DAT_SUCCESS otherwise.
*/
-u32 dapl_evd_post_cr_arrival_event(DAPL_EVD *evd_ptr,
+u32 dapl_evd_post_cr_arrival_event(struct dapl_evd *evd_ptr,
DAT_SP_HANDLE sp_handle,
struct sockaddr *ia_address_ptr,
DAT_CONN_QUAL conn_qual,
DAT_CR_HANDLE cr_handle);
-u32 dapl_evd_post_connection_event(DAPL_EVD *evd_ptr,
+u32 dapl_evd_post_connection_event(struct dapl_evd *evd_ptr,
enum dat_event_number event_number,
DAT_EP_HANDLE ep_handle,
int private_data_size,
void *private_data);
-u32 dapl_evd_post_async_error_event(DAPL_EVD *evd_ptr,
+u32 dapl_evd_post_async_error_event(struct dapl_evd *evd_ptr,
enum dat_event_number event_number,
- DAPL_IA *ia_ptr);
+ struct dapl_ia *ia_ptr);
-u32 dapl_evd_post_software_event(DAPL_EVD *evd_ptr,
+u32 dapl_evd_post_software_event(struct dapl_evd *evd_ptr,
enum dat_event_number event_number,
void *pointer);
@@ -105,7 +106,7 @@ extern void dapl_evd_cq_async_error_call
extern void dapl_evd_qp_async_error_callback(struct ib_event *cause_ptr,
void *context);
-extern u32 dapl_evd_cq_poll_to_event(DAPL_EVD *evd_ptr,
+extern u32 dapl_evd_cq_poll_to_event(struct dapl_evd *evd_ptr,
struct dat_event *event);
#endif
Index: linux-kernel-resolv/dat-provider/dapl_hash.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_hash.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_hash.c (working copy)
@@ -161,7 +161,7 @@ dapl_hash_rehash(DAPL_HASH_ELEM * elemen
* TRUE on success
*/
static boolean_t
-dapl_hash_add(DAPL_HASH_TABLEP p_table, DAPL_HASH_KEY key, void *datum,
+dapl_hash_add(struct dapl_hash_table *table, DAPL_HASH_KEY key, void *datum,
boolean_t allow_dup, boolean_t *report_dup)
{
void *olddatum;
@@ -184,7 +184,7 @@ dapl_hash_add(DAPL_HASH_TABLEP p_table,
return FALSE;
}
- DAPL_HASHLOOKUP(p_table, key, olddatum, found);
+ DAPL_HASHLOOKUP(table, key, olddatum, found);
if (found) {
/*
* key exists already
@@ -201,16 +201,16 @@ dapl_hash_add(DAPL_HASH_TABLEP p_table,
}
}
- hashValue = DAPL_DOHASH(key, p_table->tbl_size);
+ hashValue = DAPL_DOHASH(key, table->tbl_size);
key = save_key;
- if (NO_DATUM(p_table->table[hashValue].datum)) {
+ if (NO_DATUM(table->table[hashValue].datum)) {
/*
* Empty head - just fill it in
*/
- p_table->table[hashValue].key = key;
- p_table->table[hashValue].datum = datum;
- p_table->table[hashValue].next_element = NULL;
- p_table->num_entries++;
+ table->table[hashValue].key = key;
+ table->table[hashValue].datum = datum;
+ table->table[hashValue].next_element = NULL;
+ table->num_entries++;
status = TRUE;
} else {
DAPL_HASH_ELEM *newelement = kmalloc(sizeof *newelement,
@@ -223,14 +223,14 @@ dapl_hash_add(DAPL_HASH_TABLEP p_table,
newelement->key = key;
newelement->datum = datum;
newelement->next_element = NULL;
- for (lastelement = &p_table->table[hashValue];
+ for (lastelement = &table->table[hashValue];
lastelement->next_element;
lastelement = lastelement->next_element) {
/* Walk to the end of the chain */
chain_len++;
}
lastelement->next_element = newelement;
- p_table->num_entries++;
+ table->num_entries++;
status = TRUE;
} else
status = FALSE;
@@ -241,14 +241,14 @@ dapl_hash_add(DAPL_HASH_TABLEP p_table,
* length.
*/
chain_len++;
- p_table->hash_tbl_inserts++;
- p_table->hash_tbl_total += p_table->num_entries;
- p_table->hash_chn_total += chain_len;
- if (p_table->num_entries > p_table->hash_tbl_max) {
- p_table->hash_tbl_max = p_table->num_entries;
+ table->hash_tbl_inserts++;
+ table->hash_tbl_total += table->num_entries;
+ table->hash_chn_total += chain_len;
+ if (table->num_entries > table->hash_tbl_max) {
+ table->hash_tbl_max = table->num_entries;
}
- if (chain_len > p_table->hash_chn_max) {
- p_table->hash_chn_max = chain_len;
+ if (chain_len > table->hash_chn_max) {
+ table->hash_chn_max = chain_len;
}
return status;
@@ -319,9 +319,9 @@ dapl_hash_delete_element(DAPL_HASH_ELEM
/*
* Create a new hash table with at least 'table_size' hash buckets.
*/
-u32 dapl_hash_create(int table_size, DAPL_HASH_TABLE **pp_table)
+u32 dapl_hash_create(int table_size, struct dapl_hash_table **pp_table)
{
- DAPL_HASH_TABLE *p_table;
+ struct dapl_hash_table *p_table;
int table_length = table_size * sizeof (struct DAPL_HASH_ELEM);
u32 dat_status = DAT_SUCCESS;
int i;
@@ -356,14 +356,14 @@ u32 dapl_hash_create(int table_size, DAP
*pp_table = p_table;
- bail:
+bail:
return DAT_SUCCESS;
}
/*
* Destroy a hash table
*/
-u32 dapl_hash_free(DAPL_HASH_TABLE *p_table)
+u32 dapl_hash_free(struct dapl_hash_table *p_table)
{
dapl_os_assert(p_table && p_table->table);
@@ -378,7 +378,7 @@ u32 dapl_hash_free(DAPL_HASH_TABLE *p_ta
* Returns the number of elements stored in the table
*/
-u32 dapl_hash_size(DAPL_HASH_TABLE *p_table, int *p_size)
+u32 dapl_hash_size(struct dapl_hash_table *p_table, int *p_size)
{
dapl_os_assert(p_table && p_size);
@@ -392,7 +392,7 @@ u32 dapl_hash_size(DAPL_HASH_TABLE *p_ta
* Duplicates are not expected, and return in error, having done nothing.
*/
-u32 dapl_hash_insert(DAPL_HASH_TABLE *p_table, DAPL_HASH_KEY key,
+u32 dapl_hash_insert(struct dapl_hash_table *p_table, DAPL_HASH_KEY key,
DAPL_HASH_DATA data)
{
u32 dat_status = DAT_SUCCESS;
@@ -415,7 +415,7 @@ u32 dapl_hash_insert(DAPL_HASH_TABLE *p_
* data is returned in the DAPL_HASH_DATA
* pointer if that pointer is not NULL.
*/
-u32 dapl_hash_search(DAPL_HASH_TABLE *p_table, DAPL_HASH_KEY key,
+u32 dapl_hash_search(struct dapl_hash_table *p_table, DAPL_HASH_KEY key,
DAPL_HASH_DATA *p_data)
{
u32 dat_status;
@@ -439,7 +439,7 @@ u32 dapl_hash_search(DAPL_HASH_TABLE *p_
return dat_status;
}
-u32 dapl_hash_remove(DAPL_HASH_TABLE *p_table, DAPL_HASH_KEY key,
+u32 dapl_hash_remove(struct dapl_hash_table *p_table, DAPL_HASH_KEY key,
DAPL_HASH_DATA *p_data)
{
u32 dat_status;
Index: linux-kernel-resolv/dat-provider/dapl_sp_util.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_sp_util.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_sp_util.h (working copy)
@@ -37,16 +37,17 @@
#ifndef DAPL_PSP_UTIL_H
#define DAPL_PSP_UTIL_H
-DAPL_SP *dapl_sp_alloc(DAPL_IA * ia_ptr, boolean_t is_psp);
+struct dapl_sp *dapl_sp_alloc(struct dapl_ia *ia_ptr, boolean_t is_psp);
-void dapl_sp_dealloc(DAPL_SP * sp_ptr);
+void dapl_sp_dealloc(struct dapl_sp *sp_ptr);
-void dapl_sp_link_cr(DAPL_SP * sp_ptr, DAPL_CR * cr_ptr);
+void dapl_sp_link_cr(struct dapl_sp *sp_ptr, struct dapl_cr *cr_ptr);
-DAPL_CR *dapl_sp_search_cr(DAPL_SP * sp_ptr, struct dapl_cm_id *ib_cm_handle);
+struct dapl_cr *dapl_sp_search_cr(struct dapl_sp *sp_ptr,
+ struct dapl_cm_id *ib_cm_handle);
-void dapl_sp_remove_cr(DAPL_SP * sp_ptr, DAPL_CR * cr_ptr);
+void dapl_sp_remove_cr(struct dapl_sp *sp_ptr, struct dapl_cr *cr_ptr);
-void dapl_sp_remove_ep(DAPL_EP * ep_ptr);
+void dapl_sp_remove_ep(struct dapl_ep *ep_ptr);
-#endif /* DAPL_PSP_UTIL_H */
+#endif /* DAPL_PSP_UTIL_H */
Index: linux-kernel-resolv/dat-provider/dapl_ep_dup_connect.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ep_dup_connect.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ep_dup_connect.c (working copy)
@@ -73,12 +73,12 @@ u32 dapl_ep_dup_connect(DAT_EP_HANDLE ep
DAT_TIMEOUT timeout, int private_data_size,
const void *private_data, enum dat_qos qos)
{
- DAPL_EP *ep_dup_ptr;
+ struct dapl_ep *ep_dup_ptr;
struct sockaddr *remote_ia_address_ptr;
DAT_CONN_QUAL remote_conn_qual;
u32 dat_status;
- ep_dup_ptr = (DAPL_EP *) ep_dup_handle;
+ ep_dup_ptr = (struct dapl_ep *)ep_dup_handle;
/*
* Verify the dup handle, which must be connected. All other
Index: linux-kernel-resolv/dat-provider/dapl.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl.h (working copy)
@@ -123,7 +123,7 @@ typedef enum dapl_evd_completion {
#define DAPL_BAD_HANDLE(h, magicNum) ( \
((h) == NULL) || \
((unsigned long)(h) & 3) || \
- (((DAPL_HEADER *)(h))->magic != (magicNum)))
+ (((struct dapl_header *)(h))->magic != (magicNum)))
#define DAPL_MIN(a, b) ((a < b) ? (a) : (b))
#define DAPL_MAX(a, b) ((a > b) ? (a) : (b))
@@ -158,35 +158,9 @@ typedef struct ib_hca_transport {
u16 lid;
} ib_hca_transport_t;
-typedef struct dapl_llist_entry DAPL_LLIST_ENTRY;
-typedef DAPL_LLIST_ENTRY *DAPL_LLIST_HEAD;
-typedef struct dapl_ring_buffer DAPL_RING_BUFFER;
-typedef struct dapl_cookie_buffer DAPL_COOKIE_BUFFER;
-
-typedef struct dapl_hash_table DAPL_HASH_TABLE;
-typedef struct dapl_hash_table *DAPL_HASH_TABLEP;
typedef u64 DAPL_HASH_KEY;
typedef void *DAPL_HASH_DATA;
-typedef struct dapl_hca DAPL_HCA;
-
-typedef struct dapl_header DAPL_HEADER;
-
-typedef struct dapl_ia DAPL_IA;
-typedef struct dapl_cno DAPL_CNO;
-typedef struct dapl_evd DAPL_EVD;
-typedef struct dapl_ep DAPL_EP;
-typedef struct dapl_srq DAPL_SRQ;
-typedef struct dapl_pz DAPL_PZ;
-typedef struct dapl_lmr DAPL_LMR;
-typedef struct dapl_rmr DAPL_RMR;
-typedef struct dapl_sp DAPL_SP;
-typedef struct dapl_cr DAPL_CR;
-
-typedef struct dapl_cookie DAPL_COOKIE;
-typedef struct dapl_dto_cookie DAPL_DTO_COOKIE;
-typedef struct dapl_rmr_cookie DAPL_RMR_COOKIE;
-
/*********************************************************************
* *
* Structures *
@@ -197,7 +171,7 @@ struct dapl_llist_entry {
struct dapl_llist_entry *flink;
struct dapl_llist_entry *blink;
void *data;
- DAPL_LLIST_HEAD *list_head; /* for consistency checking */
+ struct dapl_llist_entry **list_head; /* for consistency checking */
};
struct dapl_ring_buffer {
@@ -208,7 +182,7 @@ struct dapl_ring_buffer {
};
struct dapl_cookie_buffer {
- DAPL_COOKIE *pool;
+ struct dapl_cookie *pool;
int pool_size;
atomic_t head;
atomic_t tail;
@@ -217,7 +191,7 @@ struct dapl_cookie_buffer {
struct dapl_hca {
spinlock_t lock;
unsigned long flags;
- DAPL_LLIST_HEAD ia_list_head; /* list of all open IAs */
+ struct dapl_llist_entry *ia_list_head; /* list of all open IAs */
atomic_t handle_ref_count; /* count of ia_opens on handle */
struct sockaddr_in6 hca_address; /* local address of HCA */
char *name; /* provider name */
@@ -225,7 +199,7 @@ struct dapl_hca {
u8 port_num; /* number of physical port */
ib_hca_transport_t ib_trans; /* Values specific transport API */
/* Memory Subsystem Support */
- DAPL_HASH_TABLE *lmr_hash_table;
+ struct dapl_hash_table *lmr_hash_table;
/* Limits & useful HCA attributes */
struct dat_ia_attr ia_attr;
struct dat_ep_attr ep_attr;
@@ -236,8 +210,8 @@ 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; /* struct type */
- DAPL_IA *owner_ia; /* ia which owns this stuct */
- DAPL_LLIST_ENTRY ia_list_entry; /* link entry on ia struct */
+ struct dapl_ia *owner_ia; /* ia which owns this struct */
+ struct dapl_llist_entry ia_list_entry; /* link entry on ia struct */
DAT_CONTEXT user_context; /* user context - opaque to DAPL */
spinlock_t lock; /* lock - in header for easier macros */
unsigned long flags; /* saved lock flag values */
@@ -245,32 +219,32 @@ struct dapl_header {
/* DAPL_IA maps to DAT_IA_HANDLE */
struct dapl_ia {
- DAPL_HEADER header;
- DAPL_HCA *hca_ptr;
- DAPL_EVD *async_error_evd;
+ struct dapl_header header; /* WARNING: must be first */
+ struct dapl_hca *hca_ptr;
+ struct dapl_evd *async_error_evd;
boolean_t cleanup_async_error_evd;
- DAPL_LLIST_ENTRY hca_ia_list_entry; /* HCAs list of IAs */
- DAPL_LLIST_HEAD ep_list_head; /* EP queue */
- DAPL_LLIST_HEAD lmr_list_head; /* LMR queue */
- DAPL_LLIST_HEAD rmr_list_head; /* RMR queue */
- DAPL_LLIST_HEAD pz_list_head; /* PZ queue */
- DAPL_LLIST_HEAD evd_list_head; /* EVD queue */
- DAPL_LLIST_HEAD psp_list_head; /* PSP queue */
- DAPL_LLIST_HEAD rsp_list_head; /* RSP queue */
- DAPL_LLIST_HEAD srq_list_head; /* SRQ queue */
+ struct dapl_llist_entry hca_ia_list_entry; /* HCAs list of IAs */
+ struct dapl_llist_entry *ep_list_head; /* EP queue */
+ struct dapl_llist_entry *lmr_list_head; /* LMR queue */
+ struct dapl_llist_entry *rmr_list_head; /* RMR queue */
+ struct dapl_llist_entry *pz_list_head; /* PZ queue */
+ struct dapl_llist_entry *evd_list_head; /* EVD queue */
+ struct dapl_llist_entry *psp_list_head; /* PSP queue */
+ struct dapl_llist_entry *rsp_list_head; /* RSP queue */
+ struct dapl_llist_entry *srq_list_head; /* SRQ queue */
};
/* DAPL_CNO maps to DAT_CNO_HANDLE */
struct dapl_cno {
- DAPL_HEADER header;
+ struct dapl_header header; /* WARNING: must be first */
struct dat_upcall_object cno_upcall;
enum dat_upcall_policy cno_upcall_policy;
};
/* DAPL_EVD maps to DAT_EVD_HANDLE */
struct dapl_evd {
- DAPL_HEADER header;
+ struct dapl_header header; /* WARNING: must be first */
DAPL_EVD_STATE evd_state;
enum dat_evd_flags evd_flags;
@@ -292,22 +266,22 @@ struct dapl_evd {
/* the actual events */
int qlen;
struct dat_event *events;
- DAPL_RING_BUFFER free_event_queue;
- DAPL_RING_BUFFER pending_event_queue;
- DAPL_CNO *cno_ptr;
+ struct dapl_ring_buffer free_event_queue;
+ struct dapl_ring_buffer pending_event_queue;
+ struct dapl_cno *cno_ptr;
};
/* uDAPL timer entry, used to queue timeouts */
struct dapl_timer_entry {
- DAPL_LLIST_ENTRY list_entry; /* link entry on ia struct */
+ struct dapl_llist_entry list_entry; /* link entry on ia struct */
DAPL_OS_TIMEVAL expires;
void (*function) (void *);
void *data;
};
-/* DAPL_EP maps to DAT_EP_HANDLE */
+/* struct dapl_ep maps to DAT_EP_HANDLE */
struct dapl_ep {
- DAPL_HEADER header;
+ struct dapl_header header; /* WARNING: must be first */
/* What the DAT Consumer asked for */
struct dat_ep_param param;
@@ -336,8 +310,8 @@ struct dapl_ep {
atomic_t req_count;
atomic_t recv_count;
- DAPL_COOKIE_BUFFER req_buffer;
- DAPL_COOKIE_BUFFER recv_buffer;
+ struct dapl_cookie_buffer req_buffer;
+ struct dapl_cookie_buffer recv_buffer;
struct ib_sge *recv_iov;
int recv_iov_num;
@@ -346,37 +320,37 @@ struct dapl_ep {
int send_iov_num;
};
-/* DAPL_SRQ maps to DAT_SRQ_HANDLE */
+/* struct dapl_srq maps to DAT_SRQ_HANDLE */
struct dapl_srq {
- DAPL_HEADER header;
+ struct dapl_header header; /* WARNING: must be first */
struct dat_srq_param param;
atomic_t srq_ref_count;
- DAPL_COOKIE_BUFFER recv_buffer;
+ struct dapl_cookie_buffer recv_buffer;
atomic_t recv_count;
};
-/* DAPL_PZ maps to DAT_PZ_HANDLE */
+/* struct dapl_pz maps to DAT_PZ_HANDLE */
struct dapl_pz {
- DAPL_HEADER header;
+ struct dapl_header header; /* WARNING: must be first */
struct ib_pd *pd_handle;
atomic_t pz_ref_count;
};
-/* DAPL_LMR maps to DAT_LMR_HANDLE */
+/* struct dapl_lmr maps to DAT_LMR_HANDLE */
struct dapl_lmr {
- DAPL_HEADER header;
+ struct dapl_header header; /* WARNING: must be first */
struct dat_lmr_param param;
struct ib_mr *mr_handle;
atomic_t lmr_ref_count;
};
-/* DAPL_RMR maps to DAT_RMR_HANDLE */
+/* struct dapl_rmr maps to DAT_RMR_HANDLE */
struct dapl_rmr {
- DAPL_HEADER header;
+ struct dapl_header header; /* WARNING: must be first */
struct dat_rmr_param param;
- DAPL_EP *ep;
- DAPL_PZ *pz;
- DAPL_LMR *lmr;
+ struct dapl_ep *ep;
+ struct dapl_pz *pz;
+ struct dapl_lmr *lmr;
struct ib_mw *mw_handle;
};
@@ -389,9 +363,9 @@ typedef enum dapl_sp_state {
DAPL_SP_STATE_RSP_PENDING
} DAPL_SP_STATE;
-/* DAPL_SP maps to DAT_PSP_HANDLE and DAT_RSP_HANDLE */
+/* struct dapl_sp maps to DAT_PSP_HANDLE and DAT_RSP_HANDLE */
struct dapl_sp {
- DAPL_HEADER header;
+ struct dapl_header header; /* WARNING: must be first */
DAPL_SP_STATE state; /* type and queue of the SP */
/* PSP/RSP PARAM fields */
@@ -404,13 +378,13 @@ struct dapl_sp {
/* maintenence fields */
boolean_t listening; /* PSP is registered & active */
struct ib_cm_id *cm_srvc_handle; /* Used by CM */
- DAPL_LLIST_HEAD cr_list_head; /* CR pending queue */
+ struct dapl_llist_entry *cr_list_head; /* CR pending queue */
int cr_list_count; /* count of CRs on queue */
};
-/* DAPL_CR maps to DAT_CR_HANDLE */
+/* struct dapl_cr maps to DAT_CR_HANDLE */
struct dapl_cr {
- DAPL_HEADER header;
+ struct dapl_header header; /* WARNING: must be first */
/* for convenience the data is kept as a struct dat_cr_param.
* however, the "local_endpoint" field is always NULL
@@ -430,7 +404,7 @@ struct dapl_cr {
* Need to be able to associate the CR back to the PSP for
* dapl_cr_reject.
*/
- DAPL_SP *sp_ptr;
+ struct dapl_sp *sp_ptr;
};
typedef enum dapl_dto_type {
@@ -446,27 +420,27 @@ typedef enum dapl_cookie_type {
DAPL_COOKIE_TYPE_RMR,
} DAPL_COOKIE_TYPE;
-/* DAPL_DTO_COOKIE used as context for DTO WQEs */
+/* struct dapl_dto_cookie used as context for DTO WQEs */
struct dapl_dto_cookie {
DAPL_DTO_TYPE type;
DAT_DTO_COOKIE cookie;
int size; /* used for SEND and RDMA write */
};
-/* DAPL_RMR_COOKIE used as context for bind WQEs */
+/* struct dapl_rmr_cookie used as context for bind WQEs */
struct dapl_rmr_cookie {
- DAPL_RMR *rmr;
+ struct dapl_rmr *rmr;
DAT_RMR_COOKIE cookie;
};
-/* DAPL_COOKIE used as context for WQEs */
+/* struct dapl_cookie used as context for WQEs */
struct dapl_cookie {
DAPL_COOKIE_TYPE type; /* Must be first, to define struct. */
- DAPL_EP *ep;
+ struct dapl_ep *ep;
int index;
union {
- DAPL_DTO_COOKIE dto;
- DAPL_RMR_COOKIE rmr;
+ struct dapl_dto_cookie dto;
+ struct dapl_rmr_cookie rmr;
} val;
};
@@ -737,34 +711,35 @@ extern u32 dapl_srq_set_lw(DAT_SRQ_HANDL
* DAPL internal utility function prototpyes
*/
-extern void dapl_llist_init_head(DAPL_LLIST_HEAD * head);
+extern void dapl_llist_init_head(struct dapl_llist_entry **head);
-extern void dapl_llist_init_entry(DAPL_LLIST_ENTRY * entry);
+extern void dapl_llist_init_entry(struct dapl_llist_entry *entry);
-extern boolean_t dapl_llist_is_empty(DAPL_LLIST_HEAD * head);
+extern boolean_t dapl_llist_is_empty(struct dapl_llist_entry **head);
-extern void dapl_llist_add_head(DAPL_LLIST_HEAD * head,
- DAPL_LLIST_ENTRY * entry, void *data);
+extern void dapl_llist_add_head(struct dapl_llist_entry **head,
+ struct dapl_llist_entry *entry, void *data);
-extern void dapl_llist_add_tail(DAPL_LLIST_HEAD * head,
- DAPL_LLIST_ENTRY * entry, void *data);
+extern void dapl_llist_add_tail(struct dapl_llist_entry **head,
+ struct dapl_llist_entry *entry, void *data);
-extern void dapl_llist_add_entry(DAPL_LLIST_HEAD * head,
- DAPL_LLIST_ENTRY * entry,
- DAPL_LLIST_ENTRY * new_entry, void *data);
+extern void dapl_llist_add_entry(struct dapl_llist_entry **head,
+ struct dapl_llist_entry *entry,
+ struct dapl_llist_entry *new_entry,
+ void *data);
-extern void *dapl_llist_remove_head(DAPL_LLIST_HEAD * head);
+extern void *dapl_llist_remove_head(struct dapl_llist_entry **head);
-extern void *dapl_llist_remove_tail(DAPL_LLIST_HEAD * head);
+extern void *dapl_llist_remove_tail(struct dapl_llist_entry **head);
-extern void *dapl_llist_remove_entry(DAPL_LLIST_HEAD * head,
- DAPL_LLIST_ENTRY * entry);
+extern void *dapl_llist_remove_entry(struct dapl_llist_entry **head,
+ struct dapl_llist_entry *entry);
-extern void *dapl_llist_peek_head(DAPL_LLIST_HEAD * head);
+extern void *dapl_llist_peek_head(struct dapl_llist_entry **head);
-extern void *dapl_llist_next_entry(DAPL_LLIST_HEAD * head,
- DAPL_LLIST_ENTRY * cur_ent);
+extern void *dapl_llist_next_entry(struct dapl_llist_entry **head,
+ struct dapl_llist_entry *cur_ent);
-extern void dapl_llist_debug_print_list(DAPL_LLIST_HEAD * head);
+extern void dapl_llist_debug_print_list(struct dapl_llist_entry **head);
#endif
Index: linux-kernel-resolv/dat-provider/dapl_psp_query.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_psp_query.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_psp_query.c (working copy)
@@ -40,11 +40,11 @@
u32 dapl_psp_query(DAT_PSP_HANDLE psp_handle, struct dat_psp_param *psp_param)
{
- DAPL_SP *sp_ptr;
+ struct dapl_sp *sp_ptr;
u32 status;
if (DAPL_BAD_HANDLE(psp_handle, DAPL_MAGIC_PSP) ||
- ((DAPL_SP *) psp_handle)->listening != TRUE) {
+ ((struct dapl_sp *)psp_handle)->listening != TRUE) {
status =
DAT_ERROR(DAT_INVALID_HANDLE, DAT_INVALID_HANDLE_PSP);
goto bail;
@@ -55,7 +55,7 @@ u32 dapl_psp_query(DAT_PSP_HANDLE psp_ha
goto bail;
}
- sp_ptr = (DAPL_SP *) psp_handle;
+ sp_ptr = (struct dapl_sp *)psp_handle;
psp_param->ia_handle = sp_ptr->ia_handle;
psp_param->conn_qual = sp_ptr->conn_qual;
@@ -64,6 +64,6 @@ u32 dapl_psp_query(DAT_PSP_HANDLE psp_ha
status = DAT_SUCCESS;
- bail:
+bail:
return status;
}
Index: linux-kernel-resolv/dat-provider/dapl_llist.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_llist.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_llist.c (working copy)
@@ -57,7 +57,7 @@
*
* Purpose: initialize a linked list head
*/
-void dapl_llist_init_head(DAPL_LLIST_HEAD * head)
+void dapl_llist_init_head(struct dapl_llist_entry **head)
{
*head = NULL;
}
@@ -67,7 +67,7 @@ void dapl_llist_init_head(DAPL_LLIST_HEA
*
* Purpose: initialize a linked list entry
*/
-void dapl_llist_init_entry(DAPL_LLIST_ENTRY * entry)
+void dapl_llist_init_entry(struct dapl_llist_entry *entry)
{
entry->blink = NULL;
entry->flink = NULL;
@@ -80,7 +80,7 @@ void dapl_llist_init_entry(DAPL_LLIST_EN
*
* Purpose: returns TRUE if the linked list is empty
*/
-boolean_t dapl_llist_is_empty(DAPL_LLIST_HEAD * head)
+boolean_t dapl_llist_is_empty(struct dapl_llist_entry **head)
{
return (*head == NULL);
}
@@ -91,10 +91,10 @@ boolean_t dapl_llist_is_empty(DAPL_LLIST
* Purpose: Add an entry to the head of a linked list
*/
void
-dapl_llist_add_head(DAPL_LLIST_HEAD * head,
- DAPL_LLIST_ENTRY * entry, void *data)
+dapl_llist_add_head(struct dapl_llist_entry **head,
+ struct dapl_llist_entry *entry, void *data)
{
- DAPL_LLIST_ENTRY *first;
+ struct dapl_llist_entry *first;
/* deal with empty list */
if (dapl_llist_is_empty(head)) {
@@ -119,10 +119,10 @@ dapl_llist_add_head(DAPL_LLIST_HEAD * he
* Purpose: Add an entry to the tail of a linked list
*/
void
-dapl_llist_add_tail(DAPL_LLIST_HEAD * head,
- DAPL_LLIST_ENTRY * entry, void *data)
+dapl_llist_add_tail(struct dapl_llist_entry **head,
+ struct dapl_llist_entry *entry, void *data)
{
- DAPL_LLIST_ENTRY *last;
+ struct dapl_llist_entry *last;
/* deal with empty list */
if (dapl_llist_is_empty(head)) {
@@ -147,12 +147,12 @@ dapl_llist_add_tail(DAPL_LLIST_HEAD * he
* not verify the list or the validity of the entries passed in.
*/
void
-dapl_llist_add_entry(DAPL_LLIST_HEAD * head,
- DAPL_LLIST_ENTRY * entry,
- DAPL_LLIST_ENTRY * new_entry, void *data)
+dapl_llist_add_entry(struct dapl_llist_entry **head,
+ struct dapl_llist_entry *entry,
+ struct dapl_llist_entry *new_entry, void *data)
{
- DAPL_LLIST_ENTRY *first;
- DAPL_LLIST_ENTRY *prev;
+ struct dapl_llist_entry *first;
+ struct dapl_llist_entry *prev;
/* get the head pointer */
first = *head;
@@ -180,9 +180,9 @@ dapl_llist_add_entry(DAPL_LLIST_HEAD * h
*
* Purpose: Remove the first entry of a linked list
*/
-void *dapl_llist_remove_head(DAPL_LLIST_HEAD * head)
+void *dapl_llist_remove_head(struct dapl_llist_entry **head)
{
- DAPL_LLIST_ENTRY *first;
+ struct dapl_llist_entry *first;
dapl_os_assert(!dapl_llist_is_empty(head));
first = *head;
@@ -206,9 +206,9 @@ void *dapl_llist_remove_head(DAPL_LLIST_
*
* Purpose: Remove the last entry of a linked list
*/
-void *dapl_llist_remove_tail(DAPL_LLIST_HEAD * head)
+void *dapl_llist_remove_tail(struct dapl_llist_entry **head)
{
- DAPL_LLIST_ENTRY *last;
+ struct dapl_llist_entry *last;
dapl_os_assert(!dapl_llist_is_empty(head));
last = (*head)->blink;
@@ -232,9 +232,10 @@ void *dapl_llist_remove_tail(DAPL_LLIST_
*
* Purpose: Remove the specified entry from a linked list
*/
-void *dapl_llist_remove_entry(DAPL_LLIST_HEAD * head, DAPL_LLIST_ENTRY * entry)
+void *dapl_llist_remove_entry(struct dapl_llist_entry **head,
+ struct dapl_llist_entry *entry)
{
- DAPL_LLIST_ENTRY *first;
+ struct dapl_llist_entry *first;
dapl_os_assert(!dapl_llist_is_empty(head));
first = *head;
@@ -263,9 +264,9 @@ void *dapl_llist_remove_entry(DAPL_LLIST
* dapl_llist_peek_head
*/
-void *dapl_llist_peek_head(DAPL_LLIST_HEAD * head)
+void *dapl_llist_peek_head(struct dapl_llist_entry **head)
{
- DAPL_LLIST_ENTRY *first;
+ struct dapl_llist_entry *first;
dapl_os_assert(!dapl_llist_is_empty(head));
first = *head;
@@ -279,9 +280,10 @@ void *dapl_llist_peek_head(DAPL_LLIST_HE
* head
*/
-void *dapl_llist_next_entry(DAPL_LLIST_HEAD * head, DAPL_LLIST_ENTRY * cur_ent)
+void *dapl_llist_next_entry(struct dapl_llist_entry **head,
+ struct dapl_llist_entry *cur_ent)
{
- DAPL_LLIST_ENTRY *next;
+ struct dapl_llist_entry *next;
dapl_os_assert(!dapl_llist_is_empty(head));
if (cur_ent == NULL) {
@@ -301,10 +303,10 @@ void *dapl_llist_next_entry(DAPL_LLIST_H
*
* Purpose: Prints the linked list for debugging
*/
-void dapl_llist_debug_print_list(DAPL_LLIST_HEAD * head)
+void dapl_llist_debug_print_list(struct dapl_llist_entry **head)
{
- DAPL_LLIST_ENTRY *entry;
- DAPL_LLIST_ENTRY *first;
+ struct dapl_llist_entry *entry;
+ struct dapl_llist_entry *first;
first = *head;
if (!first) {
dapl_dbg_log(DAPL_DBG_TYPE_UTIL, "EMPTY_LIST\n");
Index: linux-kernel-resolv/dat-provider/dapl_hash.h
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_hash.h (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_hash.h (working copy)
@@ -67,19 +67,19 @@
* *
*********************************************************************/
-extern u32 dapl_hash_create(int capacity, DAPL_HASH_TABLE **pp_table);
+extern u32 dapl_hash_create(int capacity, struct dapl_hash_table **pp_table);
-extern u32 dapl_hash_free(DAPL_HASH_TABLE *p_table);
+extern u32 dapl_hash_free(struct dapl_hash_table *p_table);
-extern u32 dapl_hash_size(DAPL_HASH_TABLE *p_table, int *p_size);
+extern u32 dapl_hash_size(struct dapl_hash_table *p_table, int *p_size);
-extern u32 dapl_hash_insert(DAPL_HASH_TABLE *p_table, DAPL_HASH_KEY key,
+extern u32 dapl_hash_insert(struct dapl_hash_table *p_table, DAPL_HASH_KEY key,
DAPL_HASH_DATA data);
-extern u32 dapl_hash_search(DAPL_HASH_TABLE *p_table, DAPL_HASH_KEY key,
+extern u32 dapl_hash_search(struct dapl_hash_table *p_table, DAPL_HASH_KEY key,
DAPL_HASH_DATA *p_data);
-extern u32 dapl_hash_remove(DAPL_HASH_TABLE *p_table, DAPL_HASH_KEY key,
+extern u32 dapl_hash_remove(struct dapl_hash_table *p_table, DAPL_HASH_KEY key,
DAPL_HASH_DATA *p_data);
#endif /* DAPL_HASH_H */
Index: linux-kernel-resolv/dat-provider/dapl_lmr_kcreate.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_lmr_kcreate.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_lmr_kcreate.c (working copy)
@@ -37,8 +37,8 @@
#include "dapl_lmr_util.h"
#include "dapl_openib_util.h"
-static inline u32 dapl_lmr_create_virtual(DAPL_IA *ia, void *virt_addr,
- u64 length, DAPL_PZ *pz,
+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,
DAT_LMR_CONTEXT *lmr_context,
@@ -46,7 +46,7 @@ static inline u32 dapl_lmr_create_virtua
u64 *registered_length,
u64 *registered_address)
{
- DAPL_LMR *lmr;
+ struct dapl_lmr *lmr;
DAT_REGION_DESCRIPTION reg_desc;
u32 dat_status = DAT_SUCCESS;
@@ -114,9 +114,9 @@ bail:
}
-static inline u32 dapl_lmr_create_physical(DAPL_IA *ia,
+static inline u32 dapl_lmr_create_physical(struct dapl_ia *ia,
DAT_REGION_DESCRIPTION phys_addr,
- u64 page_count, DAPL_PZ *pz,
+ u64 page_count, struct dapl_pz *pz,
enum dat_mem_priv_flags privileges,
DAT_LMR_HANDLE *lmr_handle,
DAT_LMR_CONTEXT *lmr_context,
@@ -124,7 +124,7 @@ static inline u32 dapl_lmr_create_physic
u64 *registered_length,
u64 *registered_address)
{
- DAPL_LMR *lmr;
+ struct dapl_lmr *lmr;
u32 dat_status = DAT_SUCCESS;
u64 *array = phys_addr.for_array;
@@ -190,8 +190,9 @@ bail:
return dat_status;
}
-static inline u32 dapl_lmr_create_lmr(DAPL_IA *ia, DAPL_LMR *original_lmr,
- DAPL_PZ *pz,
+static inline u32 dapl_lmr_create_lmr(struct dapl_ia *ia,
+ struct dapl_lmr *original_lmr,
+ struct dapl_pz *pz,
enum dat_mem_priv_flags privileges,
DAT_LMR_HANDLE *lmr_handle,
DAT_LMR_CONTEXT *lmr_context,
@@ -199,7 +200,7 @@ static inline u32 dapl_lmr_create_lmr(DA
u64 *registered_length,
u64 *registered_address)
{
- DAPL_LMR *lmr;
+ struct dapl_lmr *lmr;
DAT_REGION_DESCRIPTION reg_desc;
u32 dat_status;
@@ -309,8 +310,8 @@ u32 dapl_lmr_kcreate(DAT_IA_HANDLE ia_ha
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)
{
- DAPL_IA *ia;
- DAPL_PZ *pz;
+ struct dapl_ia *ia;
+ struct dapl_pz *pz;
u32 dat_status;
dapl_dbg_log(DAPL_DBG_TYPE_API,
@@ -328,8 +329,8 @@ u32 dapl_lmr_kcreate(DAT_IA_HANDLE ia_ha
goto bail;
}
- ia = (DAPL_IA *) ia_handle;
- pz = (DAPL_PZ *) pz_handle;
+ ia = (struct dapl_ia *)ia_handle;
+ pz = (struct dapl_pz *)pz_handle;
switch (mem_type) {
case DAT_MEM_TYPE_VIRTUAL:
@@ -358,7 +359,7 @@ u32 dapl_lmr_kcreate(DAT_IA_HANDLE ia_ha
}
case DAT_MEM_TYPE_LMR:
{
- DAPL_LMR *lmr;
+ struct dapl_lmr *lmr;
if (DAPL_BAD_HANDLE
(region_description.for_lmr_handle,
@@ -369,7 +370,7 @@ u32 dapl_lmr_kcreate(DAT_IA_HANDLE ia_ha
goto bail;
}
- lmr = (DAPL_LMR *) region_description.for_lmr_handle;
+ lmr = (struct dapl_lmr *)region_description.for_lmr_handle;
dat_status =
dapl_lmr_create_lmr(ia, lmr, pz, privileges,
@@ -394,6 +395,6 @@ u32 dapl_lmr_kcreate(DAT_IA_HANDLE ia_ha
}
}
- bail:
+bail:
return dat_status;
}
Index: linux-kernel-resolv/dat-provider/dapl_ep_post_recv.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ep_post_recv.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ep_post_recv.c (working copy)
@@ -71,8 +71,8 @@ u32 dapl_ep_post_recv(DAT_EP_HANDLE ep_h
DAT_DTO_COOKIE user_cookie,
enum dat_completion_flags completion_flags)
{
- DAPL_EP *ep_ptr;
- DAPL_COOKIE *cookie;
+ struct dapl_ep *ep_ptr;
+ struct dapl_cookie *cookie;
u32 dat_status;
dapl_dbg_log(DAPL_DBG_TYPE_API,
@@ -87,7 +87,7 @@ u32 dapl_ep_post_recv(DAT_EP_HANDLE ep_h
goto bail;
}
- ep_ptr = (DAPL_EP *) ep_handle;
+ ep_ptr = (struct dapl_ep *)ep_handle;
/*
* Synchronization ok since this buffer is only used for receive
Index: linux-kernel-resolv/dat-provider/dapl_cr_query.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_cr_query.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_cr_query.c (working copy)
@@ -36,7 +36,7 @@
u32 dapl_cr_query(DAT_CR_HANDLE cr_handle, struct dat_cr_param *cr_param)
{
- DAPL_CR *cr_ptr;
+ struct dapl_cr *cr_ptr;
u32 status;
dapl_dbg_log(DAPL_DBG_TYPE_API,
@@ -53,7 +53,7 @@ u32 dapl_cr_query(DAT_CR_HANDLE cr_handl
goto bail;
}
- cr_ptr = (DAPL_CR *) cr_handle;
+ cr_ptr = (struct dapl_cr *)cr_handle;
/* obtain the remote IP address */
(void) dapl_ib_cm_remote_addr((DAT_HANDLE) cr_handle,
@@ -64,6 +64,6 @@ u32 dapl_cr_query(DAT_CR_HANDLE cr_handl
status = DAT_SUCCESS;
- bail:
+bail:
return status;
}
Index: linux-kernel-resolv/dat-provider/dapl_rsp_query.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_rsp_query.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_rsp_query.c (working copy)
@@ -40,7 +40,7 @@
u32 dapl_rsp_query(DAT_RSP_HANDLE rsp_handle, struct dat_rsp_param *rsp_param)
{
- DAPL_SP *sp_ptr;
+ struct dapl_sp *sp_ptr;
u32 status;
if (DAPL_BAD_HANDLE(rsp_handle, DAPL_MAGIC_RSP)) {
@@ -53,7 +53,7 @@ u32 dapl_rsp_query(DAT_RSP_HANDLE rsp_ha
goto bail;
}
- sp_ptr = (DAPL_SP *) rsp_handle;
+ sp_ptr = (struct dapl_sp *)rsp_handle;
/*
* Fill in the RSP params
@@ -65,6 +65,6 @@ u32 dapl_rsp_query(DAT_RSP_HANDLE rsp_ha
status = DAT_SUCCESS;
- bail:
+bail:
return status;
}
Index: linux-kernel-resolv/dat-provider/dapl_pz_free.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_pz_free.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_pz_free.c (working copy)
@@ -56,7 +56,7 @@
*/
u32 dapl_pz_free(DAT_PZ_HANDLE pz_handle)
{
- DAPL_PZ *pz;
+ struct dapl_pz *pz;
u32 dat_status = DAT_SUCCESS;
dapl_dbg_log(DAPL_DBG_TYPE_API, "dapl_pz_free (%p)\n", pz_handle);
@@ -67,7 +67,7 @@ u32 dapl_pz_free(DAT_PZ_HANDLE pz_handle
goto bail;
}
- pz = (DAPL_PZ *) pz_handle;
+ pz = (struct dapl_pz *)pz_handle;
if (0 != atomic_read(&pz->pz_ref_count)) {
dat_status =
Index: linux-kernel-resolv/dat-provider/dapl_ep_set_watermark.c
===================================================================
--- linux-kernel-resolv/dat-provider/dapl_ep_set_watermark.c (revision 2431)
+++ linux-kernel-resolv/dat-provider/dapl_ep_set_watermark.c (working copy)
@@ -63,13 +63,13 @@ u32 dapl_ep_set_watermark(DAT_EP_HANDLE
int soft_high_watermark,
int hard_high_watermark)
{
- DAPL_EP *ep_ptr;
+ struct dapl_ep *ep_ptr;
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_ptr = (DAPL_EP *) ep_handle;
+ ep_ptr = (struct dapl_ep *)ep_handle;
/*
* Verify parameter & state
More information about the general
mailing list