#include "al_cm_cep.h"\r
#include "al_common.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al.tmh"\r
+#endif\r
+\r
#include "al_mad_pool.h"\r
#include "al_mgr.h"\r
#include "al_verbs.h"\r
IN const ib_al_handle_t h_al )\r
#endif\r
{\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MGR );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
\r
ref_al_obj( &h_al->obj );\r
h_al->obj.pfn_destroy( &h_al->obj, NULL );\r
\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
return IB_SUCCESS;\r
}\r
\r
status = ib_put_mad( &p_mad_element->element );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_put_mad failed with status %s, continuing.\n",\r
ib_get_err_str(status)) );\r
}\r
ib_ca_handle_t h_ca;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !p_size )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = ib_query_ca( h_ca, p_ca_attr, p_size );\r
deref_al_obj( &h_ca->obj );\r
\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return status;\r
}\r
\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return;\r
}\r
\r
#include "al.h"\r
#include "al_av.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_av.tmh"\r
+#endif\r
+\r
#include "al_pd.h"\r
#include "al_res_mgr.h"\r
#include "al_verbs.h"\r
\r
if( !p_av_attr || !ph_av )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
\r
ib_destroy_av(\r
IN const ib_av_handle_t h_av )\r
{\r
- CL_ENTER( AL_DBG_AV, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_AV );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_av, AL_OBJ_TYPE_H_AV ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AV_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AV_HANDLE\n") );\r
return IB_INVALID_AV_HANDLE;\r
}\r
\r
ref_al_obj( &h_av->obj );\r
h_av->obj.pfn_destroy( &h_av->obj, NULL );\r
\r
- CL_EXIT( AL_DBG_AV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AV );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_AV, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_AV );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_av, AL_OBJ_TYPE_H_AV ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AV_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AV_HANDLE\n") );\r
return IB_INVALID_AV_HANDLE;\r
}\r
if( !p_av_attr || !ph_pd )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
h_av->av_attr = *p_av_attr;\r
}\r
\r
- CL_EXIT( AL_DBG_AV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AV );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_AV, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_AV );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_av, AL_OBJ_TYPE_H_AV ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AV_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AV_HANDLE\n") );\r
return IB_INVALID_AV_HANDLE;\r
}\r
if( !p_av_mod )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
h_av->av_attr = *p_av_mod;\r
}\r
\r
- CL_EXIT( AL_DBG_AV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AV );\r
return status;\r
}\r
#include "al_ca.h"\r
#include "al_cq.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_ca.tmh"\r
+#endif\r
+\r
#include "al_mgr.h"\r
#include "al_mr.h"\r
#include "al_mw.h"\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
\r
ib_api_status_t status;\r
al_obj_type_t obj_type = AL_OBJ_TYPE_H_CA;\r
\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
if( !ph_ca )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
h_ca = (ib_ca_handle_t)cl_zalloc( sizeof( ib_ca_t ) );\r
if( !h_ca )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("IB_INSUFFICIENT_MEMORY\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( status != IB_SUCCESS )\r
{\r
__free_ca( &h_ca->obj );\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return status;\r
}\r
\r
if( !h_ca->obj.p_ci_ca )\r
{\r
h_ca->obj.pfn_destroy( &h_ca->obj, NULL );\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return IB_INVALID_GUID;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
h_ca->obj.pfn_destroy( &h_ca->obj, NULL );\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return status;\r
}\r
}\r
\r
*ph_ca = h_ca;\r
\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return IB_SUCCESS;\r
}\r
\r
IN const ib_ca_handle_t h_ca,\r
IN const ib_pfn_destroy_cb_t pfn_destroy_cb OPTIONAL )\r
{\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_ca, AL_OBJ_TYPE_H_CA ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_CA_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_CA_HANDLE\n") );\r
return IB_INVALID_CA_HANDLE;\r
}\r
\r
ref_al_obj( &h_ca->obj );\r
h_ca->obj.pfn_destroy( &h_ca->obj, pfn_destroy_cb );\r
\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_ca, AL_OBJ_TYPE_H_CA ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_CA_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_CA_HANDLE\n") );\r
return IB_INVALID_CA_HANDLE;\r
}\r
if( !p_size )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = verbs_query_ca( h_ca, p_ca_attr, p_size );\r
\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_ca, AL_OBJ_TYPE_H_CA ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_CA_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_CA_HANDLE\n") );\r
return IB_INVALID_CA_HANDLE;\r
}\r
if( !p_port_attr_mod )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = verbs_modify_ca(h_ca, port_num, ca_mod, p_port_attr_mod);\r
\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_PD, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PD );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_ca, AL_OBJ_TYPE_H_CA ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_CA_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_CA_HANDLE\n") );\r
return IB_INVALID_CA_HANDLE;\r
}\r
\r
if( status == IB_SUCCESS )\r
deref_al_obj( &(*ph_pd)->obj );\r
\r
- CL_EXIT( AL_DBG_PD, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PD );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CQ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CQ );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_ca, AL_OBJ_TYPE_H_CA ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_CA_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_CA_HANDLE\n") );\r
return IB_INVALID_CA_HANDLE;\r
}\r
\r
if( status == IB_SUCCESS )\r
deref_al_obj( &(*ph_cq)->obj );\r
\r
- CL_EXIT( AL_DBG_CQ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return status;\r
}\r
\r
#include "al_common.h"\r
#include "al_cq.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_ci_ca_shared.tmh"\r
+#endif\r
+\r
#include "al_mgr.h"\r
#include "al_pnp.h"\r
#include "al_qp.h"\r
uint32_t attr_size;\r
uint8_t i;\r
\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
/* Get the size of the CA attribute structure. */\r
status = ib_query_ca( p_ci_ca->h_ca, NULL, &attr_size );\r
if( status != IB_INSUFFICIENT_MEMORY )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_query_ca failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
p_ca_attr = cl_malloc( attr_size );\r
if( !p_ca_attr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_malloc failed to allocate p_ca_attr!\n") );\r
return IB_INSUFFICIENT_RESOURCES;\r
}\r
{\r
cl_free( p_ca_attr );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_query_ca failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
{\r
cl_free( p_ca_attr );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_malloc failed to allocate port_array!\n") );\r
return IB_INSUFFICIENT_RESOURCES;\r
}\r
\r
cl_free( p_ca_attr );\r
\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return IB_SUCCESS;\r
}\r
\r
cl_pool_item_t* p_item;\r
event_item_t* p_event_item;\r
\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
CL_ASSERT( p_event_rec );\r
\r
{\r
/* Ignore events if the object is being destroyed. */\r
cl_spinlock_release( &p_obj->lock );\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return;\r
}\r
\r
{\r
/* Could not get an item. This event will not be reported. */\r
cl_spinlock_release( &p_obj->lock );\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return;\r
}\r
\r
p_event_item->async_item.pfn_callback = ci_ca_process_event_cb;\r
cl_async_proc_queue( gp_async_proc_mgr, &p_event_item->async_item );\r
\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
}\r
\r
\r
event_item_t* p_event_item;\r
al_obj_t* p_obj;\r
\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
CL_ASSERT( p_async_item );\r
\r
/* Dereference the object. */\r
deref_al_obj( p_obj );\r
\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
}\r
\r
\r
uintn_t port_index, gid_index;\r
ib_port_attr_t *p_port_attr;\r
\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
if( !p_ca_attr || !p_gid )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("No p_ca_attr or p_gid.\n") );\r
return NULL;\r
}\r
if( !cl_memcmp( &p_port_attr->p_gid_table[gid_index],\r
p_gid, sizeof(ib_gid_t) ) )\r
{\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return p_port_attr;\r
}\r
}\r
}\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("No match found.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("No match found.\n") );\r
return NULL;\r
}\r
\r
uint32_t attr_size;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
/* Query to get the CA attributes size. */\r
attr_size = 0;\r
p_pnp_attr = (ib_ca_attr_t*)cl_zalloc( attr_size * 2 );\r
if( !p_pnp_attr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CA, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_CA,\r
("Unable to allocate buffer for PnP attributes\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
status = ib_query_ca( p_ci_ca->h_ca, p_pnp_attr, &attr_size );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CA, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_CA,\r
("Unable to query attributes\n") );\r
cl_free( p_pnp_attr );\r
return status;\r
p_ci_ca->p_user_attr = (ib_ca_attr_t*)(((uint8_t*)p_pnp_attr) + attr_size);\r
ci_ca_unlock_attr( p_ci_ca );\r
\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return IB_SUCCESS;\r
}\r
\r
#include "al_debug.h"\r
\r
\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_cm_qp.tmh"\r
+#endif\r
+\r
typedef struct _al_listen\r
{\r
al_obj_t obj;\r
( (h_qp->obj.state != CL_INITIALIZED) && \r
(h_qp->obj.state != CL_DESTROYING) ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_CM, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return;\r
}\r
\r
status = h_qp->pfn_modify_qp( h_qp, &qp_mod, NULL );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("pfn_modify_qp to IB_QPS_ERROR returned %s\n",\r
ib_get_err_str( status )) );\r
return;\r
__proc_dconn_timeout( h_qp );\r
break;\r
default:\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid CM send MAD attribute ID %d.\n", p_mad->attr_id) );\r
break;\r
}\r
status = al_cep_get_rts_attr( p_cm->h_al, p_cm->cid, &qp_mod );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_cep_get_rts_attr returned %s.\n", ib_get_err_str(status)) );\r
goto done;\r
}\r
status = ib_modify_qp( p_cm->h_qp, &qp_mod );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_modify_qp for LAP returned %s.\n", ib_get_err_str(status)) );\r
}\r
\r
// break;\r
\r
default:\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid CM recv MAD attribute ID %d.\n", p_mad->attr_id) );\r
}\r
\r
p_async_mad = (cep_async_mad_t*)cl_zalloc( sizeof(cep_async_mad_t) );\r
if( !p_async_mad )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("failed to cl_zalloc cm_async_mad_t (%d bytes)\n",\r
sizeof(cep_async_mad_t)) );\r
return;\r
status = ib_modify_qp( h_qp, &qp_mod );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_modify_qp to IB_QPS_RESET returned %s\n",\r
ib_get_err_str(status) ) );\r
}\r
status = ib_modify_qp( h_qp, p_init );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_modify_qp returned %s.\n", ib_get_err_str(status) ) );\r
return status;\r
}\r
((al_conn_qp_t*)p_cm_req->h_qp)->cid, p_cm_req, &qp_mod );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_cep_pre_req returned %s.\n", ib_get_err_str( status )) );\r
return status;\r
}\r
status = __cep_init_qp( p_cm_req->h_qp, &qp_mod );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__cep_init_qp returned %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
status = al_create_cep( h_al, __cm_handler, p_cm_req->h_qp, &cid );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_create_cep returned %s.\n", ib_get_err_str( status )) );\r
goto done;\r
}\r
status = __cep_pre_req( p_cm_req );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__cep_pre_req returned %s.\n", ib_get_err_str( status )) );\r
goto err;\r
}\r
//if( p_sync_event )\r
// cl_event_destroy( p_sync_event );\r
\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_cep_send_req returned %s.\n", ib_get_err_str(status)) );\r
err:\r
ref_al_obj( &p_qp->qp.obj );\r
/* wait on event if synchronous operation */\r
//if( p_sync_event )\r
//{\r
- // CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,\r
+ // AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
// ("event blocked on REQ...\n") );\r
// cl_event_wait_on( p_sync_event, EVENT_NO_TIMEOUT, FALSE );\r
\r
\r
if( !p_cm_req )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
switch( p_cm_req->qp_type )\r
{\r
default:\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Invalid qp_type.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid qp_type.\n") );\r
return IB_INVALID_SETTING;\r
\r
case IB_QPT_RELIABLE_CONN:\r
if( AL_OBJ_INVALID_HANDLE( p_cm_req->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
(p_cm_req->h_qp->type != p_cm_req->qp_type) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
\r
case IB_QPT_UNRELIABLE_DGRM:\r
if( AL_OBJ_INVALID_HANDLE( p_cm_req->h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
status = IB_UNSUPPORTED;\r
status = al_cep_get_rtr_attr( h_cm.h_al, h_cm.cid, &qp_mod );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_cep_get_rtr_attr returned %s\n", ib_get_err_str( status )) );\r
return status;\r
}\r
status = ib_modify_qp( h_qp, &qp_mod );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_modify_qp to RTR returned %s.\n", ib_get_err_str(status) ) );\r
return status;\r
}\r
status = al_cep_get_rts_attr( h_cm.h_al, h_cm.cid, &qp_mod );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_cep_get_rts_attr returned %s\n", ib_get_err_str( status )) );\r
return status;\r
}\r
status = ib_modify_qp( h_qp, &qp_mod );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_modify_qp to RTS returned %s.\n", ib_get_err_str(status) ) );\r
return status;\r
}\r
status = __cep_init_qp( p_cm_rep->h_qp, p_qp_mod );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cm_init_qp returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
(ib_recv_wr_t** __ptr64)p_cm_rep->pp_recv_failure );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_post_recv returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
p_cm_rep->access_ctrl, p_cm_rep->sq_depth, p_cm_rep->rq_depth );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__cep_rts_qp returned %s.\n", ib_get_err_str(status)) );\r
}\r
\r
if( cid != AL_INVALID_CID )\r
{\r
/* We don't destroy the CEP to allow the user to retry accepting. */\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("QP already connected.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("QP already connected.\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
\r
h_cm.h_al, h_cm.cid, p_cm_rep->h_qp, p_cm_rep, &qp_mod );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_cep_pre_rep returned %s.\n", ib_get_err_str( status )) );\r
goto err;\r
}\r
status = __cep_pre_rep( h_cm, &qp_mod, p_cm_rep );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__cep_pre_req returned %s\n", ib_get_err_str(status)) );\r
goto err;\r
}\r
status = al_cep_send_rep( h_cm.h_al, h_cm.cid );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_cep_send_rep returned %s\n", ib_get_err_str(status)) );\r
err:\r
cl_atomic_xchg(\r
\r
if( !p_cm_rep )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
switch( p_cm_rep->qp_type )\r
{\r
default:\r
- AL_TRACE( AL_DBG_ERROR, ("Invalid qp_type.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid qp_type.\n") );\r
status = IB_INVALID_SETTING;\r
break;\r
\r
if( AL_OBJ_INVALID_HANDLE( p_cm_rep->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
(p_cm_rep->h_qp->type != p_cm_rep->qp_type) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
status = IB_INVALID_QP_HANDLE;\r
}\r
else if( p_cm_rep->h_qp->obj.h_al != h_cm_req.h_al )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
status = IB_INVALID_QP_HANDLE;\r
}\r
break;\r
(AL_OBJ_INVALID_HANDLE( p_cm_rep->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
(p_cm_rep->h_qp->type != p_cm_rep->qp_type) ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
status = IB_INVALID_QP_HANDLE;\r
}\r
break;\r
\r
if( !p_cm_rtu )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
// */\r
//if( p_conn->p_sync_event )\r
//{\r
- // CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ // AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
// ("Connection in invalid state. Sync call in progress.\n" ) );\r
\r
// cm_res_release( p_conn );\r
p_cm_rtu->access_ctrl, p_cm_rtu->sq_depth, p_cm_rtu->rq_depth );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__cep_rts_qp returned %s.\n", ib_get_err_str( status )) );\r
goto err;\r
}\r
}\r
}\r
\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_cep_rtu returned %s.\n", ib_get_err_str( status )) );\r
return status;\r
}\r
\r
if( !p_cm_mra )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = al_cep_mra( h_cm.h_al, h_cm.cid, p_cm_mra );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_cep_mra returned %s\n", ib_get_err_str( status )) );\r
}\r
\r
\r
if( !p_cm_rej )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
\r
if( !p_cm_dreq )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
switch( p_cm_dreq->qp_type )\r
{\r
default:\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Invalid qp_type.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid qp_type.\n") );\r
return IB_INVALID_SETTING;\r
\r
case IB_QPT_RELIABLE_CONN:\r
if( AL_OBJ_INVALID_HANDLE( p_cm_dreq->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
(p_cm_dreq->h_qp->type != p_cm_dreq->qp_type) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
break;\r
\r
if( !p_cm_drep )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
\r
if( !p_cm_lap )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
switch( p_cm_lap->qp_type )\r
{\r
default:\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Invalid qp_type.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid qp_type.\n") );\r
return IB_INVALID_SETTING;\r
\r
case IB_QPT_RELIABLE_CONN:\r
if( AL_OBJ_INVALID_HANDLE( p_cm_lap->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
(p_cm_lap->h_qp->type != p_cm_lap->qp_type) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
break;\r
((al_conn_qp_t*)p_cm_lap->h_qp)->cid, p_cm_lap );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_cep_lap returned %s.\n", ib_get_err_str( status )) );\r
}\r
\r
\r
if( !p_cm_apr )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
switch( p_cm_apr->qp_type )\r
{\r
default:\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Invalid qp_type.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid qp_type.\n") );\r
return IB_INVALID_SETTING;\r
\r
case IB_QPT_RELIABLE_CONN:\r
if( AL_OBJ_INVALID_HANDLE( p_cm_apr->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
(p_cm_apr->h_qp->type != p_cm_apr->qp_type) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
break;\r
status = al_cep_pre_apr( h_cm_lap.h_al, h_cm_lap.cid, p_cm_apr, &qp_mod );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_cep_pre_apr returned %s.\n", ib_get_err_str( status )) );\r
return status;\r
}\r
status = ib_modify_qp( h_cm_lap.h_qp, &qp_mod );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_modify_qp for LAP returned %s.\n",\r
ib_get_err_str( status )) );\r
return status;\r
\r
if( AL_OBJ_INVALID_HANDLE( h_qp, AL_OBJ_TYPE_H_QP ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
\r
p_obj->h_al, p_listen->cid, deref_al_obj );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_destroy_cep returned %s.\n", ib_get_err_str( status )) );\r
deref_al_obj( p_obj );\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_listen->obj.pfn_destroy( &p_listen->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_listen->obj.pfn_destroy( &p_listen->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_create_cep returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_listen->obj.pfn_destroy( &p_listen->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_cep_listen returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !p_cm_listen || !pfn_listen_err_cb || !ph_cm_listen )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = __cep_listen(h_al, p_cm_listen, pfn_listen_err_cb, listen_context,\r
ph_cm_listen );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
\r
if( AL_OBJ_INVALID_HANDLE( h_cm_listen, AL_OBJ_TYPE_H_LISTEN ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
\r
ib_qp_mod_t qp_mod;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_memclr( &qp_mod, sizeof(ib_qp_mod_t) );\r
qp_mod.req_state = IB_QPS_RESET;\r
status = ib_modify_qp( h_qp, &qp_mod );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_modify_qp to IB_QPS_RESET returned %s\n",\r
ib_get_err_str(status) ) );\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
ib_qp_mod_t qp_mod;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_memclr( &qp_mod, sizeof(ib_qp_mod_t) );\r
qp_mod.req_state = IB_QPS_INIT;\r
if( !p_port_attr )\r
{\r
ci_ca_unlock_attr( h_qp->obj.p_ci_ca );\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl, ("invalid p_gid\n" ) );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("invalid p_gid\n" ) );\r
return IB_INVALID_GID;\r
}\r
\r
\r
if( qp_mod.state.init.pkey_index == BAD_PKEY_INDEX )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl, ("invalid PKEY\n" ) );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("invalid PKEY\n" ) );\r
return IB_INVALID_PKEY;\r
}\r
\r
status = ib_modify_qp( h_qp, &qp_mod );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_modify_qp to IB_QPS_INIT returned %s\n",\r
ib_get_err_str(status) ) );\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
status = __reset_qp( h_qp );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__reset_qp returned %s\n", ib_get_err_str(status) ) );\r
return status;\r
}\r
status = __init_qp( h_qp, p_gid, pkey, access_ctrl );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__init_qp returned %s.\n", ib_get_err_str(status) ) );\r
return status;\r
}\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Set the QP to RTR. */\r
status = ib_modify_qp( h_qp, p_qp_mod_rtr );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_modify_qp to RTR returned %s.\n", ib_get_err_str(status) ) );\r
return status;\r
}\r
status = ib_modify_qp( h_qp, p_qp_mod_rts );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_modify_qp to RTS returned %s.\n", ib_get_err_str(status) ) );\r
return status;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
ib_qp_mod_t qp_mod;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Special checks on the QP state for error handling - see above. */\r
if( !h_qp || !AL_OBJ_IS_TYPE( h_qp, AL_OBJ_TYPE_H_QP ) ||\r
( (h_qp->obj.state != CL_INITIALIZED) && \r
(h_qp->obj.state != CL_DESTROYING) ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_CM, ("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
\r
status = h_qp->pfn_modify_qp( h_qp, &qp_mod, NULL );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("pfn_modify_qp to IB_QPS_ERROR returned %s\n",\r
ib_get_err_str(status) ) );\r
return status;\r
UNUSED_PARAM( timewait );\r
#endif /* CL_KERNEL */\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
IN OUT ib_qp_mod_t * const p_qp_mod_rtr,\r
IN OUT ib_qp_mod_t * const p_qp_mod_rts )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Update the QP RTR transition information. */\r
p_qp_mod_rtr->state.rtr.rq_psn = p_cm_rep->h_qp->num;\r
cm_local_ack_timeout( ib_path_rec_pkt_life( p_path_rec ),\r
p_cm_rep->target_ack_delay );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
IN const ib_cm_rtu_t * const p_cm_rtu,\r
IN OUT ib_qp_mod_t * const p_qp_mod_rtr )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Update the QP RTR transition information. */\r
if( p_cm_rtu->access_ctrl )\r
p_qp_mod_rtr->state.rtr.rq_depth = p_cm_rtu->rq_depth;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
#include "al_ci_ca.h"\r
#include "al_common.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_common.tmh"\r
+#endif\r
+\r
#include "al_mgr.h"\r
#include <complib/cl_math.h>\r
#include "ib_common.h"\r
IN const ib_pfn_destroy_cb_t pfn_destroy_cb );\r
\r
\r
-#if defined( _DEBUG_ )\r
+\r
const char* ib_obj_type_str[] =\r
{\r
"AL_OBJ_TYPE_UNKNOWN",\r
"AL_OBJ_TYPE_H_SA_REG",\r
"AL_OBJ_TYPE_H_FMR"\r
};\r
-#endif\r
\r
\r
/*\r
{\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_AL_OBJ );\r
CL_ASSERT( p_obj && pfn_free );\r
CL_ASSERT( p_obj->state == CL_UNINITIALIZED );\r
- CL_TRACE( AL_DBG_AL_OBJ, g_al_dbg_lvl, ("%p\n", p_obj ) );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_AL_OBJ, ("%p\n", p_obj ) );\r
\r
/* Initialize the object. */\r
p_obj->async_item.pfn_callback = async_destroy_cb;\r
*/\r
ref_al_obj( p_obj );\r
\r
- CL_EXIT( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AL_OBJ );\r
return IB_SUCCESS;\r
}\r
\r
\r
CL_ASSERT( p_child_obj->state == CL_INITIALIZED );\r
\r
- AL_TRACE( AL_DBG_AL_OBJ,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_AL_OBJ,\r
("%p(%s) to %p(%s)\n",\r
p_child_obj, ib_get_obj_type( p_child_obj ),\r
p_parent_obj, ib_get_obj_type( p_parent_obj ) ) );\r
{\r
al_obj_t *p_parent_obj;\r
\r
- CL_ENTER( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_AL_OBJ );\r
\r
p_parent_obj = p_obj->p_parent_obj;\r
CL_ASSERT( p_obj );\r
CL_ASSERT( p_parent_obj->state == CL_INITIALIZED ||\r
p_parent_obj->state == CL_DESTROYING );\r
\r
- CL_TRACE( AL_DBG_AL_OBJ, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_AL_OBJ,\r
("%p(%s) from %p(%s)\n",\r
p_obj, ib_get_obj_type( p_obj ),\r
p_parent_obj, ib_get_obj_type( p_parent_obj ) ) );\r
cl_qlist_remove_item( &p_parent_obj->obj_list,\r
(cl_list_item_t*)&p_obj->pool_item );\r
cl_spinlock_release( &p_parent_obj->lock );\r
- CL_EXIT( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AL_OBJ );\r
}\r
\r
\r
{\r
uint32_t ref_cnt;\r
\r
- CL_ENTER( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
- CL_TRACE( AL_DBG_AL_OBJ, g_al_dbg_lvl,\r
+ AL_ENTER( AL_DBG_AL_OBJ );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_AL_OBJ,\r
("%p(%s)\n", p_obj, ib_get_obj_type( p_obj ) ) );\r
ref_cnt = cl_atomic_inc( &p_obj->ref_cnt );\r
CL_ASSERT( ref_cnt != 1 || p_obj->type == AL_OBJ_TYPE_H_CQ );\r
\r
- CL_EXIT( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AL_OBJ );\r
return ref_cnt;\r
}\r
\r
{\r
int32_t ref_cnt;\r
\r
- CL_ENTER( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_AL_OBJ );\r
\r
CL_ASSERT( p_obj );\r
CL_ASSERT( p_obj->state == CL_INITIALIZED ||\r
p_obj->state == CL_DESTROYING );\r
CL_ASSERT( p_obj->ref_cnt );\r
\r
- CL_TRACE( AL_DBG_AL_OBJ, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_AL_OBJ,\r
("%p(%s)\n", p_obj, ib_get_obj_type( p_obj ) ) );\r
\r
ref_cnt = cl_atomic_dec( &p_obj->ref_cnt );\r
}\r
}\r
\r
- CL_EXIT( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AL_OBJ );\r
return ref_cnt;\r
}\r
\r
destroy_al_obj(\r
IN al_obj_t * const p_obj )\r
{\r
- CL_ENTER( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_AL_OBJ );\r
\r
CL_ASSERT( p_obj );\r
CL_ASSERT( p_obj->state == CL_DESTROYING ||\r
cl_spinlock_destroy( &p_obj->lock );\r
p_obj->state = CL_DESTROYED;\r
\r
- CL_EXIT( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AL_OBJ );\r
}\r
\r
\r
IN struct _al_obj *p_obj,\r
IN const ib_pfn_destroy_cb_t pfn_destroy_cb )\r
{\r
- CL_ENTER( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_AL_OBJ );\r
\r
if( pfn_destroy_cb == ib_sync_destroy )\r
sync_destroy_obj( p_obj, pfn_destroy_cb );\r
else if( destroy_obj( p_obj, pfn_destroy_cb ) )\r
deref_al_obj( p_obj ); /* Only destroy the object once. */\r
\r
- CL_EXIT( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AL_OBJ );\r
}\r
\r
\r
{\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_AL_OBJ );\r
\r
if( !destroy_obj( p_obj, pfn_destroy_cb ) )\r
{\r
\r
if( cl_status != CL_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Error waiting for references to be released - delaying.\n") );\r
print_al_obj( p_obj );\r
/*\r
CL_ASSERT( cl_status == CL_SUCCESS );\r
if( cl_status != CL_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Forcing object destruction.\n") );\r
print_al_obj( p_obj );\r
//print_tail_al_objs();\r
}\r
async_destroy_cb( &p_obj->async_item );\r
\r
- CL_EXIT( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AL_OBJ );\r
}\r
\r
\r
cl_list_item_t *p_list_item;\r
al_obj_t *p_child_obj;\r
\r
- CL_ENTER( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_AL_OBJ );\r
\r
CL_ASSERT( p_obj );\r
CL_ASSERT( p_obj->state == CL_INITIALIZED ||\r
p_obj->state == CL_DESTROYING );\r
\r
- CL_TRACE( AL_DBG_AL_OBJ, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_AL_OBJ,\r
("%p(%s)\n", p_obj, ib_get_obj_type( p_obj ) ) );\r
\r
/*\r
detach_al_obj( p_obj );\r
\r
/* Destroy all child resources. No need to lock during destruction. */\r
- CL_TRACE( AL_DBG_AL_OBJ, g_al_dbg_lvl, ("destroying children\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_AL_OBJ, ("destroying children\n") );\r
p_list_item = cl_qlist_tail( &p_obj->obj_list );\r
while( p_list_item != cl_qlist_end( &p_obj->obj_list ) )\r
{\r
p_child_obj = PARENT_STRUCT( p_list_item, al_obj_t, pool_item );\r
CL_ASSERT( p_child_obj->pfn_destroy );\r
- CL_TRACE( AL_DBG_AL_OBJ, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_AL_OBJ,\r
("bye bye: %p(%s)\n", p_child_obj,\r
ib_get_obj_type( p_child_obj ) ) );\r
ref_al_obj( p_child_obj );\r
}\r
\r
p_obj->user_destroy_cb = pfn_destroy_cb;\r
- CL_EXIT( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AL_OBJ );\r
return TRUE;\r
}\r
\r
al_obj_t *p_obj;\r
al_obj_t *p_parent_obj = NULL;\r
\r
- CL_ENTER( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_AL_OBJ );\r
\r
CL_ASSERT( p_item );\r
p_obj = PARENT_STRUCT( p_item, al_obj_t, async_item );\r
CL_ASSERT( p_obj->state == CL_DESTROYING );\r
CL_ASSERT( !p_obj->ref_cnt );\r
\r
- CL_TRACE( AL_DBG_AL_OBJ, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_AL_OBJ,\r
("%p\n", p_obj ) );\r
\r
/* Cleanup any hardware related resources. */\r
if( p_obj->pfn_cleanup )\r
{\r
- CL_TRACE( AL_DBG_AL_OBJ, g_al_dbg_lvl, ("cleaning up\n" ) );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_AL_OBJ, ("cleaning up\n" ) );\r
p_obj->pfn_cleanup( p_obj );\r
}\r
\r
/* Notify the user that we're done. */\r
if( p_obj->user_destroy_cb )\r
{\r
- CL_TRACE( AL_DBG_AL_OBJ, g_al_dbg_lvl, ("notifying user\n" ) );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_AL_OBJ, ("notifying user\n" ) );\r
p_obj->user_destroy_cb( (void*)p_obj->context );\r
}\r
\r
/* Free the resources associated with the object. */\r
- CL_TRACE( AL_DBG_AL_OBJ, g_al_dbg_lvl, ("freeing object\n" ) );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_AL_OBJ, ("freeing object\n" ) );\r
p_obj->pfn_free( p_obj );\r
\r
/* Dereference the parent after freeing the child. */\r
if( p_parent_obj )\r
deref_al_obj( p_parent_obj );\r
- CL_EXIT( AL_DBG_AL_OBJ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AL_OBJ );\r
}\r
*/\r
ib_api_status_t\r
attach_al_obj(\r
- IN al_obj_t * const p_parent_obj ,\r
+ IN al_obj_t * const p_parent_obj,\r
IN al_obj_t * const p_child_obj );\r
\r
\r
\r
\r
\r
-#if defined( _DEBUG_ ) \r
+\r
extern const char* ib_obj_type_str[];\r
\r
static inline const char*\r
\r
return( ib_obj_type_str[ AL_BASE_TYPE( p_obj->type ) ] );\r
}\r
-#endif\r
+\r
\r
\r
\r
\r
#include "al_cq.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_cq.tmh"\r
+#endif\r
+\r
#include "al_ca.h"\r
#include "al_pd.h"\r
#include "al_qp.h"\r
\r
if( !p_cq_create || !ph_cq )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
if( (p_cq_create->pfn_comp_cb && p_cq_create->h_wait_obj) ||\r
(!p_cq_create->pfn_comp_cb && !p_cq_create->h_wait_obj) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_SETTING\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_SETTING\n") );\r
return IB_INVALID_SETTING;\r
}\r
\r
IN const ib_cq_handle_t h_cq,\r
IN const ib_pfn_destroy_cb_t pfn_destroy_cb OPTIONAL )\r
{\r
- CL_ENTER( AL_DBG_CQ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CQ );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_cq, AL_OBJ_TYPE_H_CQ ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_CQ_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_CQ_HANDLE\n") );\r
return IB_INVALID_CQ_HANDLE;\r
}\r
\r
ref_al_obj( &h_cq->obj );\r
h_cq->obj.pfn_destroy( &h_cq->obj, pfn_destroy_cb );\r
\r
- CL_EXIT( AL_DBG_CQ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CQ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CQ );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_cq, AL_OBJ_TYPE_H_CQ ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_CQ_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_CQ_HANDLE\n") );\r
return IB_INVALID_CQ_HANDLE;\r
}\r
if( !p_size )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = verbs_modify_cq( h_cq, p_size );\r
\r
- CL_EXIT( AL_DBG_CQ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CQ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CQ );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_cq, AL_OBJ_TYPE_H_CQ ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_CQ_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_CQ_HANDLE\n") );\r
return IB_INVALID_CQ_HANDLE;\r
}\r
if( !p_size )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = verbs_query_cq( h_cq, p_size );\r
\r
- CL_EXIT( AL_DBG_CQ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CQ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CQ );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_cq, AL_OBJ_TYPE_H_CQ ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_CQ_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_CQ_HANDLE\n") );\r
return IB_INVALID_CQ_HANDLE;\r
}\r
if( !p_n_cqes )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = verbs_peek_cq( h_cq, p_n_cqes );\r
\r
- CL_EXIT( AL_DBG_CQ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return status;\r
}\r
\r
PERF_DECLARE( VerbsPollCq );\r
\r
cl_perf_start( IbPollCq );\r
- CL_ENTER( AL_DBG_CQ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CQ );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_cq, AL_OBJ_TYPE_H_CQ ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_CQ_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_CQ_HANDLE\n") );\r
return IB_INVALID_CQ_HANDLE;\r
}\r
if( !pp_free_wclist || !pp_done_wclist )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = verbs_poll_cq( h_cq, pp_free_wclist, pp_done_wclist );\r
cl_perf_stop( &g_perf, VerbsPollCq );\r
\r
- CL_EXIT( AL_DBG_CQ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
cl_perf_stop( &g_perf, IbPollCq );\r
return status;\r
}\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CQ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CQ );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_cq, AL_OBJ_TYPE_H_CQ ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_CQ_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_CQ_HANDLE\n") );\r
return IB_INVALID_CQ_HANDLE;\r
}\r
\r
status = verbs_rearm_cq( h_cq, solicited );\r
\r
- CL_EXIT( AL_DBG_CQ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CQ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CQ );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_cq, AL_OBJ_TYPE_H_CQ ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_CQ_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_CQ_HANDLE\n") );\r
return IB_INVALID_CQ_HANDLE;\r
}\r
if( !n_cqes )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = verbs_rearm_n_cq( h_cq, n_cqes );\r
\r
- CL_EXIT( AL_DBG_CQ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return status;\r
}\r
\r
#define __AL_DEBUG_H__\r
\r
#ifndef __MODULE__\r
-#define __MODULE__ "al"\r
+#define __MODULE__ "[AL]"\r
#endif\r
\r
#include <complib/cl_debug.h>\r
#include <complib/cl_perf.h>\r
\r
+extern uint32_t g_al_dbg_level;\r
+extern uint32_t g_al_dbg_flags;\r
+\r
+#if defined(EVENT_TRACING)\r
+//\r
+// Software Tracing Definitions \r
+//\r
+\r
+#ifndef CL_KERNEL\r
+\r
+#define WPP_CONTROL_GUIDS \\r
+ WPP_DEFINE_CONTROL_GUID(ALCtlGuid1,(B199CE55,F8BF,4147,B119,DACD1E5987A6), \\r
+ WPP_DEFINE_BIT( AL_DBG_ERROR) \\r
+ WPP_DEFINE_BIT( AL_DBG_AL_OBJ) \\r
+ WPP_DEFINE_BIT( AL_DBG_HDL) \\r
+ WPP_DEFINE_BIT( AL_DBG_SMI) \\r
+ WPP_DEFINE_BIT( AL_DBG_SMI_CB) \\r
+ WPP_DEFINE_BIT( AL_DBG_MAD_POOL) \\r
+ WPP_DEFINE_BIT( AL_DBG_MAD_SVC) \\r
+ WPP_DEFINE_BIT( AL_DBG_PNP) \\r
+ WPP_DEFINE_BIT( AL_DBG_CM) \\r
+ WPP_DEFINE_BIT( AL_DBG_CA) \\r
+ WPP_DEFINE_BIT( AL_DBG_MR) \\r
+ WPP_DEFINE_BIT( AL_DBG_MGR)\\r
+ WPP_DEFINE_BIT( AL_DBG_DEV)\\r
+ WPP_DEFINE_BIT( AL_DBG_MCAST)\\r
+ WPP_DEFINE_BIT( AL_DBG_PD)\\r
+ WPP_DEFINE_BIT( AL_DBG_AV)\\r
+ WPP_DEFINE_BIT( AL_DBG_CQ)\\r
+ WPP_DEFINE_BIT( AL_DBG_QP)\\r
+ WPP_DEFINE_BIT( AL_DBG_MW)\\r
+ WPP_DEFINE_BIT( AL_DBG_PROXY_CB)\\r
+ WPP_DEFINE_BIT( AL_DBG_UAL)\\r
+ WPP_DEFINE_BIT( AL_DBG_QUERY)\\r
+ WPP_DEFINE_BIT( AL_DBG_SA_REQ)\\r
+ WPP_DEFINE_BIT( AL_DBG_IOC)\\r
+ WPP_DEFINE_BIT( AL_DBG_SUB)\\r
+ WPP_DEFINE_BIT( AL_DBG_MAD))\r
+\r
+#else\r
+\r
+#define WPP_CONTROL_GUIDS \\r
+ WPP_DEFINE_CONTROL_GUID(ALCtlGuid2,(99DC84E3,B106,431e,88A6,4DD20C9BBDE3), \\r
+ WPP_DEFINE_BIT( AL_DBG_ERROR) \\r
+ WPP_DEFINE_BIT( AL_DBG_AL_OBJ) \\r
+ WPP_DEFINE_BIT( AL_DBG_HDL) \\r
+ WPP_DEFINE_BIT( AL_DBG_SMI) \\r
+ WPP_DEFINE_BIT( AL_DBG_SMI_CB) \\r
+ WPP_DEFINE_BIT( AL_DBG_MAD_POOL) \\r
+ WPP_DEFINE_BIT( AL_DBG_MAD_SVC) \\r
+ WPP_DEFINE_BIT( AL_DBG_PNP) \\r
+ WPP_DEFINE_BIT( AL_DBG_CM) \\r
+ WPP_DEFINE_BIT( AL_DBG_CA) \\r
+ WPP_DEFINE_BIT( AL_DBG_MR) \\r
+ WPP_DEFINE_BIT( AL_DBG_MGR)\\r
+ WPP_DEFINE_BIT( AL_DBG_DEV)\\r
+ WPP_DEFINE_BIT( AL_DBG_MCAST)\\r
+ WPP_DEFINE_BIT( AL_DBG_PD)\\r
+ WPP_DEFINE_BIT( AL_DBG_AV)\\r
+ WPP_DEFINE_BIT( AL_DBG_CQ)\\r
+ WPP_DEFINE_BIT( AL_DBG_QP)\\r
+ WPP_DEFINE_BIT( AL_DBG_MW)\\r
+ WPP_DEFINE_BIT( AL_DBG_PROXY_CB)\\r
+ WPP_DEFINE_BIT( AL_DBG_UAL)\\r
+ WPP_DEFINE_BIT( AL_DBG_QUERY)\\r
+ WPP_DEFINE_BIT( AL_DBG_SA_REQ)\\r
+ WPP_DEFINE_BIT( AL_DBG_IOC)\\r
+ WPP_DEFINE_BIT( AL_DBG_SUB)\\r
+ WPP_DEFINE_BIT( AL_DBG_MAD))\r
+\r
+#endif\r
+\r
+\r
+#define WPP_LEVEL_FLAGS_ENABLED(lvl, flags) (WPP_LEVEL_ENABLED(flags) && WPP_CONTROL(WPP_BIT_ ## flags).Level >= lvl)\r
+#define WPP_LEVEL_FLAGS_LOGGER(lvl,flags) WPP_LEVEL_LOGGER(flags)\r
+#define WPP_FLAG_ENABLED(flags)(WPP_LEVEL_ENABLED(flags) && WPP_CONTROL(WPP_BIT_ ## flags).Level >= TRACE_LEVEL_VERBOSE)\r
+#define WPP_FLAG_LOGGER(flags) WPP_LEVEL_LOGGER(flags)\r
+\r
+\r
+// begin_wpp config\r
+// AL_ENTER( FLAG );\r
+// AL_EXIT( FLAG );\r
+// USEPREFIX(AL_PRINT, "%!STDPREFIX! %!FUNC!() :");\r
+// USESUFFIX(AL_ENTER, " %!FUNC!():[");\r
+// USESUFFIX(AL_EXIT, " %!FUNC!():]");\r
+// end_wpp\r
+\r
+\r
+\r
+#else\r
+\r
+#include <wmistr.h>\r
+#include <evntrace.h>\r
+\r
+/*\r
+ * Debug macros\r
+ */\r
+\r
\r
/* Debug message source */\r
-#define AL_DBG_AL_OBJ (1 << 0)\r
-#define AL_DBG_HDL (1 << 1)\r
+#define AL_DBG_ERR (1 << 0)\r
+#define AL_DBG_AL_OBJ (1 << 1)\r
+#define AL_DBG_HDL (1 << 2)\r
#define AL_DBG_SMI (1 << 4)\r
#define AL_DBG_SMI_CB (1 << 5)\r
-#define AL_DBG_MAD_POOL (1 << 7)\r
+#define AL_DBG_MAD_POOL (1 << 7)\r
#define AL_DBG_MAD_SVC (1 << 8)\r
#define AL_DBG_PNP (1 << 9)\r
#define AL_DBG_CM (1 << 10)\r
#define AL_DBG_SA_REQ (1 << 26)\r
#define AL_DBG_IOC (1 << 27)\r
#define AL_DBG_SUB (1 << 28)\r
+#define AL_DBG_MAD (1 << 29) //TODO \r
+\r
+#define AL_DBG_ERROR (CL_DBG_ERROR | AL_DBG_ERR)\r
+\r
+#if DBG\r
+\r
+// assignment of _level_ is need to to overcome warning C4127\r
+#define AL_PRINT( _level_,_flag_,_msg_) \\r
+ { \\r
+ if( g_al_dbg_level >= (_level_) ) \\r
+ CL_TRACE( _flag_, g_al_dbg_level, _msg_ ); \\r
+ }\r
+\r
\r
-/* Debug message type */\r
-#define AL_DBG_FUNC (1 << 29)\r
-#define AL_DBG_WARN (1 << 30)\r
-#define AL_DBG_ERROR CL_DBG_ERROR\r
+#define AL_PRINT_EXIT( _level_,_flag_,_msg_) \\r
+ { \\r
+ if( g_al_dbg_level >= (_level_) ) \\r
+ CL_TRACE( _flag_, g_al_dbg_level, _msg_ );\\r
+ AL_EXIT( _flag_ );\\r
+ }\r
\r
-#define AL_DBG_NONE CL_DBG_DISABLE\r
-#define AL_DBG_FULL CL_DBG_ALL\r
+#define AL_ENTER( _flag_) \\r
+ { \\r
+ if( g_al_dbg_level >= TRACE_LEVEL_VERBOSE ) \\r
+ CL_ENTER( _flag_, g_al_dbg_level ); \\r
+ }\r
\r
-#define AL_DBG_MAD (AL_DBG_SMI | AL_DBG_SMI_CB | \\r
- AL_DBG_MAD_POOL | AL_DBG_MAD_SVC)\r
-#define AL_DBG_NORMAL AL_DBG_ERROR\r
-#define AL_DBG_VERBOSE (AL_DBG_FULL & (~AL_DBG_AL_OBJ))\r
+#define AL_EXIT( _flag_)\\r
+ { \\r
+ if( g_al_dbg_level >= TRACE_LEVEL_VERBOSE ) \\r
+ CL_EXIT( _flag_, g_al_dbg_level ); \\r
+ }\r
\r
-extern uint32_t g_al_dbg_lvl;\r
\r
-/* Macros for simplifying CL_ENTER, CL_TRACE, etc. */\r
-#define AL_ENTER( msg_lvl ) \\r
- CL_ENTER( (msg_lvl | AL_DBG_FUNC), g_al_dbg_lvl )\r
+#else\r
\r
-#define AL_EXIT( msg_lvl ) \\r
- CL_EXIT( (msg_lvl | AL_DBG_FUNC), g_al_dbg_lvl )\r
+#define AL_PRINT( lvl, flags, msg)\r
\r
-#define AL_TRACE( msg_lvl, msg ) \\r
- CL_TRACE( (msg_lvl), g_al_dbg_lvl, msg )\r
+#define AL_PRINT_EXIT( _level_,_flag_,_msg_)\r
+\r
+#define AL_ENTER( _flag_)\r
+\r
+#define AL_EXIT( _flag_)\r
+\r
+\r
+#endif\r
\r
-#define AL_TRACE_EXIT( msg_lvl, msg ) \\r
- CL_TRACE_EXIT( (msg_lvl), g_al_dbg_lvl, msg )\r
+#endif //EVENT_TRACING\r
\r
-#define AL_PRINT( msg_lvl, msg ) \\r
- CL_PRINT( (msg_lvl), g_al_dbg_lvl, msg )\r
\r
\r
enum al_perf_counters\r
\r
#include "al_ca.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_dm.tmh"\r
+#endif\r
+\r
#include "al_dm.h"\r
#include "al_mgr.h"\r
#include "ib_common.h"\r
{\r
ib_ioc_handle_t h_ioc;\r
\r
- CL_ENTER( AL_DBG_IOC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_IOC );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_ca, AL_OBJ_TYPE_H_CA ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_CA_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_CA_HANDLE\n") );\r
return IB_INVALID_CA_HANDLE;\r
}\r
if( !p_ioc_profile || !ph_ioc )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
/* Return the IOC handle to the user. */\r
*ph_ioc = h_ioc;\r
\r
- CL_EXIT( AL_DBG_IOC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_IOC );\r
return IB_SUCCESS;\r
}\r
\r
ib_destroy_ioc(\r
IN const ib_ioc_handle_t h_ioc )\r
{\r
- CL_ENTER( AL_DBG_IOC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_IOC );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_ioc, AL_OBJ_TYPE_H_IOC ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
\r
ref_al_obj( &h_ioc->obj );\r
h_ioc->obj.pfn_destroy( &h_ioc->obj, NULL );\r
\r
- CL_EXIT( AL_DBG_IOC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_IOC );\r
return IB_SUCCESS;\r
}\r
\r
al_iou_t* p_iou;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_IOC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_IOC );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_ioc, AL_OBJ_TYPE_H_IOC ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
\r
/* Register the IOC with the IO unit. */\r
status = add_ioc( p_iou, h_ioc );\r
\r
- CL_EXIT( AL_DBG_IOC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_IOC );\r
return status;\r
}\r
\r
ib_svc_handle_t h_svc;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_IOC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_IOC );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_ioc, AL_OBJ_TYPE_H_IOC ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !p_svc_entry || !ph_svc )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( h_ioc->ioc_profile.num_svc_entries == MAX_NUM_SVC_ENTRIES )\r
{\r
cl_spinlock_release( &h_ioc->obj.lock );\r
- CL_EXIT( AL_DBG_IOC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_IOC );\r
return IB_INSUFFICIENT_RESOURCES;\r
}\r
h_svc = cl_zalloc( sizeof( ib_svc_handle_t ) );\r
if( !h_svc )\r
{\r
- CL_EXIT( AL_DBG_IOC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_IOC );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
free_svc_entry( &h_svc->obj );\r
- CL_EXIT( AL_DBG_IOC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_IOC );\r
return status;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
h_svc->obj.pfn_destroy( &h_svc->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &h_svc->obj );\r
\r
- CL_EXIT( AL_DBG_IOC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_IOC );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_ioc_handle_t h_ioc;\r
\r
- CL_ENTER( AL_DBG_IOC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_IOC );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_svc, AL_OBJ_TYPE_H_SVC_ENTRY ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
\r
/* No longer in use by this thread. */\r
cl_atomic_dec( &h_ioc->in_use_cnt );\r
\r
- CL_EXIT( AL_DBG_IOC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_IOC );\r
return IB_SUCCESS;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
h_ioc->obj.pfn_destroy( &h_ioc->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return NULL;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_dm_agent->obj.pfn_destroy( &gp_dm_agent->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
{\r
p_iou->obj.pfn_destroy( &p_iou->obj, NULL );\r
cl_spinlock_release( &gp_dm_agent->lock );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( !h_ca )\r
{\r
p_iou->obj.pfn_destroy( &p_iou->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("acquire_ca for GUID %016I64x failed.\n", p_pnp_rec->guid) );\r
return IB_INVALID_CA_HANDLE;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_iou_port->obj.pfn_destroy( &p_iou_port->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
*/\r
\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_init.tmh"\r
+#endif\r
+\r
#include "al_dev.h"\r
#include "al_init.h"\r
#include "al_mgr.h"\r
\r
\r
\r
-uint32_t g_al_dbg_lvl = AL_DBG_ERROR;\r
-\r
-\r
+uint32_t g_al_dbg_level = TRACE_LEVEL_ERROR;\r
+uint32_t g_al_dbg_flags = 0xf0;\r
/*\r
* Device driver initialization routine.\r
*/\r
cl_status_t cl_status;\r
ib_api_status_t status = IB_ERROR;\r
\r
- CL_ENTER( AL_DBG_DEV, g_al_dbg_lvl );\r
- CL_TRACE( AL_DBG_DEV, g_al_dbg_lvl, ("Hello World! =)\n") );\r
+ AL_ENTER( AL_DBG_DEV );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_DEV, ("Hello World! =)\n") );\r
\r
/*\r
* Initialize access layer services.\r
#endif\r
if( !gp_async_proc_mgr )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl, ("alloc_async_proc failed.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("alloc_async_proc failed.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
gp_async_pnp_mgr = gp_async_proc_mgr + 1;\r
cl_status = cl_async_proc_init( gp_async_obj_mgr, 1, "AL_OBJ" );\r
if( cl_status != CL_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Failed to init async_obj_mgr: status = 0x%x.\n", cl_status) );\r
return ib_convert_cl_status( cl_status );\r
}\r
cl_status = cl_async_proc_init( gp_async_proc_mgr, 1, "Althread" );\r
if( cl_status != CL_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Failed to init async_proc_mgr: status = 0x%x.\n", cl_status) );\r
return ib_convert_cl_status( cl_status );\r
}\r
cl_status = cl_async_proc_init( gp_async_pnp_mgr, 1, "AL_PNP" );\r
if( cl_status != CL_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Failed to init async_pnp_mgr: status = 0x%x.\n", cl_status) );\r
return ib_convert_cl_status( cl_status );\r
}\r
status = create_al_mgr();\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_al_mgr: status = 0x%x.\n", status) );\r
return status;\r
}\r
\r
- CL_EXIT( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_DEV );\r
return status;\r
}\r
\r
void\r
al_cleanup( void )\r
{\r
- CL_ENTER( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_DEV );\r
\r
/*\r
* Destroy access layer device interface.\r
*/\r
- CL_TRACE( AL_DBG_DEV, g_al_dbg_lvl, ("Destroying %s device.\n",\r
- AL_DEVICE_NAME) );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_DEV, ("Destroying %s device.\n",\r
+ (const char *)AL_DEVICE_NAME) );\r
\r
/*\r
* Destroy access layer services.\r
*/\r
if( gp_al_mgr )\r
{\r
- CL_TRACE( AL_DBG_DEV, g_al_dbg_lvl, ("Destroying AL Mgr.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_DEV, ("Destroying AL Mgr.\n") );\r
ref_al_obj( &gp_al_mgr->obj );\r
gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
}\r
#if AL_OBJ_PRIVATE_ASYNC_PROC\r
if( gp_async_obj_mgr )\r
{\r
- CL_TRACE( AL_DBG_DEV, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_DEV,\r
("Destroying async obj mgr.\n") );\r
cl_async_proc_destroy( gp_async_obj_mgr );\r
gp_async_obj_mgr = NULL;\r
\r
if( gp_async_pnp_mgr )\r
{\r
- CL_TRACE( AL_DBG_DEV, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_DEV,\r
("Destroying async pnp mgr.\n") );\r
cl_async_proc_destroy( gp_async_pnp_mgr );\r
gp_async_pnp_mgr = NULL;\r
\r
if( gp_async_proc_mgr )\r
{\r
- CL_TRACE( AL_DBG_DEV, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_DEV,\r
("Destroying async proc mgr.\n") );\r
cl_async_proc_destroy( gp_async_proc_mgr );\r
cl_free( gp_async_proc_mgr );\r
gp_async_proc_mgr = NULL;\r
}\r
\r
- CL_TRACE_EXIT( AL_DBG_DEV, g_al_dbg_lvl, ("Goodbye Cruel World =(\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_DEV, ("Goodbye Cruel World =(\n") );\r
}\r
\r
#include "al.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_mad.tmh"\r
+#endif\r
+\r
#include "al_cq.h"\r
#include "al_mad.h"\r
#include "al_qp.h"\r
IN ib_mad_element_t* p_mad_element,\r
IN ib_wc_t* p_wc )\r
{\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( p_mad_element );\r
CL_ASSERT( p_wc );\r
if( p_wc->recv.ud.recv_opt & IB_RECV_OPT_IMMEDIATE )\r
p_mad_element->immediate_data = p_wc->recv.ud.immediate_data;\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
}\r
\r
\r
ib_api_status_t status;\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
h_mad_disp = cl_zalloc( sizeof( al_mad_disp_t ) );\r
if( !h_mad_disp )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl, ("insufficient memory\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("insufficient memory\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
NULL, __cleanup_mad_disp, __free_mad_disp );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl, ("init obj: %s\n",\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("init obj: %s\n",\r
ib_get_err_str(status)) );\r
__free_mad_disp( &h_mad_disp->obj );\r
return status;\r
if( status != IB_SUCCESS )\r
{\r
h_mad_disp->obj.pfn_destroy( &h_mad_disp->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &h_mad_disp->obj );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
return IB_SUCCESS;\r
}\r
\r
{\r
al_mad_disp_handle_t h_mad_disp;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
CL_ASSERT( p_obj );\r
h_mad_disp = PARENT_STRUCT( p_obj, al_mad_disp_t, obj );\r
\r
if( h_mad_disp->h_qp )\r
deref_al_obj( &h_mad_disp->h_qp->obj );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
{\r
al_mad_disp_handle_t h_mad_disp;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
CL_ASSERT( p_obj );\r
h_mad_disp = PARENT_STRUCT( p_obj, al_mad_disp_t, obj );\r
\r
cl_vector_destroy( &h_mad_disp->version_vector );\r
destroy_al_obj( p_obj );\r
cl_free( h_mad_disp );\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
size_t i;\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
cl_spinlock_acquire( &h_mad_disp->obj.lock );\r
\r
/* Find an empty slot in the client vector for the registration. */\r
if( !__mad_disp_reg_unsol( h_mad_disp, h_mad_reg, p_mad_svc ) )\r
{\r
cl_spinlock_release( &h_mad_disp->obj.lock );\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl, ("reg unsol failed\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("reg unsol failed\n") );\r
return NULL;\r
}\r
}\r
/* The MAD service needs to take a reference on the dispatcher. */\r
ref_al_obj( &h_mad_disp->obj );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
return h_mad_reg;\r
}\r
\r
uint8_t i;\r
\r
/* Ensure that we are ready to handle this version number. */\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
cl_status = cl_vector_set_min_size( &h_mad_disp->version_vector,\r
__mgmt_version_index( p_mad_svc->mgmt_version ) + 1 );\r
if( cl_status != CL_SUCCESS )\r
/* No one else can be registered for this method. */\r
if( cl_ptr_vector_get( p_method_ptr_vector, i ) )\r
{\r
- CL_TRACE(AL_DBG_ERROR, g_al_dbg_lvl, \r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Other client already registered for Un-Solicited Method "\r
"%u for version %u of class %u.\n", i, p_mad_svc->mgmt_version,\r
p_mad_svc->mgmt_class ) );\r
{\r
cl_ptr_vector_set( p_method_ptr_vector, i, h_mad_reg );\r
\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC,\r
("Register version:%u (%u) class:0x%02X(%u) method:0x%02X Hdl:%p\n",\r
p_mad_svc->mgmt_version,\r
__mgmt_version_index( p_mad_svc->mgmt_version ),\r
}\r
}\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
return TRUE;\r
}\r
\r
cl_ptr_vector_t *p_method_ptr_vector;\r
size_t i;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
h_mad_disp = h_mad_reg->h_mad_disp;\r
\r
cl_spinlock_acquire( &h_mad_disp->obj.lock );\r
\r
/* The MAD service no longer requires access to the MAD dispatcher. */\r
deref_al_obj( &h_mad_disp->obj );\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
* Increment the reference count on the registration to ensure that\r
* the MAD service does not go away until the send completes.\r
*/\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
cl_atomic_inc( &h_mad_reg->ref_cnt );\r
ref_al_obj( &h_mad_reg->h_mad_svc->obj );\r
\r
* If we are the originator of the transaction, we need to modify the\r
* TID to ensure that duplicate TIDs are not used by multiple clients.\r
*/\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("dispatching TID: 0x%0"PRIx64"\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC, ("dispatching TID: 0x%I64x\n",\r
p_mad_hdr->trans_id) );\r
p_mad_wr->client_tid = p_mad_hdr->trans_id;\r
if( __use_tid_routing( p_mad_hdr, TRUE ) )\r
al_set_al_tid( &p_mad_hdr->trans_id, h_mad_reg->client_id );\r
#pragma warning( pop )\r
\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
- ("modified TID to: 0x%0"PRIx64"\n", p_mad_hdr->trans_id) );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC,\r
+ ("modified TID to: 0x%0I64x\n", p_mad_hdr->trans_id) );\r
}\r
\r
/* Post the work request to the QP. */\r
h_mad_reg->h_mad_disp->h_qp->pfn_queue_mad(\r
h_mad_reg->h_mad_disp->h_qp, p_mad_wr );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
al_mad_reg_handle_t h_mad_reg;\r
ib_mad_t *p_mad_hdr;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("p_mad_wr 0x%p\n", p_mad_wr ) );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC, ("p_mad_wr 0x%p\n", p_mad_wr ) );\r
\r
/* Get the MAD header. */\r
p_mad_hdr = get_mad_hdr_from_wr( p_mad_wr );\r
CL_ASSERT( h_mad_reg && (h_mad_reg->client_id == p_mad_wr->client_id) );\r
\r
/* Reset the TID and WR ID. */\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("send done TID: 0x%"PRIx64"\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC, ("send done TID: 0x%I64x\n",\r
p_mad_hdr->trans_id) );\r
p_mad_hdr->trans_id = p_mad_wr->client_tid;\r
p_mad_wr->send_wr.wr_id = 0;\r
deref_al_obj( &h_mad_reg->h_mad_svc->obj );\r
cl_atomic_dec( &h_mad_reg->ref_cnt );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
cl_ptr_vector_t *p_method_ptr_vector;\r
uint8_t method;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
p_mad_hdr = ib_get_mad_buf( p_mad_element );\r
\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
- ("TID = 0x%"PRIx64 "\n"\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC,\r
+ ("TID = 0x%I64x\n"\r
"class = 0x%x.\n"\r
"version = 0x%x.\n"\r
"method = 0x%x.\n",\r
if( __use_tid_routing( p_mad_hdr, FALSE ) )\r
{\r
/* The MAD was received in response to a send. */\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("routing based on TID\n"));\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC, ("routing based on TID\n"));\r
\r
/* Verify that we have a registration entry. */\r
if( al_get_al_tid( p_mad_hdr->trans_id ) >=\r
{\r
/* No clients for this version-class-method. */\r
cl_spinlock_release( &h_mad_disp->obj.lock );\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
("invalid client ID\n") );\r
return IB_NOT_FOUND;\r
}\r
}\r
else\r
{\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC,\r
("routing based on version, class, method\n"));\r
\r
/* The receive is unsolicited. Find the client. */\r
{\r
/* No clients for this version of MADs. */\r
cl_spinlock_release( &h_mad_disp->obj.lock );\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
("no clients registered for this class version\n") );\r
return IB_NOT_FOUND;\r
}\r
{\r
/* No clients for this version-class. */\r
cl_spinlock_release( &h_mad_disp->obj.lock );\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
("no clients registered for this class\n") );\r
return IB_NOT_FOUND;\r
}\r
{\r
/* No clients for this version-class-method. */\r
cl_spinlock_release( &h_mad_disp->obj.lock );\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
("no clients registered for this method-out of range\n") );\r
return IB_NOT_FOUND;\r
}\r
{\r
/* No clients for this version-class-method. */\r
cl_spinlock_release( &h_mad_disp->obj.lock );\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
("no clients registered for method %u of class %u(%u) version %u(%u)\n",\r
method,\r
p_mad_hdr->mgmt_class,\r
if( !h_mad_reg->ref_cnt )\r
{\r
cl_spinlock_release( &h_mad_disp->obj.lock );\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
("no client registered\n") );\r
return IB_NOT_FOUND;\r
}\r
\r
h_mad_reg->pfn_recv_done( h_mad_svc, p_mad_element );\r
deref_al_obj( &h_mad_svc->obj );\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
return IB_SUCCESS;\r
}\r
\r
ib_rmpp_mad_t *p_rmpp_mad;\r
boolean_t is_orig;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
/* CM MADs are never TID routed. */\r
if( p_mad_hdr->mgmt_class == IB_MCLASS_COMM_MGMT )\r
{\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
return FALSE;\r
}\r
\r
if( !are_we_sender )\r
is_orig = !is_orig;\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
return is_orig;\r
}\r
\r
al_qp_alias_t *p_qp_alias;\r
ib_qp_attr_t qp_attr;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
CL_ASSERT( h_qp );\r
\r
switch( h_qp->type )\r
break;\r
\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( !p_mad_svc || !ph_mad_svc )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
h_mad_svc->obj.pfn_destroy( &h_mad_svc->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
\r
*ph_mad_svc = h_mad_svc;\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
return IB_SUCCESS;\r
}\r
\r
KIRQL old_irql;\r
#endif\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
CL_ASSERT( p_obj );\r
h_mad_svc = PARENT_STRUCT( p_obj, al_mad_svc_t, obj );\r
\r
p_list_item != cl_qlist_end( &h_mad_svc->send_list );\r
p_list_item = cl_qlist_next( p_list_item ) )\r
{\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("canceling MAD\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC, ("canceling MAD\n") );\r
h_send = PARENT_STRUCT( p_list_item, al_mad_send_t, pool_item );\r
h_send->canceled = TRUE;\r
}\r
}\r
#endif\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
ib_mad_element_t *p_cur_mad, *p_next_mad;\r
#endif\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_mad_svc, AL_OBJ_TYPE_H_MAD_SVC ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !p_mad_element_list ||\r
( p_mad_element_list->p_next && !pp_mad_failure ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
#ifndef CL_KERNEL\r
/* This is a send from user mode using special QP alias */\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
- ("ib_send_mad: ual_context non-zero, TID = 0x%"PRIx64 ".\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC,\r
+ ("ib_send_mad: ual_context non-zero, TID = 0x%I64x.\n",\r
((ib_mad_t*)(ib_get_mad_buf( p_mad_element_list )))->trans_id ));\r
status = spl_qp_mad_send( h_mad_svc, p_mad_element_list,\r
pp_mad_failure );\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
return status;\r
#else\r
/* Post each send on the list. */\r
al_mad_element_t, element ) );\r
if( !h_send )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl, ("unable to get mad_send\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("unable to get mad_send\n") );\r
if( pp_mad_failure )\r
*pp_mad_failure = p_cur_mad;\r
return IB_INSUFFICIENT_RESOURCES;\r
status = __init_send_mad( h_mad_svc, h_send, p_cur_mad );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl, ("init_send_mad failed: %s\n",\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("init_send_mad failed: %s\n",\r
ib_get_err_str(status)) );\r
put_mad_send( h_send );\r
if( pp_mad_failure )\r
*/\r
__mad_disp_resume_send( h_mad_svc->h_mad_reg );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
return status;\r
#endif\r
}\r
uint8_t rmpp_version;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
/* Initialize tracking the send. */\r
h_send->p_send_mad = p_mad_element;\r
if( h_send->uses_rmpp )\r
{\r
/* The RMPP header is present. */\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("RMPP is activated\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC, ("RMPP is activated\n") );\r
p_rmpp_hdr = (ib_rmpp_mad_t*)p_mad_element->p_mad_buf;\r
\r
/* We only support version 1. */\r
if( rmpp_version != DEFAULT_RMPP_VERSION )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl, ("unsupported version\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("unsupported version\n") );\r
return IB_INVALID_SETTING;\r
}\r
\r
}\r
}\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_rmpp_mad_t *p_rmpp_hdr;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
CL_ASSERT( h_mad_reg && h_send );\r
CL_ASSERT( h_send->cur_seg <= h_send->seg_limit );\r
/* Send the MAD. */\r
__queue_mad_wr( h_mad_reg, h_send );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
uint8_t *p_rmpp_src, *p_rmpp_dst;\r
uintn_t hdr_len, offset, max_len;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
p_send_wr = &h_send->mad_wr.send_wr;\r
\r
cl_memclr( p_send_wr, sizeof( ib_send_wr_t ) );\r
\r
__mad_disp_queue_send( h_mad_reg, &h_send->mad_wr );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
ib_api_status_t status;\r
#endif\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_mad_svc, AL_OBJ_TYPE_H_MAD_SVC ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !p_mad_element )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
#ifndef CL_KERNEL\r
/* This is a send from user mode using special QP alias */\r
status = spl_qp_cancel_mad( h_mad_svc, p_mad_element );\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
return status;\r
#else\r
/* Search for the MAD in our MAD list. It may have already completed. */\r
if( !p_list_item )\r
{\r
cl_spinlock_release( &h_mad_svc->obj.lock );\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("mad not found\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC, ("mad not found\n") );\r
return IB_NOT_FOUND;\r
}\r
\r
}\r
\r
cl_spinlock_release( &h_mad_svc->obj.lock );\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
return IB_SUCCESS;\r
#endif\r
}\r
\r
if( AL_OBJ_INVALID_HANDLE( h_mad_svc, AL_OBJ_TYPE_H_MAD_SVC ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !p_mad_element )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( !p_list_item )\r
{\r
cl_spinlock_release( &h_mad_svc->obj.lock );\r
- AL_TRACE( AL_DBG_MAD_SVC, ("MAD not found\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC, ("MAD not found\n") );\r
return IB_NOT_FOUND;\r
}\r
\r
{\r
ib_mad_send_handle_t h_send;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
CL_ASSERT( h_mad_svc && p_mad_wr && !p_wc->p_next );\r
\r
h_send = PARENT_STRUCT( p_mad_wr, al_mad_send_t, mad_wr );\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("send callback TID:0x%"PRIx64"\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC, ("send callback TID:0x%I64x\n",\r
__get_send_tid( h_send )) );\r
\r
/* We need to synchronize access to the list as well as the MAD request. */\r
/* Complete internally sent MADs. */\r
if( __is_internal_send( h_mad_svc->svc_type, h_send->p_send_mad ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("internal send\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC, ("internal send\n") );\r
cl_qlist_remove_item( &h_mad_svc->send_list,\r
(cl_list_item_t*)&h_send->pool_item );\r
cl_spinlock_release( &h_mad_svc->obj.lock );\r
if( h_send->uses_rmpp && (h_send->cur_seg <= h_send->seg_limit) )\r
{\r
/* Send the next segment. */\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
- ("sending next RMPP segment for TID:0x%"PRIx64"\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC,\r
+ ("sending next RMPP segment for TID:0x%I64x\n",\r
__get_send_tid( h_send )) );\r
\r
__queue_rmpp_seg( h_mad_svc->h_mad_reg, h_send );\r
else\r
{\r
/* Continue waiting for a response or ACK. */\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
- ("waiting for response for TID:0x%"PRIx64"\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC,\r
+ ("waiting for response for TID:0x%I64x\n",\r
__get_send_tid( h_send )) );\r
\r
__set_retry_time( h_send );\r
*/\r
__mad_disp_resume_send( h_mad_svc->h_mad_reg );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
IN ib_mad_send_handle_t h_send,\r
IN ib_wc_status_t wc_status )\r
{\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("completing TID:0x%"PRIx64"\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC, ("completing TID:0x%I64x\n",\r
__get_send_tid( h_send )) );\r
\r
h_send->p_send_mad->status = wc_status;\r
\r
__cleanup_mad_send( h_mad_svc, h_send );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
IN ib_mad_send_handle_t h_send,\r
IN ib_wc_t *p_wc )\r
{\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
/* Complete the send if the request failed. */\r
if( p_wc->status != IB_WCS_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("y-send failed\n" ) );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("y-send failed\n" ) );\r
return TRUE;\r
}\r
\r
/* Complete the send if it has been canceled. */\r
if( h_send->canceled )\r
{\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
("y-send was canceled\n") );\r
return TRUE;\r
}\r
/* Complete the send if we have its response. */\r
if( h_send->p_resp_mad )\r
{\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
("y-response received\n") );\r
return TRUE;\r
}\r
/* RMPP sends cannot complete until all segments have been acked. */\r
if( h_send->uses_rmpp && (h_send->ack_seg < h_send->total_seg) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
("more RMPP segments to send\n") );\r
return FALSE;\r
}\r
*/\r
if( h_send->p_send_mad->resp_expected )\r
{\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
("no-waiting on response\n") );\r
return FALSE;\r
}\r
else\r
{\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("send completed\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC, ("send completed\n") );\r
return TRUE;\r
}\r
}\r
cl_list_item_t *p_list_item;\r
ib_mad_send_handle_t h_send;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
p_recv_hdr = p_recv_mad->p_mad_buf;\r
\r
h_send = PARENT_STRUCT( p_list_item, al_mad_send_t, pool_item );\r
\r
/* Match on the transaction ID, ignoring internally generated sends. */\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
if( (p_recv_hdr->trans_id == h_send->mad_wr.client_tid) &&\r
!__is_internal_send( h_mad_svc->svc_type, h_send->p_send_mad ) )\r
{\r
ib_mad_t *p_mad_hdr;\r
ib_api_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
p_mad_hdr = ib_get_mad_buf( p_mad_element );\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("recv done TID:0x%"PRIx64"\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC, ("recv done TID:0x%I64x\n",\r
p_mad_hdr->trans_id) );\r
\r
/* Raw MAD services get all receives. */\r
if( h_mad_svc->svc_type == IB_MAD_SVC_RAW )\r
{\r
/* Report the receive. */\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
- ("recv TID:0x%"PRIx64"\n", p_mad_hdr->trans_id) );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
+ ("recv TID:0x%I64x\n", p_mad_hdr->trans_id) );\r
h_mad_svc->pfn_user_recv_cb( h_mad_svc, (void*)h_mad_svc->obj.context,\r
p_mad_element );\r
return;\r
*/\r
if( p_mad_hdr->status & IB_MAD_STATUS_BUSY )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
- ("responder busy TID:0x%"PRIx64"\n", p_mad_hdr->trans_id) );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
+ ("responder busy TID:0x%I64x\n", p_mad_hdr->trans_id) );\r
ib_put_mad( p_mad_element );\r
return;\r
}\r
if( cl_status != CL_SUCCESS )\r
{\r
/* The reassembly is not done. */\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
("no RMPP receive to report\n") );\r
return;\r
}\r
else\r
{\r
/* Report the receive. */\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("unsol recv TID:0x%"PRIx64"\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC, ("unsol recv TID:0x%I64x\n",\r
p_mad_hdr->trans_id) );\r
h_mad_svc->pfn_user_recv_cb( h_mad_svc, (void*)h_mad_svc->obj.context,\r
p_mad_element );\r
}\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
* Try to find the send. The send may have already timed out or\r
* have been canceled, so we need to search for it.\r
*/\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
p_mad_hdr = ib_get_mad_buf( p_mad_element );\r
cl_spinlock_acquire( &h_mad_svc->obj.lock );\r
\r
if( !h_send )\r
{\r
/* A matching send was not found. */\r
- CL_TRACE_EXIT( AL_DBG_WARN, g_al_dbg_lvl,\r
- ("unmatched resp TID:0x%"PRIx64"\n", p_mad_hdr->trans_id) );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
+ ("unmatched resp TID:0x%I64x\n", p_mad_hdr->trans_id) );\r
cl_spinlock_release( &h_mad_svc->obj.lock );\r
ib_put_mad( p_mad_element );\r
return;\r
if( h_send->retry_time == MAX_TIME )\r
{\r
/* The send is currently active. Do not report it. */\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
- ("resp send active TID:0x%"PRIx64"\n", p_mad_hdr->trans_id) );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC,\r
+ ("resp send active TID:0x%I64x\n", p_mad_hdr->trans_id) );\r
h_send->p_resp_mad = p_mad_element;\r
cl_spinlock_release( &h_mad_svc->obj.lock );\r
}\r
else\r
{\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
- ("resp received TID:0x%"PRIx64"\n", p_mad_hdr->trans_id) );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC,\r
+ ("resp received TID:0x%I64x\n", p_mad_hdr->trans_id) );\r
\r
/* Report the send completion below. */\r
cl_qlist_remove_item( &h_mad_svc->send_list,\r
h_send->p_send_mad );\r
__cleanup_mad_send( h_mad_svc, h_send );\r
}\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
{\r
ib_rmpp_mad_t *p_rmpp_mad;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
p_rmpp_mad = (ib_rmpp_mad_t*)ib_get_mad_buf( p_mad_element );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
\r
switch( mad_svc_type )\r
{\r
ib_rmpp_mad_t *p_rmpp_mad;\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
p_rmpp_mad = ib_get_mad_buf( *pp_mad_element );\r
CL_ASSERT( ib_rmpp_is_flag_set( p_rmpp_mad, IB_RMPP_FLAG_ACTIVE ) );\r
break;\r
}\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
return cl_status;\r
}\r
\r
boolean_t send_done = FALSE;\r
ib_wc_status_t wc_status = IB_WCS_SUCCESS;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
p_rmpp_mad = (ib_rmpp_mad_t*)ib_get_mad_buf( p_mad_element );\r
\r
/*\r
if( !h_send )\r
{\r
cl_spinlock_release( &h_mad_svc->obj.lock );\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
("ACK cannot find a matching send\n") );\r
return;\r
}\r
if( cl_ntoh32( p_rmpp_mad->seg_num ) < h_send->ack_seg )\r
{\r
cl_spinlock_release( &h_mad_svc->obj.lock );\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
("old ACK - being dropped\n") );\r
return;\r
}\r
if( h_send->retry_time == MAX_TIME )\r
{\r
cl_spinlock_release( &h_mad_svc->obj.lock );\r
- CL_TRACE_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
("ACK processed, waiting for send to complete\n") );\r
return;\r
}\r
*/\r
__mad_disp_resume_send( h_mad_svc->h_mad_reg );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
ib_mad_send_handle_t h_send;\r
ib_rmpp_mad_t *p_rmpp_mad;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
p_rmpp_mad = (ib_rmpp_mad_t*)ib_get_mad_buf( p_mad_element );\r
\r
/* Search for the send. The send may have timed out or been canceled. */\r
{\r
h_send->canceled = TRUE;\r
cl_spinlock_release( &h_mad_svc->obj.lock );\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
return;\r
}\r
\r
cl_spinlock_release( &h_mad_svc->obj.lock );\r
__notify_send_comp( h_mad_svc, h_send, IB_WCS_CANCELED );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
__send_timer_cb(\r
IN void *context )\r
{\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
__check_send_queue( (ib_mad_svc_handle_t)context );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
uint64_t cur_time;\r
cl_qlist_t timeout_list;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
/*\r
* The timeout out list is used to call the user back without\r
if( h_send->retry_time == MAX_TIME )\r
{\r
/* The request is still active. */\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("active TID:0x%"PRIx64"\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC, ("active TID:0x%I64x\n",\r
__get_send_tid( h_send )) );\r
continue;\r
}\r
if( h_send->canceled )\r
{\r
/* The request has been canceled. */\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("canceling TID:0x%"PRIx64"\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC, ("canceling TID:0x%I64x\n",\r
__get_send_tid( h_send )) );\r
\r
h_send->p_send_mad->status = IB_WCS_CANCELED;\r
if( cur_time < h_send->retry_time )\r
{\r
/* The request has not timed out. */\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("waiting on TID:0x%"PRIx64"\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC, ("waiting on TID:0x%I64x\n",\r
__get_send_tid( h_send )) );\r
\r
/* Set the retry timer to the minimum needed time, in ms. */\r
/* See if we need to retry the send operation. */\r
if( h_send->retry_cnt )\r
{\r
- CL_TRACE( AL_DBG_MAD_SVC, g_al_dbg_lvl, ("retrying TID:0x%"PRIx64"\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MAD_SVC, ("retrying TID:0x%I64x\n",\r
__get_send_tid( h_send )) );\r
\r
/* Retry the send. */\r
continue;\r
}\r
/* The request has timed out or failed to be retried. */\r
- AL_TRACE( AL_DBG_MAD_SVC | AL_DBG_WARN,\r
- ("timing out TID:0x%"PRIx64"\n", __get_send_tid( h_send )) );\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_MAD_SVC,\r
+ ("timing out TID:0x%I64x\n", __get_send_tid( h_send )) );\r
\r
h_send->p_send_mad->status = IB_WCS_TIMEOUT_RETRY_ERR;\r
cl_qlist_remove_item( &h_mad_svc->send_list, p_list_item );\r
__cleanup_mad_send( h_mad_svc, h_send );\r
p_list_item = cl_qlist_remove_head( &timeout_list );\r
}\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
cl_list_item_t *p_list_item, *p_next_item;\r
boolean_t restart_timer;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
h_mad_svc = (ib_mad_svc_handle_t)context;\r
\r
\r
if( restart_timer )\r
cl_timer_start( &h_mad_svc->recv_timer, AL_REASSEMBLY_TIMEOUT );\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
}\r
\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_ca, AL_OBJ_TYPE_H_CA ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_CA_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_CA_HANDLE\n") );\r
return IB_INVALID_CA_HANDLE;\r
}\r
if( !p_mad_in || !p_mad_out )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = verbs_local_mad( h_ca, port_num, p_mad_in, p_mad_out );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
return status;\r
}\r
\r
/* Deregister a MAD pool key if it is of the expected type. */\r
ib_api_status_t\r
dereg_mad_pool(\r
- IN const ib_pool_key_t pool_key ,\r
+ IN const ib_pool_key_t pool_key,\r
IN const al_key_type_t expected_type );\r
\r
\r
#include "al.h"\r
#include "al_ca.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_mcast.tmh"\r
+#endif\r
+\r
#include "al_mgr.h"\r
#include "al_qp.h"\r
#include "al_verbs.h"\r
cl_status_t cl_status;\r
boolean_t sync;\r
\r
- CL_ENTER( AL_DBG_MCAST, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MCAST );\r
\r
/*\r
* Validate the port GUID. There is no need to validate the pkey index as\r
status = get_port_num( h_qp->obj.p_ci_ca, p_mcast_req->port_guid, NULL );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("get_port_num failed, status: %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
h_mcast = cl_zalloc( sizeof( ib_mcast_t ) );\r
if( !h_mcast )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl, ("zalloc of h_mcast failed\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("zalloc of h_mcast failed\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
{\r
if( !cl_is_blockable() )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Thread context not blockable\n") );\r
__free_mcast( &h_mcast->obj );\r
return IB_INVALID_SETTING;\r
cl_status = cl_event_init( &h_mcast->event, TRUE );\r
if( cl_status != CL_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("unable to initialize event for sync operation\n") );\r
__free_mcast( &h_mcast->obj );\r
return ib_convert_cl_status( cl_status );\r
__destroying_mcast, __cleanup_mcast, __free_mcast );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_al_obj returned %s\n", ib_get_err_str( status )) );\r
__free_mcast( &h_mcast->obj );\r
return status;\r
if( status != IB_SUCCESS )\r
{\r
h_mcast->obj.pfn_destroy( &h_mcast->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
}\r
else\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("unable to send join request: %s\n", ib_get_err_str(status)) );\r
h_mcast->obj.pfn_destroy( &h_mcast->obj, NULL );\r
}\r
* have the SA req outstanding.\r
*/\r
\r
- CL_EXIT( AL_DBG_MCAST, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MCAST );\r
return status;\r
}\r
\r
ib_user_query_t sa_mad_data;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MCAST, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MCAST );\r
\r
h_mcast = PARENT_STRUCT( p_obj, ib_mcast_t, obj );\r
\r
if( status != IB_SUCCESS )\r
deref_al_obj( &h_mcast->obj );\r
\r
- CL_EXIT( AL_DBG_MCAST, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MCAST );\r
}\r
\r
\r
ib_mcast_handle_t h_mcast;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MCAST, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MCAST );\r
\r
h_mcast = PARENT_STRUCT( p_obj, ib_mcast_t, obj );\r
\r
*/\r
if( h_mcast->h_ci_mcast )\r
{\r
- CL_TRACE( AL_DBG_MCAST, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MCAST,\r
("detaching from multicast group\n") );\r
status = verbs_detach_mcast( h_mcast );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("detach failed: %s\n", ib_get_err_str(status)) );\r
}\r
}\r
\r
- CL_EXIT( AL_DBG_MCAST, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MCAST );\r
}\r
\r
\r
ib_user_query_t sa_mad_data;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MCAST, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MCAST );\r
\r
/* Set the request information. */\r
p_mcast->sa_reg_req.pfn_sa_req_cb = join_req_cb;\r
\r
if( p_mcast_req->create )\r
{\r
- CL_TRACE( AL_DBG_MCAST, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MCAST,\r
("requesting creation of mcast group\n") );\r
\r
/* Set the necessary creation components. */\r
status = al_send_sa_req( &p_mcast->sa_reg_req, p_mcast->port_guid,\r
p_mcast_req->timeout_ms, p_mcast_req->retry_cnt, &sa_mad_data, 0 );\r
\r
- CL_EXIT( AL_DBG_MCAST, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MCAST );\r
return status;\r
}\r
\r
ib_mcast_handle_t h_mcast;\r
ib_sa_mad_t *p_sa_mad;\r
\r
- CL_ENTER( AL_DBG_MCAST, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MCAST );\r
h_mcast = PARENT_STRUCT( p_sa_req, ib_mcast_t, sa_reg_req );\r
\r
/* Record the status of the join request. */\r
\r
if( p_mad_response )\r
{\r
- CL_TRACE( AL_DBG_MCAST, g_al_dbg_lvl, ("processing response\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MCAST, ("processing response\n") );\r
p_sa_mad = (ib_sa_mad_t*)ib_get_mad_buf( p_mad_response );\r
h_mcast->resp_status = p_sa_mad->status;\r
\r
/* Record the join membership information. */\r
if( h_mcast->req_status == IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_MCAST, g_al_dbg_lvl, ("join successful\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MCAST, ("join successful\n") );\r
h_mcast->member_rec = *((ib_member_rec_t*)p_sa_mad->data);\r
}\r
\r
ib_mcast_rec_t mcast_rec;\r
boolean_t sync;\r
\r
- CL_ENTER( AL_DBG_MCAST, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MCAST );\r
\r
h_mcast = PARENT_STRUCT( p_item, ib_mcast_t, async );\r
\r
else\r
deref_al_obj( &h_mcast->obj );\r
\r
- CL_EXIT( AL_DBG_MCAST, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MCAST );\r
}\r
\r
\r
IN const ib_pfn_destroy_cb_t pfn_destroy_cb OPTIONAL )\r
{\r
\r
- CL_ENTER( AL_DBG_MCAST, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MCAST );\r
\r
if( !h_mcast )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("IB_INVALID_MCAST_HANDLE\n") );\r
return IB_INVALID_MCAST_HANDLE;\r
}\r
{\r
ib_mcast_handle_t h_mcast;\r
\r
- CL_ENTER( AL_DBG_MCAST, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MCAST );\r
h_mcast = PARENT_STRUCT( p_sa_req, ib_mcast_t, sa_dereg_req );\r
\r
if( p_mad_response )\r
* the SA operation is complete.\r
*/\r
deref_al_obj( &h_mcast->obj );\r
- CL_EXIT( AL_DBG_MCAST, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MCAST );\r
}\r
\r
\r
if( status != IB_SUCCESS )\r
{\r
h_attach->obj.pfn_destroy( &h_attach->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
#include "al.h"\r
#include "al_common.h"\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_mgr_shared.tmh"\r
+#endif\r
#include "al_ci_ca.h"\r
#include "ib_common.h"\r
#include "al_debug.h"\r
\r
UNUSED_PARAM( p_obj );\r
\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("AL object %p(%s), parent: %p ref_cnt: %d\n",\r
p_obj, ib_get_obj_type( p_obj ), p_obj->p_parent_obj,\r
p_obj->ref_cnt) );\r
cl_list_item_t *p_list_item;\r
al_ci_ca_t *p_ci_ca;\r
\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MGR );\r
\r
for( p_list_item = cl_qlist_head( &gp_al_mgr->ci_ca_list );\r
p_list_item != cl_qlist_end( &gp_al_mgr->ci_ca_list );\r
if( p_ci_ca->verbs.guid == ci_ca_guid &&\r
p_ci_ca->obj.state == CL_INITIALIZED )\r
{\r
- CL_TRACE( AL_DBG_MGR, g_al_dbg_lvl,\r
- ("find_ci_ca:CA guid %"PRIx64".\n", ci_ca_guid) );\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MGR,\r
+ ("find_ci_ca:CA guid %I64x.\n", ci_ca_guid) );\r
+ AL_EXIT( AL_DBG_MGR );\r
return p_ci_ca;\r
}\r
}\r
\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
return NULL;\r
}\r
\r
release_ci_ca(\r
IN const ib_ca_handle_t h_ca )\r
{\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MGR );\r
remove_ca( h_ca );\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
}\r
\r
\r
add_ci_ca(\r
IN al_ci_ca_t* const p_ci_ca )\r
{\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MGR );\r
cl_spinlock_acquire( &gp_al_mgr->obj.lock );\r
cl_qlist_insert_tail( &gp_al_mgr->ci_ca_list, &p_ci_ca->list_item );\r
ref_al_obj( &gp_al_mgr->obj );\r
cl_spinlock_release( &gp_al_mgr->obj.lock );\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
}\r
\r
\r
remove_ci_ca(\r
IN al_ci_ca_t* const p_ci_ca )\r
{\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MGR );\r
cl_spinlock_acquire( &gp_al_mgr->obj.lock );\r
cl_qlist_remove_item( &gp_al_mgr->ci_ca_list, &p_ci_ca->list_item );\r
cl_spinlock_release( &gp_al_mgr->obj.lock );\r
deref_al_obj( &gp_al_mgr->obj );\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
}\r
\r
\r
ib_ca_attr_t *p_ca_attr = NULL;\r
ib_port_attr_t *p_port_attr = NULL;\r
\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MGR );\r
\r
CL_ASSERT( h_al && p_gid && p_guid );\r
\r
if ( p_guid_array )\r
cl_free( p_guid_array );\r
\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MGR );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !p_gid || !p_ca_guid )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = __get_guid_by_gid( h_al, p_gid, SEARCH_CA_GUID, p_ca_guid );\r
\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MGR );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !p_gid || !p_port_guid )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = __get_guid_by_gid( h_al, p_gid, SEARCH_PORT_GUID, p_port_guid );\r
\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
return status;\r
}\r
\r
al_ci_ca_t *p_ci_ca;\r
uintn_t guid_cnt;\r
\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MGR );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !p_guid_cnt )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
/* Return the actual count. */\r
*p_guid_cnt = guid_cnt;\r
\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
/* Allow CA additions or removals. */\r
cl_spinlock_release( &gp_al_mgr->obj.lock );\r
\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
return IB_SUCCESS;\r
}\r
\r
al_ci_ca_t *p_ci_ca;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MGR );\r
\r
/* Prevent CA additions or removals. */\r
cl_spinlock_acquire( &gp_al_mgr->obj.lock );\r
index >= cl_qlist_count( &gp_al_mgr->ci_ca_list ) )\r
{\r
cl_spinlock_release( &gp_al_mgr->obj.lock );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_INDEX\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_INDEX\n") );\r
return IB_INVALID_INDEX;\r
}\r
\r
\r
cl_spinlock_release( &gp_al_mgr->obj.lock );\r
\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
return status;\r
}\r
\r
al_ci_ca_t *p_ci_ca;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MGR );\r
\r
/* Prevent CA additions or removals. */\r
cl_spinlock_acquire( &gp_al_mgr->obj.lock );\r
status = IB_INVALID_INDEX;\r
}\r
\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MGR );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !p_guid )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
break;\r
\r
case IB_PNP_IOC:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("IOC GUIDs not supported at this time\n") );\r
return IB_UNSUPPORTED;\r
\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_SETTING\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_SETTING\n") );\r
return IB_INVALID_SETTING;\r
}\r
\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
return status;\r
}\r
\r
#include <iba/ib_al.h>\r
#include "al.h"\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_mr_shared.tmh"\r
+#endif\r
#include "al_mr.h"\r
#include "al_pd.h"\r
#include "al_res_mgr.h"\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MR );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
\r
ib_mr_handle_t h_mr;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MR );\r
\r
if( !p_mr_create || !p_lkey || !p_rkey || !ph_mr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
h_mr = alloc_mr();\r
if( !h_mr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("unable to allocate memory handle\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( status != IB_SUCCESS )\r
{\r
h_mr->obj.pfn_destroy( &h_mr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
h_mr->obj.pfn_destroy( &h_mr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("unable to register memory: %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
\r
*ph_mr = h_mr;\r
\r
- CL_EXIT( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return IB_SUCCESS;\r
}\r
\r
ib_mr_handle_t h_mr;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MR );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
if( !p_vaddr || !p_lkey || !p_rkey || !ph_mr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
h_mr = alloc_mr();\r
if( !h_mr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("unable to allocate memory handle\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( status != IB_SUCCESS )\r
{\r
h_mr->obj.pfn_destroy( &h_mr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
p_lkey, p_rkey, h_mr );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("unable to register memory: %s\n", ib_get_err_str(status)) );\r
h_mr->obj.pfn_destroy( &h_mr->obj, NULL );\r
return status;\r
/* Release the reference taken in alloc_mr for initialization. */\r
deref_al_obj( &h_mr->obj );\r
\r
- CL_EXIT( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return IB_SUCCESS;\r
}\r
\r
{\r
if( AL_OBJ_INVALID_HANDLE( h_mr, AL_OBJ_TYPE_H_MR ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_MR_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_MR_HANDLE\n") );\r
return IB_INVALID_MR_HANDLE;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MR );\r
\r
if( ( mr_mod_mask & IB_MR_MOD_PD ) )\r
{\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
if( h_pd->obj.h_al != h_mr->obj.h_al )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
}\r
if( !p_lkey || !p_rkey )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
/* If we're changing the PD, we need to update the object hierarchy. */\r
if( h_pd && (status == IB_SUCCESS) )\r
{\r
- CL_TRACE( AL_DBG_MR, g_al_dbg_lvl, ("associating MR with new PD\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MR, ("associating MR with new PD\n") );\r
detach_al_obj( &h_mr->obj );\r
deref_al_obj( h_mr->obj.p_parent_obj );\r
status = attach_al_obj( &h_pd->obj, &h_mr->obj );\r
CL_ASSERT( status );\r
}\r
\r
- CL_EXIT( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MR );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_mr, AL_OBJ_TYPE_H_MR ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_MR_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_MR_HANDLE\n") );\r
return IB_INVALID_MR_HANDLE;\r
}\r
if( ( mr_mod_mask & IB_MR_MOD_PD ) )\r
{\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
if( h_pd->obj.p_parent_obj != h_mr->obj.p_parent_obj->p_parent_obj )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
}\r
if( !p_vaddr || !p_lkey || !p_rkey )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
/* If we're changing the PD, we need to update the object hierarchy. */\r
if( h_pd && (status == IB_SUCCESS) )\r
{\r
- CL_TRACE( AL_DBG_MR, g_al_dbg_lvl, ("associating MR with new PD\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MR, ("associating MR with new PD\n") );\r
detach_al_obj( &h_mr->obj );\r
deref_al_obj( h_mr->obj.p_parent_obj );\r
status = attach_al_obj( &h_pd->obj, &h_mr->obj );\r
CL_ASSERT( status );\r
}\r
\r
- CL_EXIT( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return status;\r
}\r
\r
\r
if( AL_OBJ_INVALID_HANDLE( h_mr, AL_OBJ_TYPE_H_MR ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_MR_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_MR_HANDLE\n") );\r
return IB_INVALID_MR_HANDLE;\r
}\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
\r
ib_mr_handle_t h_new_mr;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MR );\r
\r
if( !p_vaddr || !p_lkey || !p_rkey || !ph_mr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
h_new_mr = alloc_mr();\r
if( !h_new_mr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("unable to allocate memory handle\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( status != IB_SUCCESS )\r
{\r
h_new_mr->obj.pfn_destroy( &h_new_mr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
h_new_mr->obj.pfn_destroy( &h_new_mr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("unable to register memory: %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
\r
*ph_mr = h_new_mr;\r
\r
- CL_EXIT( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MR );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_mr, AL_OBJ_TYPE_H_MR ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_MR_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_MR_HANDLE\n") );\r
return IB_INVALID_MR_HANDLE;\r
}\r
\r
if( status != IB_SUCCESS )\r
deref_al_obj( &h_mr->obj );\r
\r
- CL_EXIT( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return status;\r
}\r
\r
\r
if( !verbs_check_mr(h_mr) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_MR_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_MR_HANDLE\n") );\r
return IB_INVALID_MR_HANDLE;\r
}\r
\r
h_mr->obj.pfn_destroy( &h_mr->obj, NULL );\r
}\r
\r
- CL_EXIT( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MR );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_mr, AL_OBJ_TYPE_H_MR ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_MR_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_MR_HANDLE\n") );\r
return IB_INVALID_MR_HANDLE;\r
}\r
if( !p_mr_attr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
}\r
else\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("unable to query memory region: %s\n", ib_get_err_str(status)) );\r
}\r
\r
- CL_EXIT( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return status;\r
}\r
#include <iba/ib_al.h>\r
\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_mw.tmh"\r
+#endif\r
#include "al_mw.h"\r
#include "al_pd.h"\r
#include "al_verbs.h"\r
\r
if( !p_rkey || !ph_mw )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
h_mw->obj.pfn_destroy( &h_mw->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MW, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MW );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_mw, AL_OBJ_TYPE_H_MW ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_MW_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_MW_HANDLE\n") );\r
return IB_INVALID_MW_HANDLE;\r
}\r
\r
if( status != IB_SUCCESS )\r
deref_al_obj( &h_mw->obj );\r
\r
- CL_EXIT( AL_DBG_MW, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MW );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MW, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MW );\r
\r
if( !verbs_check_mw( h_mw ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_MW_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_MW_HANDLE\n") );\r
return IB_INVALID_MW_HANDLE;\r
}\r
\r
ib_pd_handle_t h_ci_pd;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MW, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MW );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_mw, AL_OBJ_TYPE_H_MW ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_MW_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_MW_HANDLE\n") );\r
return IB_INVALID_MW_HANDLE;\r
}\r
if( !ph_pd || !p_rkey )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
CL_ASSERT( (*ph_pd)->h_ci_pd == h_ci_pd );\r
}\r
\r
- CL_EXIT( AL_DBG_MW, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MW );\r
return status;\r
}\r
#include "al_ca.h"\r
#include "al_cq.h"\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_pd.tmh"\r
+#endif\r
#include "al_mgr.h"\r
#include "al_mr.h"\r
#include "al_mw.h"\r
\r
if( !ph_pd )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
h_pd->obj.pfn_destroy( &h_pd->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
IN const ib_pd_handle_t h_pd,\r
IN const ib_pfn_destroy_cb_t pfn_destroy_cb OPTIONAL )\r
{\r
- CL_ENTER( AL_DBG_PD, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PD );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
\r
ref_al_obj( &h_pd->obj );\r
h_pd->obj.pfn_destroy( &h_pd->obj, pfn_destroy_cb );\r
\r
- CL_EXIT( AL_DBG_PD, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PD );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QP );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
\r
if( status == IB_SUCCESS )\r
deref_al_obj( &(*ph_qp)->obj );\r
\r
- CL_EXIT( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QP );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
\r
if( status == IB_SUCCESS )\r
deref_al_obj( &(*ph_qp)->obj );\r
\r
- CL_EXIT( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_AV, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_AV );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
\r
if( status == IB_SUCCESS )\r
deref_al_obj( &(*ph_av)->obj );\r
\r
- CL_EXIT( AL_DBG_AV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AV );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MW, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MW );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
\r
if( status == IB_SUCCESS )\r
deref_al_obj( &(*ph_mw)->obj );\r
\r
- CL_EXIT( AL_DBG_MW, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MW );\r
return status;\r
}\r
\r
#include "al_cm_cep.h"\r
#include "al_cq.h"\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_qp.tmh"\r
+#endif\r
#include "al_mad.h"\r
#include "al_mad_pool.h"\r
#include "al_mcast.h"\r
\r
if( !p_qp_create || !ph_qp )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
\r
if( !p_qp_create || !ph_qp )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
IN const ib_qp_handle_t h_qp,\r
IN const ib_pfn_destroy_cb_t pfn_destroy_cb OPTIONAL )\r
{\r
- CL_ENTER( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QP );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_qp, AL_OBJ_TYPE_H_QP ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
\r
ref_al_obj( &h_qp->obj );\r
h_qp->obj.pfn_destroy( &h_qp->obj, pfn_destroy_cb );\r
\r
- CL_EXIT( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return IB_SUCCESS;\r
}\r
\r
status = dereg_mad_pool( p_qp_alias->pool_key, AL_KEY_ALIAS );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR, ("dereg_mad_pool returned %s.\n",\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("dereg_mad_pool returned %s.\n",\r
ib_get_err_str(status)) );\r
deref_al_obj( &p_qp_alias->pool_key->obj );\r
}\r
status = verbs_destroy_qp( h_qp );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("verbs_destroy_qp failed with status %s.\n",\r
ib_get_err_str(status)) );\r
}\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QP );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_qp, AL_OBJ_TYPE_H_QP ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
if( !p_qp_attr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = verbs_query_qp( h_qp, p_qp_attr );\r
if( status != IB_SUCCESS )\r
{\r
- CL_EXIT( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return status;\r
}\r
\r
p_qp_attr->h_sq_cq = h_qp->h_send_cq;\r
p_qp_attr->qp_type = h_qp->type;\r
\r
- CL_EXIT( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QP );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_qp, AL_OBJ_TYPE_H_QP ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
if( !p_qp_mod )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = h_qp->pfn_modify_qp( h_qp, p_qp_mod, p_umv_buf );\r
\r
- CL_EXIT( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QP );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_qp, AL_OBJ_TYPE_H_QP ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
\r
case IB_QPT_MAD:\r
if( !p_dgrm_info )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
break;\r
\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = h_qp->pfn_init_dgrm_svc( h_qp, p_dgrm_info );\r
\r
- CL_EXIT( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_SVC );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_qp, AL_OBJ_TYPE_H_QP ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
\r
if( status == IB_SUCCESS )\r
deref_al_obj( &(*ph_mad_svc)->obj );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_SVC );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MCAST, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MCAST );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_qp, AL_OBJ_TYPE_H_QP ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
if( !p_mcast_req )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = h_qp->pfn_join_mcast( h_qp, p_mcast_req );\r
\r
- CL_EXIT( AL_DBG_MCAST, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MCAST );\r
return status;\r
}\r
\r
PERF_DECLARE( PostSend );\r
\r
cl_perf_start( IbPostSend );\r
- CL_ENTER( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QP );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_qp, AL_OBJ_TYPE_H_QP ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
if( !p_send_wr || ( p_send_wr->p_next && !pp_send_failure ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
h_qp->pfn_post_send( h_qp->h_send_qp, p_send_wr, pp_send_failure );\r
cl_perf_stop( &g_perf, PostSend );\r
\r
- CL_EXIT( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
cl_perf_stop( &g_perf, IbPostSend );\r
return status;\r
}\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QP );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_qp, AL_OBJ_TYPE_H_QP ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
if( !p_recv_wr || ( p_recv_wr->p_next && !pp_recv_failure ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status =\r
h_qp->pfn_post_recv( h_qp->h_recv_qp, p_recv_wr, pp_recv_failure );\r
\r
- CL_EXIT( AL_DBG_QP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return status;\r
}\r
\r
ib_mr_handle_t h_mr;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MW, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MW );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_mw, AL_OBJ_TYPE_H_MW ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_MW_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_MW_HANDLE\n") );\r
return IB_INVALID_MW_HANDLE;\r
}\r
if( AL_OBJ_INVALID_HANDLE( h_qp, AL_OBJ_TYPE_H_QP ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
if( !p_mw_bind || !p_rkey )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
\r
p_mw_bind->h_mr = h_mr;\r
\r
- CL_EXIT( AL_DBG_MW, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MW );\r
return status;\r
}\r
#include "al_ca.h"\r
#include "al_common.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_query.tmh"\r
+#endif\r
#include "al_mgr.h"\r
#include "al_query.h"\r
#include "ib_common.h"\r
al_query_t *p_query;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_QUERY, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QUERY );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !p_query_req )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
if( (p_query_req->flags & IB_FLAGS_SYNC) && !cl_is_blockable() )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_UNSUPPORTED\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_UNSUPPORTED\n") );\r
return IB_UNSUPPORTED;\r
}\r
\r
p_query = cl_zalloc( sizeof( al_query_t ) );\r
if( !p_query )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("insufficient memory\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("insufficient memory\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
status = query_sa( p_query, p_query_req, p_query_req->flags );\r
if( status != IB_SUCCESS && status != IB_INVALID_GUID )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("query_sa failed: %s\n", ib_get_err_str(status) ) );\r
}\r
\r
cl_free( p_query );\r
}\r
\r
- CL_EXIT( AL_DBG_QUERY, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QUERY );\r
return status;\r
}\r
\r
} rec;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_QUERY, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QUERY );\r
\r
cl_memclr( &rec, sizeof(rec) );\r
\r
switch( p_query_req->query_type )\r
{\r
case IB_QUERY_USER_DEFINED:\r
- CL_TRACE( AL_DBG_QUERY, g_al_dbg_lvl, ("USER_DEFINED\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_QUERY, ("USER_DEFINED\n") );\r
p_sa_req = (ib_user_query_t* __ptr64)p_query_req->p_query_input;\r
if( !p_sa_req->method )\r
{\r
break;\r
\r
case IB_QUERY_ALL_SVC_RECS:\r
- CL_TRACE( AL_DBG_QUERY, g_al_dbg_lvl, ("IB_QUERY_ALL_SVC_RECS\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_QUERY, ("IB_QUERY_ALL_SVC_RECS\n") );\r
sa_req.attr_id = IB_MAD_ATTR_SERVICE_RECORD;\r
sa_req.attr_size = sizeof( ib_service_record_t );\r
sa_req.comp_mask = 0;\r
break;\r
\r
case IB_QUERY_SVC_REC_BY_NAME:\r
- CL_TRACE( AL_DBG_QUERY, g_al_dbg_lvl, ("SVC_REC_BY_NAME\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_QUERY, ("SVC_REC_BY_NAME\n") );\r
sa_req.attr_id = IB_MAD_ATTR_SERVICE_RECORD;\r
sa_req.attr_size = sizeof( ib_service_record_t );\r
sa_req.comp_mask = IB_SR_COMPMASK_SNAME;\r
break;\r
\r
case IB_QUERY_SVC_REC_BY_ID:\r
- CL_TRACE( AL_DBG_QUERY, g_al_dbg_lvl, ("SVC_REC_BY_ID\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_QUERY, ("SVC_REC_BY_ID\n") );\r
sa_req.attr_id = IB_MAD_ATTR_SERVICE_RECORD;\r
sa_req.attr_size = sizeof( ib_service_record_t );\r
sa_req.comp_mask = IB_SR_COMPMASK_SID;\r
break;\r
\r
case IB_QUERY_CLASS_PORT_INFO:\r
- CL_TRACE( AL_DBG_QUERY, g_al_dbg_lvl, ("IB_QUERY_CLASS_PORT_INFO\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_QUERY, ("IB_QUERY_CLASS_PORT_INFO\n") );\r
sa_req.method = IB_MAD_METHOD_GET;\r
sa_req.attr_id = IB_MAD_ATTR_CLASS_PORT_INFO;\r
sa_req.attr_size = sizeof( ib_class_port_info_t );\r
break;\r
\r
case IB_QUERY_NODE_REC_BY_NODE_GUID:\r
- CL_TRACE( AL_DBG_QUERY, g_al_dbg_lvl, ("NODE_REC_BY_NODE_GUID\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_QUERY, ("NODE_REC_BY_NODE_GUID\n") );\r
/*\r
* 15.2.5.2:\r
* if >1 ports on of a CA/RTR the subnet return multiple\r
break;\r
\r
case IB_QUERY_PORT_REC_BY_LID:\r
- CL_TRACE( AL_DBG_QUERY, g_al_dbg_lvl, ("PORT_REC_BY_LID\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_QUERY, ("PORT_REC_BY_LID\n") );\r
sa_req.attr_id = IB_MAD_ATTR_PORTINFO_RECORD;\r
sa_req.attr_size = sizeof( ib_portinfo_record_t );\r
sa_req.comp_mask = IB_PIR_COMPMASK_BASELID;\r
break;\r
\r
case IB_QUERY_PATH_REC_BY_PORT_GUIDS:\r
- CL_TRACE( AL_DBG_QUERY, g_al_dbg_lvl, ("PATH_REC_BY_PORT_GUIDS\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_QUERY, ("PATH_REC_BY_PORT_GUIDS\n") );\r
sa_req.attr_id = IB_MAD_ATTR_PATH_RECORD;\r
sa_req.attr_size = sizeof( ib_path_rec_t );\r
sa_req.comp_mask = (IB_PR_COMPMASK_DGID |\r
break;\r
\r
case IB_QUERY_PATH_REC_BY_GIDS:\r
- CL_TRACE( AL_DBG_QUERY, g_al_dbg_lvl, ("PATH_REC_BY_GIDS\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_QUERY, ("PATH_REC_BY_GIDS\n") );\r
sa_req.attr_id = IB_MAD_ATTR_PATH_RECORD;\r
sa_req.attr_size = sizeof( ib_path_rec_t );\r
sa_req.comp_mask = (IB_PR_COMPMASK_DGID |\r
break;\r
\r
case IB_QUERY_PATH_REC_BY_LIDS:\r
- CL_TRACE( AL_DBG_QUERY, g_al_dbg_lvl, ("PATH_REC_BY_LIDS\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_QUERY, ("PATH_REC_BY_LIDS\n") );\r
/* SGID must be provided for GET_TABLE requests. */\r
sa_req.method = IB_MAD_METHOD_GET;\r
sa_req.attr_id = IB_MAD_ATTR_PATH_RECORD;\r
break;\r
\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("UNKNOWN\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("UNKNOWN\n") );\r
CL_ASSERT( p_query_req->query_type == IB_QUERY_USER_DEFINED ||\r
p_query_req->query_type == IB_QUERY_ALL_SVC_RECS ||\r
p_query_req->query_type == IB_QUERY_SVC_REC_BY_NAME ||\r
status = al_send_sa_req(\r
&p_query->sa_req, p_query_req->port_guid, p_query_req->timeout_ms,\r
p_query_req->retry_cnt, p_sa_req, flags );\r
- CL_EXIT( AL_DBG_QUERY, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QUERY );\r
return status;\r
}\r
\r
ib_query_rec_t query_rec;\r
ib_sa_mad_t *p_sa_mad;\r
\r
- CL_ENTER( AL_DBG_QUERY, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QUERY );\r
p_query = PARENT_STRUCT( p_sa_req, al_query_t, sa_req );\r
\r
/* Initialize the results of the query. */\r
/* Form the result of the query, if we got one. */\r
if( query_rec.status == IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_QUERY, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_QUERY,\r
("query succeeded\n") );\r
\r
CL_ASSERT( p_mad_response );\r
}\r
else\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("query failed: %s\n", ib_get_err_str(query_rec.status) ) );\r
if( p_mad_response )\r
query_rec.p_result_mad = p_mad_response;\r
al_remove_query( p_query );\r
cl_free( p_query );\r
\r
- CL_EXIT( AL_DBG_QUERY, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QUERY );\r
}\r
\r
#include "al.h"\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_reg_svc.tmh"\r
+#endif\r
#include "al_reg_svc.h"\r
#include "ib_common.h"\r
#include "al_mgr.h"\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !p_reg_svc_req )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
__destroying_sa_reg, NULL, __free_sa_reg );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_al_obj returned %s.\n", ib_get_err_str( status )) );\r
__free_sa_reg( &h_sa_reg->obj );\r
return status;\r
if( status != IB_SUCCESS )\r
{\r
h_sa_reg->obj.pfn_destroy( &h_sa_reg->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str( status )) );\r
return status;\r
}\r
status = sa_reg_svc( h_sa_reg, p_reg_svc_req );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("sa_reg_svc failed: %s\n", ib_get_err_str(status) ) );\r
h_sa_reg->state = SA_REG_ERROR;\r
\r
\r
if( !h_reg_svc )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
\r
#include "al_res_mgr.h"\r
#include "al_debug.h"\r
\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_res_mgr.tmh"\r
+#endif\r
+\r
\r
#define AL_MR_POOL_SIZE (4096 / sizeof( ib_mr_t ))\r
#define AL_AV_POOL_SIZE (4096 / sizeof( ib_av_t ))\r
if( status != IB_SUCCESS )\r
{\r
gp_res_mgr->obj.pfn_destroy( &gp_res_mgr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
#include "al.h"\r
#include "al_common.h"\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_sub.tmh"\r
+#endif\r
#include "al_sub.h"\r
\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SUB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SUB );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !p_sub_req || !ph_sub )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = IB_UNSUPPORTED;\r
\r
- CL_EXIT( AL_DBG_SUB, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SUB );\r
return status;\r
}\r
\r
IN const ib_sub_handle_t h_sub,\r
IN const ib_pfn_destroy_cb_t pfn_destroy_cb OPTIONAL )\r
{\r
- CL_ENTER( AL_DBG_SUB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SUB );\r
\r
if( !h_sub )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
\r
UNUSED_PARAM( pfn_destroy_cb );\r
\r
- CL_EXIT( AL_DBG_SUB, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SUB );\r
return IB_UNSUPPORTED;\r
}\r
TARGETPATH=..\..\..\bin\kernel\obj$(BUILD_ALT_DIR)\r
TARGETTYPE=DRIVER_LIBRARY\r
\r
+\r
+\r
+!if $(FREEBUILD)\r
+#ENABLE_EVENT_TRACING=1\r
+!else\r
+#ENABLE_EVENT_TRACING=1\r
+!endif\r
+\r
+\r
DLLDEF=al_exports.def\r
\r
SOURCES= ibal.rc \\r
TARGETLIBS= $(TARGETLIBS) $(DDK_LIB_PATH)\ntstrsafe.lib\r
!endif\r
\r
+\r
+!IFDEF ENABLE_EVENT_TRACING\r
+\r
+C_DEFINES = $(C_DEFINES) -DEVENT_TRACING\r
+\r
+RUN_WPP = $(SOURCES) -km -ext: .c .h .C .H \\r
+ -scan:..\al_debug.h \\r
+ -func:AL_PRINT(LEVEL,FLAGS,(MSG,...)) \\r
+ -func:AL_PRINT_EXIT(LEVEL,FLAGS,(MSG,...))\r
+!ENDIF\r
+\r
MSC_WARNING_LEVEL= /W4\r
#include "al_verbs.h"\r
#include "al_cq.h"\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_ci_ca.tmh"\r
+#endif\r
#include "al_mad_pool.h"\r
#include "al_mgr.h"\r
#include "al_mr.h"\r
cl_status_t cl_status;\r
al_ci_ca_t *p_ci_ca;\r
\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
CL_ASSERT( p_ci );\r
\r
p_ci_ca = (al_ci_ca_t*)cl_zalloc( sizeof( al_ci_ca_t ) );\r
if( !p_ci_ca )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_zalloc failed\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( cl_status != CL_SUCCESS )\r
{\r
free_ci_ca( &p_ci_ca->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_spinlock_init failed, status = 0x%x.\n",\r
ib_convert_cl_status( cl_status ) ) );\r
return ib_convert_cl_status( cl_status );\r
if( cl_status != CL_SUCCESS )\r
{\r
free_ci_ca( &p_ci_ca->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_qpool_init failed, status = 0x%x.\n", \r
ib_convert_cl_status( cl_status ) ) );\r
return ib_convert_cl_status( cl_status );\r
if( status != IB_SUCCESS )\r
{\r
free_ci_ca( &p_ci_ca->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_al_obj failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_ci_ca->obj.pfn_destroy( &p_ci_ca->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_ci_ca->obj.pfn_destroy( &p_ci_ca->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("open_ca failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_ci_ca->obj.pfn_destroy( &p_ci_ca->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_open_ca failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_ci_ca->obj.pfn_destroy( &p_ci_ca->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("get_port_guids failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_ci_ca->obj.pfn_destroy( &p_ci_ca->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_alloc_pd failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_ci_ca->obj.pfn_destroy( &p_ci_ca->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_alloc_pd alias failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_ci_ca->obj.pfn_destroy( &p_ci_ca->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_reg_mad_pool failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
{\r
/* Destroy the CA */\r
p_ci_ca->obj.pfn_destroy( &p_ci_ca->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_pnp_add_ca failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &p_ci_ca->obj );\r
\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return IB_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
al_ci_ca_t *p_ci_ca;\r
\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
CL_ASSERT( p_obj );\r
p_ci_ca = PARENT_STRUCT( p_obj, al_ci_ca_t, obj );\r
CL_ASSERT( status == IB_SUCCESS );\r
}\r
\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
}\r
\r
\r
{\r
ib_async_event_rec_t event_rec;\r
\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
CL_ASSERT( p_event_record );\r
\r
\r
ci_ca_async_event( &event_rec );\r
\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
}\r
\r
\r
void* __ptr64 * p_handle_array;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_ca, AL_OBJ_TYPE_H_CA ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_CA_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_CA_HANDLE\n") );\r
return IB_INVALID_CA_HANDLE;\r
}\r
if( !p_ci_op )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
p_handle_array = NULL;\r
if ( num_handles )\r
cl_free( p_handle_array );\r
\r
- CL_EXIT( AL_DBG_QUERY, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QUERY );\r
return status;\r
}\r
#include "al_cm.h"\r
#include "al_cm_shared.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_cm.tmh"\r
+#endif\r
+\r
#include "al_mgr.h"\r
#include "al_qp.h"\r
\r
al_conn_t *p_conn;\r
uint32_t i;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_spinlock_acquire( &gp_cm->obj.lock );\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("CM info:\n"\r
"\tactive_listen_list..: %"PRIdSIZE_T"\n"\r
"\tinactive_listen_list: %"PRIdSIZE_T"\n"\r
cl_pool_count( &gp_cm->req_pool ),\r
cl_qmap_count( &gp_cm->conn_map ) ) );\r
/* walk lists for connection info */\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,("Active listens:\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("Active listens:\n") );\r
i = 1;\r
\r
for( p_item = cl_qlist_head( &gp_cm->active_listen_list );\r
{\r
p_listen = PARENT_STRUCT( p_item, al_listen_t, list_item );\r
\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("\n%d)\n"\r
- "\tservice_id...:0x%"PRIx64"\n"\r
+ "\tservice_id...:0x%I64x\n"\r
"\tlid..........:0x%x\n"\r
- "\tport_guid....:0x%"PRIx64"\n"\r
+ "\tport_guid....:0x%I64x\n"\r
"\tqp_type......:%d\n",\r
i++,\r
p_listen->info.svc_id, p_listen->info.lid,\r
}\r
\r
\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,("Inactive listens:\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("Inactive listens:\n") );\r
i = 1;\r
\r
for( p_item = cl_qlist_head( &gp_cm->inactive_listen_list );\r
{\r
p_listen = PARENT_STRUCT( p_item, al_listen_t, list_item );\r
\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("\n%d)\n"\r
- "\tservice_id...:0x%"PRIx64"\n"\r
+ "\tservice_id...:0x%I64x\n"\r
"\tlid..........:0x%x\n"\r
- "\tport_guid....:0x%"PRIx64"\n"\r
+ "\tport_guid....:0x%I64x\n"\r
"\tqp_type......:%d\n",\r
i++,\r
p_listen->info.svc_id, p_listen->info.lid,\r
}\r
\r
\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,("In Timewait:\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("In Timewait:\n") );\r
i = 1;\r
\r
for( p_item = cl_qlist_head( &gp_cm->time_wait_list );\r
{\r
p_conn = PARENT_STRUCT( p_item, al_conn_t, map_item );\r
\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("\n%d)\n"\r
"\tstate........:%d\n"\r
"\tref_cnt......:%d\n"\r
\r
cl_spinlock_release( &gp_cm->obj.lock );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
#endif\r
}\r
\r
__cm_pnp_dereg_cb(\r
IN void *context )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
UNUSED_PARAM( context );\r
\r
deref_al_obj( &gp_cm->obj );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( &gp_cm->obj == p_obj );\r
UNUSED_PARAM( p_obj );\r
status = ib_dereg_pnp( gp_cm->h_pnp, __cm_pnp_dereg_cb );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_dereg_pnp failed with status %s.\n",\r
ib_get_err_str(status)) );\r
deref_al_obj( &gp_cm->obj );\r
\r
/* Cancel all timewait timers. */\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
__free_cm(\r
IN al_obj_t* p_obj )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( &gp_cm->obj == p_obj );\r
/* All listen request should have been cleaned up by this point. */\r
cl_free( gp_cm );\r
gp_cm = NULL;\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
{\r
cm_port_agent_t *p_port_cm;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_port_cm = PARENT_STRUCT( p_obj, cm_port_agent_t, obj );\r
\r
p_port_cm->h_pd = NULL;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
{\r
cm_port_agent_t *p_port_cm;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_port_cm = PARENT_STRUCT( p_obj, cm_port_agent_t, obj );\r
\r
destroy_al_obj( &p_port_cm->obj );\r
cl_free( p_port_cm );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
ib_av_attr_t av_attr;\r
cl_list_item_t *p_list_item;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_spinlock_acquire( &p_port_cm->lock );\r
\r
}\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
ib_av_t *h_av;\r
uint32_t ref_cnt;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
h_av = p_mad->h_av;\r
\r
cl_spinlock_release( &p_port_cm->lock );\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
al_conn_t *p_conn;\r
uint8_t counter;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
CL_ASSERT( h_al && h_al->obj.type == AL_OBJ_TYPE_H_AL );\r
\r
cl_spinlock_acquire( &gp_cm->obj.lock );\r
if( !p_item )\r
{\r
cl_spinlock_release( &gp_cm->obj.lock );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_qpool_get failed for al_conn_t.\n") );\r
return NULL;\r
}\r
{\r
cl_qpool_put( &gp_cm->conn_pool, (cl_pool_item_t*)&p_conn->map_item );\r
cl_spinlock_release( &gp_cm->obj.lock );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_pool_get failed for conn_req_t.\n") );\r
return NULL;\r
}\r
p_conn->p_req_info = NULL;\r
cl_qpool_put( &gp_cm->conn_pool, (cl_pool_item_t*)&p_conn->map_item );\r
cl_spinlock_release( &gp_cm->obj.lock );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_insert_conn failed for conn_req_t.\n") );\r
return NULL;\r
}\r
\r
ref_al_obj( &gp_cm->obj );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return p_conn;\r
}\r
\r
__ref_conn(\r
IN al_conn_t* const p_conn )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_atomic_inc( &p_conn->ref_cnt );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
{\r
ib_qp_handle_t h_qp;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/*\r
* Destruction of the connection object and unbinding it from the QP\r
if( h_qp )\r
{\r
/* We shouldn't have a QP at this point. */\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("QP (%p) still referenced by connection object\n", h_qp) );\r
cm_reset_qp( h_qp, 0 );\r
deref_al_obj( &h_qp->obj );\r
cl_spinlock_release( &gp_cm->obj.lock );\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
ib_api_status_t status;\r
ib_grh_t grh;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_conn );\r
\r
status = ib_get_mad( p_port_cm->pool_key, MAD_BLOCK_SIZE, &p_mad );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_get_mad failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
{\r
__deref_conn( p_conn );\r
ib_put_mad( p_mad );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__get_av failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
p_conn->p_send_mad = NULL;\r
__deref_conn( p_conn );\r
ib_put_mad( p_mad );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_send_mad failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_port_cm );\r
CL_ASSERT( p_mad );\r
if( status != IB_SUCCESS )\r
{\r
ib_put_mad( p_mad );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__get_av failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
ib_put_mad( p_mad );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_send_mad failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_port_cm );\r
CL_ASSERT( p_conn );\r
}\r
cm_res_release( p_conn );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
ib_mad_t *p_hdr;\r
cm_async_mad_t *p_async_mad;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
UNUSED_PARAM( h_mad_svc );\r
\r
if( !p_async_mad )\r
{\r
ib_put_mad( p_mad );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("failed to cl_zalloc cm_async_mad_t (%d bytes)\n",\r
sizeof(cm_async_mad_t)) );\r
return;\r
default:\r
cl_free( p_async_mad );\r
ib_put_mad( p_mad );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid CM MAD attribute ID.\n") );\r
return;\r
}\r
/* Queue the MAD for asynchronous processing. */\r
cl_async_proc_queue( gp_async_proc_mgr, &p_async_mad->item );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
{\r
cm_async_mad_t *p_async_mad;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
UNUSED_PARAM( h_mad_svc );\r
CL_ASSERT( p_mad->p_next == NULL );\r
if( !p_async_mad )\r
{\r
ib_put_mad( p_mad );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("failed to cl_zalloc cm_async_mad_t (%d bytes)\n",\r
sizeof(cm_async_mad_t)) );\r
return;\r
/* Queue the MAD for asynchronous processing. */\r
cl_async_proc_queue( gp_async_proc_mgr, &p_async_mad->item );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
al_conn_t *p_conn;\r
ib_mad_element_t *p_mad;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_async_mad = PARENT_STRUCT( p_item, cm_async_mad_t, item );\r
p_mad = p_async_mad->p_mad;\r
{\r
__put_av( p_port_cm, p_mad );\r
ib_put_mad( p_mad );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return;\r
}\r
\r
__put_av( p_port_cm, p_mad );\r
ib_put_mad( p_mad );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
cm_conn_migrated(\r
IN al_conn_t* const p_conn )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Update the index to the primary path. */\r
cm_res_acquire( p_conn );\r
/* Only the lowest bit is valid (0 or 1). */\r
p_conn->idx_primary&=0x1;\r
cm_res_release( p_conn );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
/*\r
ib_qp_create_t qp_create;\r
ib_mad_svc_t mad_svc;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_status = cl_spinlock_init( &p_port_cm->lock );\r
if( cl_status != CL_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_spinlock_init failed\n") );\r
return ib_convert_cl_status( cl_status );\r
}\r
&p_port_cm->h_pd );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_alloc_pd failed with status %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
&p_port_cm->h_qp );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_get_spl_qp failed with status %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
ib_reg_mad_svc( p_port_cm->h_qp, &mad_svc, &p_port_cm->h_mad_svc );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_reg_mad_svc failed with status %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
ib_port_attr_mod_t port_attr_mod;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* calculate size of port_cm struct */\r
p_port_cm = (cm_port_agent_t*)cl_zalloc( sizeof(cm_port_agent_t) +\r
p_pnp_rec->p_ca_attr->size );\r
if( !p_port_cm )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Failed to cl_zalloc port CM agent.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( status != IB_SUCCESS )\r
{\r
__free_port_cm( &p_port_cm->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_al_obj failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_port_cm->obj.pfn_destroy( &p_port_cm->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( !p_port_cm->h_ca )\r
{\r
p_port_cm->obj.pfn_destroy( &p_port_cm->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("acquire_ca failed.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("acquire_ca failed.\n") );\r
return IB_INVALID_GUID;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
p_port_cm->obj.pfn_destroy( &p_port_cm->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__init_data_svc failed with status %s.\n",\r
ib_get_err_str(status)) );\r
return status;\r
{\r
ib_api_status_t status = IB_SUCCESS;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
switch( p_pnp_rec->pnp_event )\r
{\r
break; /* Ignore other PNP events. */\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
al_conn_t *p_conn;\r
cm_async_timer_t *p_async_timer;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_async_timer = PARENT_STRUCT( p_item, cm_async_timer_t, item );\r
p_conn = p_async_timer->p_conn;\r
__deref_conn( p_conn );\r
cl_free( p_async_timer );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
{\r
cm_async_timer_t *p_async_timer;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_async_timer = (cm_async_timer_t*)cl_zalloc( sizeof(cm_async_timer_t) );\r
if( !p_async_timer )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("failed to cl_zalloc cm_async_timer_t (%d bytes). System unstable!\n",\r
sizeof(cm_async_timer_t)) );\r
/* Bah - just release the connection now. */\r
p_async_timer->item.pfn_callback = __process_cm_timer;\r
cl_async_proc_queue( gp_async_proc_mgr, &p_async_timer->item );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
cl_status = cm_res_init( p_conn );\r
if( cl_status != CL_SUCCESS )\r
{\r
- /*CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ /*AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cm_res_init failed with status %s.\n",\r
CL_STATUS_MSG( cl_status )) );*/\r
return CL_ERROR;\r
cl_status = cl_timer_init( &p_conn->timer, __conn_timer_cb, p_conn );\r
if( cl_status != CL_SUCCESS )\r
{\r
- /*CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ /*AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_timer_init failed with status %s.\n",\r
CL_STATUS_MSG( cl_status )) );*/\r
cm_res_destroy( p_conn );\r
cl_status_t cl_status;\r
ib_pnp_req_t pnp_req;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( gp_cm == NULL );\r
\r
gp_cm = (al_cm_agent_t*)cl_zalloc( sizeof(al_cm_agent_t) );\r
if( !gp_cm )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Failed allocation of global CM agent.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( status != IB_SUCCESS )\r
{\r
__free_cm( &gp_cm->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_al_obj failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_cm->obj.pfn_destroy( &gp_cm->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( cl_status != CL_SUCCESS )\r
{\r
gp_cm->obj.pfn_destroy( &gp_cm->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_qpool_init failed with status %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
return ib_convert_cl_status( cl_status );\r
if( cl_status != CL_SUCCESS )\r
{\r
gp_cm->obj.pfn_destroy( &gp_cm->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_pool_init failed with status %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
return ib_convert_cl_status( cl_status );\r
if( status != IB_SUCCESS )\r
{\r
gp_cm->obj.pfn_destroy( &gp_cm->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_reg_pnp failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
* deref the object.\r
*/\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
ib_port_attr_t *p_port_attr;\r
uint16_t gid_idx;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_spinlock_acquire( &gp_cm->obj.lock );\r
for( p_item = cl_qlist_head( &gp_cm->obj.obj_list );\r
if( pp_port_cm )\r
*pp_port_cm = p_port_cm;\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
}\r
cl_spinlock_release( &gp_cm->obj.lock );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("No match found.\n") );\r
return status;\r
}\r
#include "al_cm_conn.h"\r
#include "al_cm_sidr.h"\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_cm_cep.tmh"\r
+#endif\r
#include "ib_common.h"\r
#include "al_mgr.h"\r
#include "al_ca.h"\r
status = ib_get_mad( p_port_cep->pool_key, MAD_BLOCK_SIZE, &p_rej_mad );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_get_mad returned %s\n", ib_get_err_str( status )) );\r
return;\r
}\r
*/\r
if( p_rej->reason == IB_REJ_INVALID_SID )\r
{\r
- AL_TRACE( AL_DBG_CM,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("Request rejected (invalid SID) - retrying.\n") );\r
goto err1;\r
}\r
\r
default:\r
/* Ignore the REJ. */\r
- AL_TRACE( AL_DBG_CM, ("REJ received in invalid state.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("REJ received in invalid state.\n") );\r
err1:\r
ib_put_mad( p_mad );\r
AL_EXIT( AL_DBG_CM );\r
\r
p_req = (mad_cm_req_t*)p_mad->p_mad_buf;\r
\r
- AL_TRACE( AL_DBG_CM,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("REQ: comm_id (x%x) qpn (x%x) received\n",\r
p_req->local_comm_id, conn_req_get_lcl_qpn( p_req )) );\r
\r
if( conn_req_get_qp_type( p_req ) > IB_QPT_UNRELIABLE_CONN )\r
{\r
/* Reserved value. Reject. */\r
- AL_TRACE( AL_DBG_ERROR, ("Invalid transport type received.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid transport type received.\n") );\r
reason = IB_REJ_INVALID_XPORT;\r
goto reject;\r
}\r
case CEP_STATE_TIMEWAIT:\r
case CEP_STATE_DESTROY:\r
/* Send a reject. */\r
- AL_TRACE( AL_DBG_CM,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("REQ received for connection in TIME_WAIT state.\n") );\r
__reject_req( p_port_cep, p_mad, IB_REJ_STALE_CONN );\r
break;\r
* dropped, then the remote CM will eventually process it, and\r
* we'd just be adding traffic.\r
*/\r
- AL_TRACE( AL_DBG_CM, ("Duplicate REQ received.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("Duplicate REQ received.\n") );\r
ib_put_mad( p_mad );\r
}\r
KeReleaseInStackQueuedSpinLockFromDpcLevel( &hdl );\r
{\r
/* Reject the request for insufficient resources. */\r
reason = IB_REJ_INSUF_RESOURCES;\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_create_cep failed\nREJ sent for insufficient resources.\n") );\r
goto reject;\r
}\r
}\r
else\r
{\r
- AL_TRACE( AL_DBG_CM, ("No listens active!\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("No listens active!\n") );\r
\r
/* Match against peer-to-peer requests using SID and compare data. */\r
//p_cep = __lookup_peer();\r
// p_conn = PARENT_STRUCT( p_list_item, kcep_t, map_item );\r
// __peer_req( p_port_cep, p_conn, p_async_mad->p_mad );\r
// cl_free( p_async_mad );\r
- // CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ // AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
// ("REQ matched a peer-to-peer request.\n") );\r
// return;\r
// }\r
{\r
/* No match found. Reject. */\r
reason = IB_REJ_INVALID_SID;\r
- AL_TRACE( AL_DBG_CM, ("REQ received but no match found.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("REQ received but no match found.\n") );\r
goto cleanup;\r
}\r
}\r
p_cep = __lookup_cep( NULL, p_mra->remote_comm_id );\r
if( !p_cep )\r
{\r
- AL_TRACE( AL_DBG_CM,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("MRA received that could not be matched.\n") );\r
goto err;\r
}\r
{\r
if( p_cep->remote_comm_id != p_mra->local_comm_id )\r
{\r
- AL_TRACE( AL_DBG_CM,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("MRA received that could not be matched.\n") );\r
goto err;\r
}\r
(p_cep->state & CEP_MSG_MASK)) )\r
{\r
/* Invalid state. */\r
- AL_TRACE( AL_DBG_CM, ("MRA received in invalid state.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("MRA received in invalid state.\n") );\r
goto err;\r
}\r
\r
if( p_cep->state & CEP_STATE_MRA )\r
{\r
/* Invalid state. */\r
- AL_TRACE( AL_DBG_CM, ("Already received MRA.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("Already received MRA.\n") );\r
goto err;\r
}\r
\r
\r
p_rep = (mad_cm_rep_t*)p_mad->p_mad_buf;\r
\r
- AL_TRACE( AL_DBG_CM,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("REP: comm_id (x%x) received\n", p_rep->local_comm_id ) );\r
\r
KeAcquireInStackQueuedSpinLockAtDpcLevel( &gp_cep_mgr->lock, &hdl );\r
{\r
KeReleaseInStackQueuedSpinLockFromDpcLevel( &hdl );\r
ib_put_mad( p_mad );\r
- AL_TRACE_EXIT( AL_DBG_CM,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("REP received that could not be matched.\n") );\r
return;\r
}\r
\r
default:\r
ib_put_mad( p_mad );\r
- AL_TRACE( AL_DBG_CM, ("REP received in invalid state.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("REP received in invalid state.\n") );\r
break;\r
}\r
\r
\r
p_rtu = (mad_cm_rtu_t*)p_mad->p_mad_buf;\r
\r
- AL_TRACE( AL_DBG_CM,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("RTU: comm_id (x%x) received\n", p_rtu->local_comm_id) );\r
\r
/* Find the connection by local connection ID. */\r
p_cep = __lookup_cep( NULL, p_rtu->remote_comm_id );\r
if( !p_cep || p_cep->remote_comm_id != p_rtu->local_comm_id )\r
{\r
- AL_TRACE( AL_DBG_CM, ("RTU received that could not be matched.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("RTU received that could not be matched.\n") );\r
goto done;\r
}\r
\r
return;\r
\r
default:\r
- AL_TRACE( AL_DBG_CM, ("RTU received in invalid state.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("RTU received in invalid state.\n") );\r
break;\r
}\r
\r
\r
p_dreq = (mad_cm_dreq_t*)p_mad->p_mad_buf;\r
\r
- AL_TRACE( AL_DBG_CM,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("DREQ: comm_id (x%x) qpn (x%x) received\n",\r
p_dreq->local_comm_id, conn_dreq_get_remote_qpn( p_dreq )) );\r
\r
p_cep->remote_comm_id != p_dreq->local_comm_id ||\r
p_cep->local_qpn != conn_dreq_get_remote_qpn( p_dreq ) )\r
{\r
- AL_TRACE( AL_DBG_CM, ("DREQ received that could not be matched.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("DREQ received that could not be matched.\n") );\r
KeReleaseInStackQueuedSpinLockFromDpcLevel( &hdl );\r
ib_put_mad( p_mad );\r
AL_EXIT( AL_DBG_CM );\r
break;\r
\r
default:\r
- AL_TRACE( AL_DBG_CM, ("DREQ received in invalid state.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("DREQ received in invalid state.\n") );\r
case CEP_STATE_DREQ_RCVD:\r
ib_put_mad( p_mad );\r
break;\r
p_cep = __lookup_cep( NULL, p_drep->remote_comm_id );\r
if( !p_cep || p_cep->remote_comm_id != p_drep->local_comm_id )\r
{\r
- AL_TRACE( AL_DBG_CM, ("DREP received that could not be matched.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("DREP received that could not be matched.\n") );\r
KeReleaseInStackQueuedSpinLockFromDpcLevel( &hdl );\r
ib_put_mad( p_mad );\r
AL_EXIT( AL_DBG_CM );\r
if( p_cep->state != CEP_STATE_DREQ_SENT &&\r
p_cep->state != CEP_STATE_DREQ_DESTROY )\r
{\r
- AL_TRACE( AL_DBG_CM, ("DREP received in invalid state.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("DREP received in invalid state.\n") );\r
\r
KeReleaseInStackQueuedSpinLockFromDpcLevel( &hdl );\r
ib_put_mad( p_mad );\r
{\r
KeReleaseInStackQueuedSpinLockFromDpcLevel( &hdl );\r
ib_put_mad( p_mad );\r
- AL_TRACE_EXIT( AL_DBG_CM, ("LAP received that could not be matched.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("LAP received that could not be matched.\n") );\r
return;\r
}\r
\r
break;\r
\r
default:\r
- AL_TRACE( AL_DBG_CM, ("LAP received in invalid state.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("LAP received in invalid state.\n") );\r
ib_put_mad( p_mad );\r
break;\r
}\r
p_cep = __lookup_cep( NULL, p_apr->remote_comm_id );\r
if( !p_cep || p_cep->remote_comm_id != p_apr->local_comm_id )\r
{\r
- AL_TRACE( AL_DBG_CM, ("APR received that could not be matched.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("APR received that could not be matched.\n") );\r
goto done;\r
}\r
\r
return;\r
\r
default:\r
- AL_TRACE( AL_DBG_CM, ("APR received in invalid state.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("APR received in invalid state.\n") );\r
break;\r
}\r
\r
//\r
default:\r
ib_put_mad( p_mad );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid CM MAD attribute ID.\n") );\r
return;\r
}\r
if( status != IB_SUCCESS )\r
{\r
ib_put_mad( p_mad );\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_send_mad failed with status %s.\n", ib_get_err_str(status)) );\r
}\r
\r
cl_atomic_dec( &p_cep->ref_cnt );\r
p_cep->p_send_mad = NULL;\r
ib_put_mad( p_mad );\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_send_mad failed with status %s.\n", ib_get_err_str(status)) );\r
}\r
\r
&p_port_cep->h_pd );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_alloc_pd failed with status %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
&p_port_cep->h_qp );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_get_spl_qp failed with status %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
ib_reg_mad_svc( p_port_cep->h_qp, &mad_svc, &p_port_cep->h_mad_svc );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_reg_mad_svc failed with status %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
p_port_cep = (cep_agent_t*)cl_zalloc( sizeof(cep_agent_t) );\r
if( !p_port_cep )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Failed to cl_zalloc port CM agent.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( status != IB_SUCCESS )\r
{\r
__free_port_cep( &p_port_cep->obj );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_al_obj failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_port_cep->obj.pfn_destroy( &p_port_cep->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( !p_port_cep->h_ca )\r
{\r
p_port_cep->obj.pfn_destroy( &p_port_cep->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("acquire_ca failed.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("acquire_ca failed.\n") );\r
return IB_INVALID_GUID; }\r
\r
status = __init_data_svc( p_port_cep, p_pnp_rec->p_port_attr );\r
if( status != IB_SUCCESS )\r
{\r
p_port_cep->obj.pfn_destroy( &p_port_cep->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__init_data_svc failed with status %s.\n",\r
ib_get_err_str(status)) );\r
return status;\r
else\r
p_item = cl_rbmap_right( p_item );\r
\r
- AL_TRACE( AL_DBG_CM,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("Svc ID match but compare buffer mismatch.\n") );\r
continue;\r
}\r
p_item = cl_rbmap_right( p_item ), left = FALSE;\r
else\r
{\r
- AL_TRACE( AL_DBG_CM | AL_DBG_WARN,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("WARNING: Duplicate remote CID and CA GUID.\n") );\r
goto done;\r
}\r
p_item = cl_rbmap_right( p_item ), left = FALSE;\r
else\r
{\r
- AL_TRACE( AL_DBG_CM | AL_DBG_WARN,\r
- ("WARNING: Duplicate remote QPN and CA GUID.\n") );\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
+ ("WARNING: Duplicate remote QPN and CA GUID.\n") );\r
goto done;\r
}\r
}\r
gp_cep_mgr->h_pnp, (ib_pfn_destroy_cb_t)deref_al_obj );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_dereg_pnp failed with status %s.\n",\r
ib_get_err_str(status)) );\r
deref_al_obj( &gp_cep_mgr->obj );\r
gp_cep_mgr = (al_cep_mgr_t*)cl_zalloc( sizeof(al_cep_mgr_t) );\r
if( !gp_cep_mgr )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Failed allocation of global CM agent.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( status != IB_SUCCESS )\r
{\r
__free_cep_mgr( &gp_cep_mgr->obj );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_al_obj failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_cep_mgr->obj.pfn_destroy( &gp_cep_mgr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( cl_status != CL_SUCCESS )\r
{\r
gp_cep_mgr->obj.pfn_destroy( &gp_cep_mgr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_vector_init failed with status %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
return ib_convert_cl_status( cl_status );\r
if( status != IB_SUCCESS )\r
{\r
gp_cep_mgr->obj.pfn_destroy( &gp_cep_mgr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_reg_pnp failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
p_cep = ExAllocateFromNPagedLookasideList( &gp_cep_mgr->cep_pool );\r
if( !p_cep )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Failed to allocate CEP.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Failed to allocate CEP.\n") );\r
return NULL;\r
}\r
\r
if( !p_cep->p_cid )\r
{\r
ExFreeToNPagedLookasideList( &gp_cep_mgr->cep_pool, p_cep );\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Failed to get CID.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Failed to get CID.\n") );\r
return NULL;\r
}\r
\r
p_port_cep = __get_cep_agent( p_cep );\r
if( !p_port_cep )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("__get_cep_agent failed.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("__get_cep_agent failed.\n") );\r
return IB_INSUFFICIENT_RESOURCES;\r
}\r
\r
status = ib_get_mad( p_port_cep->pool_key, MAD_BLOCK_SIZE, pp_mad );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_get_mad returned %s.\n", ib_get_err_str( status )) );\r
return status;\r
}\r
break;\r
\r
default:\r
- AL_TRACE( AL_DBG_ERROR, ("CEP in state %d.\n", p_cep->state) );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("CEP in state %d.\n", p_cep->state) );\r
case CEP_STATE_TIMEWAIT:\r
/* Already in timewait - so all is good. */\r
p_cep->state = CEP_STATE_DESTROY;\r
if( !p_cep )\r
{\r
KeReleaseInStackQueuedSpinLock( &hdl );\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Failed to allocate CEP.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Failed to allocate CEP.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
KeReleaseInStackQueuedSpinLock( &hdl );\r
else\r
break;\r
\r
- AL_TRACE( AL_DBG_CM,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("Svc ID match but compare buffer mismatch.\n") );\r
continue;\r
}\r
p_cep->p_cmp_buf = cl_malloc( p_listen_info->cmp_len );\r
if( !p_cep->p_cmp_buf )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Failed to allocate compare buffer.\n") );\r
status = IB_INSUFFICIENT_MEMORY;\r
goto done;\r
\r
if( !p_cm_req->p_primary_path )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Invalid primary path record.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid primary path record.\n") );\r
return IB_INVALID_SETTING;\r
}\r
\r
p_port_cep = __format_path_av( p_cm_req->p_primary_path, &p_cep->av[0] );\r
if( !p_port_cep )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Primary path unrealizable.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Primary path unrealizable.\n") );\r
return IB_INVALID_SETTING;\r
}\r
\r
if( p_port_cep->h_ca->obj.p_ci_ca->verbs.guid !=\r
p_cm_req->h_qp->obj.p_ci_ca->verbs.guid )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Primary path not realizable on given QP.\n") );\r
return IB_INVALID_SETTING;\r
}\r
if( ib_path_rec_mtu( p_cm_req->p_primary_path ) !=\r
ib_path_rec_mtu( p_cm_req->p_alt_path ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Mismatched primary and alternate path MTUs.\n") );\r
return IB_INVALID_SETTING;\r
}\r
/* The PKEY must match too. */\r
if( p_cm_req->p_alt_path->pkey != p_cm_req->p_primary_path->pkey )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Mismatched pimary and alternate PKEYs.\n") );\r
return IB_INVALID_SETTING;\r
}\r
p_port_cep->h_ca->obj.p_ci_ca->verbs.guid != p_cep->local_ca_guid )\r
{\r
/* Alternate path is not on same CA. */\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Alternate path unrealizable.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Alternate path unrealizable.\n") );\r
return IB_INVALID_SETTING;\r
}\r
\r
status = __format_req( p_cep, p_cm_req );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Invalid pdata length.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid pdata length.\n") );\r
ib_put_mad( p_cep->p_mad );\r
p_cep->p_mad = NULL;\r
break;\r
p_cm_lap->p_lap_pdata, p_cm_lap->lap_length, p_lap );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("lap pdata invalid.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("lap pdata invalid.\n") );\r
return status;\r
}\r
\r
if( !p_cep->was_active )\r
{\r
/* Only the side that took the active role can initialte a LAP. */\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Only the active side of a connection can initiate a LAP.\n") );\r
status = IB_INVALID_STATE;\r
break;\r
p_port_cep = __format_path_av( p_cm_lap->p_alt_path, &p_cep->alt_av );\r
if( !p_port_cep )\r
{\r
- AL_TRACE( AL_DBG_ERROR, ("Alternate path invalid!\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Alternate path invalid!\n") );\r
status = IB_INVALID_SETTING;\r
break;\r
}\r
\r
if( p_port_cep->h_ca->obj.p_ci_ca->verbs.guid != p_cep->local_ca_guid )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Alternate CA GUID different from current!\n") );\r
status = IB_INVALID_SETTING;\r
break;\r
p_cm_apr->info_length, p_apr );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("apr_info invalid\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("apr_info invalid\n") );\r
return status;\r
}\r
\r
p_cm_apr->apr_length, p_apr );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("apr pdata invalid\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("apr pdata invalid\n") );\r
return status;\r
}\r
\r
status = __format_dreq( p_cep, p_pdata, pdata_len, p_mad );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__format_dreq returned %s.\n", ib_get_err_str( status )) );\r
break;\r
}\r
break;\r
}\r
\r
- AL_TRACE( AL_DBG_ERROR, ("No alternate path avaialble.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("No alternate path avaialble.\n") );\r
\r
/* Fall through. */\r
default:\r
mad_cm_req_t *p_req;\r
al_conn_t *p_conn;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_list_item );\r
CL_ASSERT( context );\r
\r
if( p_req->local_comm_id != p_conn->remote_comm_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Remote comm ID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
if( p_req->local_ca_guid != p_conn->remote_ca_guid )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Remote CA GUID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
/* Reference the connection since we're working on it... */\r
__ref_conn( p_conn );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
al_conn_t *p_conn;\r
conn_req_t *p_info;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_list_item );\r
CL_ASSERT( context );\r
if( p_conn->remote_ca_guid != p_req->local_ca_guid ||\r
conn_req_get_lcl_qpn( p_req ) != p_conn->remote_qpn )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_NOT_FOUND;\r
}\r
\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("REQ received for stale connection.\n") );\r
return CL_SUCCESS;\r
}\r
mad_cm_req_t *p_req;\r
al_listen_t *p_listen;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_list_item );\r
CL_ASSERT( context );\r
\r
if( p_req->sid != p_listen->info.svc_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl, ("Svc ID mismatch.\n") );\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM, ("Svc ID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
if( cl_memcmp( &p_req->pdata[p_listen->info.compare_offset],\r
p_listen->info.p_compare_buffer, p_listen->info.compare_length ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Svc ID match but compare buffer mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
/* Reference the listen so that it doesn't go away. */\r
ref_al_obj( &p_listen->obj );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
mad_cm_req_t *p_req;\r
al_conn_t *p_conn;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_list_item );\r
CL_ASSERT( context );\r
/* Only match against peer-to-peer requests, not client requests. */\r
if( !p_conn->p_req_info->pfn_cm_req_cb )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl, ("Client request.\n") );\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM, ("Client request.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
/* Validate the transport type against the connection's QP type. */\r
if( conn_req_get_qp_type( p_req ) != p_conn->h_qp->type )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Transport type mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
/* Compare SID and compare data. */\r
if( p_req->sid != p_conn->p_req_info->svc_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl, ("Svc ID mismatch.\n") );\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM, ("Svc ID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
if( p_conn->state != CM_CONN_REQ_SENT )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Peer connection already matched.\n") );\r
return CL_NOT_FOUND;\r
}\r
/* Trying to connect to the same CA as the request. */\r
if( p_conn->local_comm_id == p_req->local_comm_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Same peer request.\n") );\r
return CL_NOT_FOUND;\r
}\r
/* do a local lid and gid match */\r
if( p_conn->path->slid != p_req->primary_path.remote_lid )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("slid mismatch. May be a different req in list\n") );\r
return CL_NOT_FOUND;\r
}\r
if( cl_memcmp( &p_conn->path->sgid, &p_req->primary_path.remote_gid,\r
sizeof(ib_gid_t) ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("sgid mismatch. May be a different req in list\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
if( p_conn->path->dlid != p_req->primary_path.local_lid )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("dlid mismatch. May be a different req in list\n") );\r
return CL_NOT_FOUND;\r
}\r
if( cl_memcmp( &p_conn->path->dgid, &p_req->primary_path.local_gid,\r
sizeof(ib_gid_t) ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("dgid mismatch. May be a different req in list\n") );\r
return CL_NOT_FOUND;\r
}\r
p_conn->p_req_info->p_compare_buffer,\r
p_conn->p_req_info->compare_length ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Svc ID match but compare buffer mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
/* Reference the connection object so it doesn't go away. */\r
__ref_conn( p_conn );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
al_conn_t *p_conn;\r
al_listen_t *p_listen;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_list_item );\r
CL_ASSERT( context );\r
\r
if( p_conn->p_req_info->svc_id != p_listen->info.svc_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl, ("Svc ID mismatch.\n") );\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM, ("Svc ID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
{\r
if( !p_conn->p_req_info->p_compare_buffer )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Svc ID match but compare buffer mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
( p_conn->p_req_info->compare_offset !=\r
p_listen->info.compare_offset ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Svc ID match but compare buffer mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
if( cl_memcmp( p_conn->p_req_info->p_compare_buffer,\r
p_listen->info.p_compare_buffer, p_listen->info.compare_length ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Svc ID match but compare buffer mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
/* Reference the listen so that it doesn't go away. */\r
ref_al_obj( &p_listen->obj );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
IN req_path_info_t *p_path,\r
OUT ib_path_rec_t *p_path_rec )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_req );\r
CL_ASSERT( p_path );\r
p_path_rec->tclass = p_path->traffic_class;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
ib_rej_status_t\r
{\r
ib_port_attr_t *p_port_attr;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_port_attr = &p_port_cm->p_ca_attr->p_port_attr[p_port_cm->port_idx];\r
\r
if( ( p_listen->info.ca_guid != IB_ALL_CAS ) &&\r
( p_listen->info.ca_guid != p_port_cm->p_ca_attr->ca_guid ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("CaGuid mismatch on listen.\n") );\r
return IB_REJ_INVALID_SID;\r
}\r
( ( p_listen->info.lid != p_path_rec->slid ) ||\r
( p_listen->info.lid != p_port_attr->lid ) ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("lid mismatch on listen.\n") );\r
return IB_REJ_INVALID_LID;\r
}\r
if( ( p_listen->info.port_guid != IB_ALL_PORTS ) &&\r
( p_listen->info.port_guid != p_port_attr->port_guid ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("PortGuid mismatch on listen.\n") );\r
return IB_REJ_INVALID_SID;\r
}\r
if( ( p_listen->info.pkey != IB_ALL_PKEYS ) &&\r
( p_listen->info.pkey != p_path_rec->pkey ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("pkey mismatch on listen.\n") );\r
return IB_REJ_INVALID_SID;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return 0;\r
}\r
\r
{\r
ib_rej_status_t rej_status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_port_cm );\r
CL_ASSERT( p_req );\r
switch( p_req->hdr.class_ver )\r
{\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid class version type received.\n") );\r
return IB_REJ_UNSUPPORTED;\r
\r
if( conn_req_get_qp_type( p_req ) > IB_QPT_UNRELIABLE_CONN )\r
{\r
/* Reserved value. Reject. */\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid transport type received.\n") );\r
return IB_REJ_INVALID_XPORT;\r
}\r
p_req_rec->h_cm_listen = ;\r
*/\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return 0;\r
}\r
\r
mad_cm_req_t *p_req;\r
mad_cm_rej_t *p_rej;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_port_cm );\r
CL_ASSERT( p_mad );\r
/* Assumption: The retry count, send options, etc are zeroed on a recv. */\r
__cm_send_mad( p_port_cm, p_mad );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
ib_api_status_t status;\r
cm_port_agent_t *p_port_cm;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_conn );\r
CL_ASSERT( pp_port_cm );\r
&p_port_cm, &p_conn->p_req_info->p_ca_attr );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__get_port_attr failed for primary path.\n") );\r
return status;\r
}\r
if( p_conn->p_req_info->p_ca_attr->ca_guid !=\r
p_conn->h_qp->obj.p_ci_ca->verbs.guid )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Primary path is not on the same CA as QP.\n") );\r
return IB_INVALID_SETTING;\r
}\r
p_conn->p_req_info->port_idx = p_port_cm->port_idx;\r
\r
*pp_port_cm = p_port_cm;\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
cm_port_agent_t *p_port_cm;\r
ib_ca_attr_t *p_ca_attr;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Get the alternate path port attributes. */\r
status = __get_port_attr( &p_conn->path[1].sgid, p_conn->path[1].slid,\r
&p_port_cm, &p_ca_attr );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__get_port_attr failed for alternate path.\n") );\r
return status;\r
}\r
if( p_ca_attr->ca_guid != p_conn->p_req_info->p_ca_attr->ca_guid )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Primary and alternate paths on different CAs.\n") );\r
return IB_INVALID_SETTING;\r
}\r
p_conn->p_req_info->alt_port_idx = p_port_cm->port_idx;\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
struct _qp_rtr *p_rtr;\r
struct _qp_rts *p_rts;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn->state = CM_CONN_REQ_RCVD;\r
p_conn->was_active = FALSE;\r
/* copy mad info for cm handoff */\r
p_conn->mads.req = *p_req;\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
void\r
ib_cm_req_rec_t req_rec;\r
ib_rej_status_t rej_status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_port_cm );\r
CL_ASSERT( p_listen );\r
{\r
/* The request is malformed. Reject it. */\r
__reject_req( p_port_cm, p_mad, rej_status );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("REJ sent for malformed REQ.\n") );\r
return;\r
}\r
{\r
/* Reject the request for insufficient resources. */\r
__reject_req( p_port_cm, p_mad, IB_REJ_INSUF_RESOURCES );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("REJ sent for insufficient resources.\n") );\r
return;\r
}\r
/* Return the REQ to the mad pool */\r
ib_put_mad( p_mad );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
ib_rej_status_t rej_status;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_port_cm );\r
CL_ASSERT( p_conn );\r
__repeated_mad( p_port_cm, p_conn, p_mad );\r
/* Release reference on p_conn obtained from __match_peer. */\r
__deref_conn( p_conn );\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Won peer compare, repeating REQ.\n") );\r
return;\r
}\r
__repeated_mad( p_port_cm, p_conn, p_mad );\r
/* Release reference on p_conn obtained from __match_peer. */\r
__deref_conn( p_conn );\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Won peer compare, repeating REQ.\n") );\r
return;\r
}\r
\r
/* The request is malformed. Reject it. */\r
__reject_req( p_port_cm, p_mad, rej_status );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("REJ sent for malformed REQ.\n") );\r
return;\r
}\r
cm_res_release( p_conn );\r
/* Release reference on p_conn obtained from __match_peer. */\r
__deref_conn( p_conn );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("REQ in invalid state.\n") );\r
return;\r
}\r
/* Return the REQ to the mad pool */\r
ib_put_mad( p_mad );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
ib_rej_status_t rej_status;\r
al_conn_t *p_conn_handoff;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_conn );\r
\r
cl_spinlock_release( &gp_cm->obj.lock );\r
__conn_reject( p_conn, IB_REJ_INVALID_SID, NULL, 0, NULL );\r
cm_res_release( p_conn );\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Handoff failed on svc_id!\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
/* The request does not conform to the handoff process service. */\r
__conn_reject( p_conn, rej_status, NULL, 0, NULL );\r
cm_res_release( p_conn );\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Handoff failed on svc_id info!\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
/* Reject the request for insufficient resources. */\r
__conn_reject( p_conn, IB_REJ_INSUF_RESOURCES, NULL, 0, NULL );\r
cm_res_release( p_conn );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Handoff failed on insufficient resources.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
/* deref the listen object */\r
deref_al_obj( &p_listen->obj );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
al_conn_t *p_conn;\r
al_listen_t *p_listen;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_async_mad = PARENT_STRUCT( p_item, cm_async_mad_t, item );\r
p_req = (mad_cm_req_t*)p_async_mad->p_mad->p_mad_buf;\r
p_port_cm = p_async_mad->p_port_cm;\r
\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl, ("REQ: comm_id (x%x) received\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("REQ: comm_id (x%x) received\n",\r
p_req->local_comm_id ) );\r
\r
/* Match against pending connections using remote comm ID and CA GUID. */\r
__repeated_mad( p_port_cm, p_conn, p_async_mad->p_mad );\r
__deref_conn( p_conn );\r
cl_free( p_async_mad );\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Duplicate REQ received.\n") );\r
return;\r
}\r
cl_spinlock_release( &gp_cm->obj.lock );\r
__reject_req( p_port_cm, p_async_mad->p_mad, IB_REJ_STALE_CONN );\r
cl_free( p_async_mad );\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("REQ received for connection in TIME_WAIT state.\n") );\r
return;\r
}\r
__listen_req( p_port_cm, p_listen, p_async_mad->p_mad );\r
deref_al_obj( &p_listen->obj );\r
cl_free( p_async_mad );\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("REQ matched a listen.\n") );\r
return;\r
}\r
\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl, ("No listens active!\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("No listens active!\n") );\r
\r
/* Match against peer-to-peer requests using SID and compare data. */\r
p_list_item = cl_qlist_find_from_head( &gp_cm->pending_list,\r
p_conn = PARENT_STRUCT( p_list_item, al_conn_t, map_item );\r
__peer_req( p_port_cm, p_conn, p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("REQ matched a peer-to-peer request.\n") );\r
return;\r
}\r
cl_spinlock_release( &gp_cm->obj.lock );\r
__reject_req( p_port_cm, p_async_mad->p_mad, IB_REJ_INVALID_SID );\r
cl_free( p_async_mad );\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("REQ received but no match found.\n") );\r
}\r
\r
al_conn_t *p_conn;\r
mad_cm_mra_t *p_mra;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn = PARENT_STRUCT( p_list_item, al_conn_t, map_item );\r
p_mra = (mad_cm_mra_t*)context;\r
\r
if( p_conn->local_comm_id != p_mra->remote_comm_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Local conn ID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
if( p_conn->remote_comm_id &&\r
p_conn->remote_comm_id == p_mra->local_comm_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Remote conn ID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
uint32_t timeout;\r
uint8_t pkt_life;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Cancel the send for the REQ, REP, or LAP. */\r
ib_cancel_mad( p_conn->h_mad_svc, p_conn->p_send_mad );\r
__deref_conn( p_conn );\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
{\r
ib_cm_mra_rec_t mra_rec;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_conn->h_qp );\r
\r
*/\r
p_conn->pfn_cm_mra_cb( &mra_rec );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
boolean_t do_callback = TRUE;\r
uint64_t key;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_async_mad = PARENT_STRUCT( p_item, cm_async_mad_t, item );\r
p_port_cm = p_async_mad->p_port_cm;\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("MRA received for LAP that could not be matched.\n") );\r
return;\r
}\r
if( p_map_item ==\r
(cl_map_item_t*)cl_qlist_end( &gp_cm->pending_list ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("MRA received that could not be matched.\n") );\r
\r
cl_spinlock_release( &gp_cm->obj.lock );\r
break;\r
\r
default:\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("MRA received in invalid state.\n") );\r
do_callback = FALSE;\r
break;\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
const ib_net64_t UNALIGNED *p_ca_guid;\r
uint8_t ari_len;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn = PARENT_STRUCT( p_list_item, al_conn_t, map_item );\r
p_rej = (mad_cm_rej_t*)context;\r
if( p_rej->remote_comm_id &&\r
p_conn->local_comm_id != p_rej->remote_comm_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Local comm ID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
if( p_conn->remote_comm_id &&\r
p_conn->remote_comm_id != p_rej->local_comm_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Remote comm ID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
if( ( p_conn->p_req_info->p_ca_attr ) &&\r
( p_conn->p_req_info->p_ca_attr->ca_guid != *p_ca_guid ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Local CA GUID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
/* We reached here with a comm id match which is good enough for me */\r
\r
__ref_conn( p_conn );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
al_conn_t *p_conn;\r
uint64_t key;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_async_mad = PARENT_STRUCT( p_item, cm_async_mad_t, item );\r
p_port_cm = p_async_mad->p_port_cm;\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("REJ received that could not be matched.\n") );\r
return;\r
}\r
__deref_conn( p_conn );\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Request rejected (invalid SID) - retrying.\n") );\r
return;\r
}\r
__deref_conn( p_conn );\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("REJ received in invalid state.\n") );\r
return;\r
}\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
cm_port_agent_t *p_port_cm;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
UNUSED_PARAM( p_rej_pdata );\r
\r
/*\r
&p_port_cm, NULL );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__get_port_attr returned %s\n", ib_get_err_str(status)) );\r
return;\r
}\r
__cm_send( p_port_cm, p_conn );\r
__conn_abort( p_conn );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
al_conn_t *p_conn;\r
mad_cm_rep_t *p_rep;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn = PARENT_STRUCT( p_list_item, al_conn_t, map_item );\r
p_rep = (mad_cm_rep_t*)context;\r
\r
- CL_PRINT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("p_conn:: local_comm_id (x%x) remote_comm_id (x%x)\n"\r
"p_rep:: local_comm_id (x%x) remote_comm_id (x%x)\n",\r
p_conn->local_comm_id,\r
\r
if( p_conn->local_comm_id != p_rep->remote_comm_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Local comm ID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
__ref_conn( p_conn );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
IN const al_conn_t* const p_conn,\r
OUT ib_cm_rep_rec_t* const p_rep_rec )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_memclr( p_rep_rec, sizeof(ib_cm_rep_rec_t) );\r
\r
p_rep_rec->flow_ctrl = conn_rep_get_e2e_flow_ctl( p_rep );\r
p_rep_rec->apr_status = conn_rep_get_failover( p_rep );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
void\r
struct _qp_rtr *p_rtr;\r
struct _qp_rts *p_rts;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* The send should have been cancelled during MRA processing. */\r
p_conn->state = CM_CONN_REP_RCVD;\r
p_rts->qkey = p_rep->local_qkey;\r
*/\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
void\r
ib_cm_rep_rec_t rep_rec;\r
uint64_t key;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_async_mad = PARENT_STRUCT( p_item, cm_async_mad_t, item );\r
p_rep = (mad_cm_rep_t*)p_async_mad->p_mad->p_mad_buf;\r
\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl, ("REP: comm_id (x%x) received\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("REP: comm_id (x%x) received\n",\r
p_rep->local_comm_id ) );\r
\r
/* Check the pending list by the local connection ID. */\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("REP received that could not be matched.\n") );\r
return;\r
}\r
break;\r
\r
default:\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("REP received in invalid state.\n") );\r
cm_res_release( p_conn );\r
ib_put_mad( p_async_mad->p_mad );\r
__deref_conn( p_conn );\r
cl_free( p_async_mad );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
al_conn_t *p_conn;\r
mad_cm_rtu_t *p_rtu;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn = PARENT_STRUCT( p_list_item, al_conn_t, map_item );\r
p_rtu = (mad_cm_rtu_t*)context;\r
\r
if( p_conn->local_comm_id != p_rtu->remote_comm_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Local comm ID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
if( p_conn->remote_comm_id != p_rtu->local_comm_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Remote comm ID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
__ref_conn( p_conn );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
IN const al_conn_t* const p_conn,\r
OUT ib_cm_rtu_rec_t* const p_rtu_rec )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_memclr( p_rtu_rec, sizeof(ib_cm_rtu_rec_t) );\r
\r
p_rtu_rec->h_qp = p_conn->h_qp;\r
p_rtu_rec->qp_context = p_conn->h_qp->obj.context;\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
void\r
ib_pfn_cm_rtu_cb_t pfn_rtu;\r
ib_cm_rtu_rec_t rtu_rec;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_async_mad = PARENT_STRUCT( p_item, cm_async_mad_t, item );\r
p_rtu = (mad_cm_rtu_t*)p_async_mad->p_mad->p_mad_buf;\r
\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl, ("RTU: comm_id (x%x) received\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("RTU: comm_id (x%x) received\n",\r
p_rtu->local_comm_id ) );\r
\r
/* Find the connection by local connection ID. */\r
cl_spinlock_release( &gp_cm->obj.lock );\r
if( p_list_item == cl_qlist_end( &gp_cm->pending_list ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("RTU received that could not be matched.\n") );\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
break;\r
\r
default:\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("RTU received in invalid state.\n") );\r
cm_res_release( p_conn );\r
break;\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
al_conn_t *p_conn;\r
mad_cm_dreq_t *p_dreq;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn = PARENT_STRUCT( p_list_item, al_conn_t, map_item );\r
p_dreq = (mad_cm_dreq_t*)context;\r
\r
if( p_conn->local_comm_id != p_dreq->remote_comm_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Local comm ID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
if( p_conn->remote_comm_id != p_dreq->local_comm_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Remote comm ID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
if( p_conn->local_qpn != conn_dreq_get_remote_qpn( p_dreq ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("local QPN mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
IN const al_conn_t* const p_conn,\r
OUT ib_cm_dreq_rec_t* const p_dreq_rec )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_memclr( p_dreq_rec, sizeof(ib_cm_dreq_rec_t) );\r
\r
p_dreq_rec->qp_type = p_conn->qp_type;\r
p_dreq_rec->qp_context = p_conn->h_qp->obj.context;\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
uint64_t key;\r
ib_cm_dreq_rec_t dreq_rec;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_async_mad = PARENT_STRUCT( p_item, cm_async_mad_t, item );\r
p_dreq = (mad_cm_dreq_t*)p_async_mad->p_mad->p_mad_buf;\r
(cl_map_item_t*)cl_qlist_end( &gp_cm->time_wait_list ) )\r
{\r
cl_spinlock_release( &gp_cm->obj.lock );\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("DREQ received that could not be matched.\n") );\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
__deref_conn( p_conn );\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return;\r
}\r
\r
break;\r
\r
default:\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("DREQ received in invalid state.\n") );\r
cm_res_release( p_conn );\r
ib_put_mad( p_async_mad->p_mad );\r
IN const al_conn_t* const p_conn,\r
OUT ib_cm_drep_rec_t* const p_drep_rec )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_memclr( p_drep_rec, sizeof(ib_cm_drep_rec_t) );\r
\r
p_drep_rec->h_qp = p_conn->h_qp;\r
p_drep_rec->qp_context = p_conn->h_qp->obj.context;\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
al_conn_t *p_conn;\r
ib_cm_drep_rec_t drep_rec;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_async_mad = PARENT_STRUCT( p_item, cm_async_mad_t, item );\r
p_drep = (mad_cm_drep_t*)p_async_mad->p_mad->p_mad_buf;\r
if( p_map_item == cl_qmap_end( &gp_cm->conn_map ) )\r
{\r
cl_spinlock_release( &gp_cm->obj.lock );\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("DREP received that could not be matched.\n") );\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
break;\r
\r
default:\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("DREP received in invalid state.\n") );\r
cm_res_release( p_conn );\r
}\r
\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
{\r
const lap_path_info_t* const p_path = &p_lap->alternate_path;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_lap );\r
CL_ASSERT( p_path_rec );\r
p_path_rec->tclass = conn_lap_path_get_tclass( p_path );\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
al_conn_t *p_conn;\r
ib_cm_lap_rec_t lap_rec;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_async_mad = PARENT_STRUCT( p_item, cm_async_mad_t, item );\r
p_port_cm = p_async_mad->p_port_cm;\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("LAP received that could not be matched.\n") );\r
return;\r
}\r
break;\r
\r
default:\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("LAP received in invalid state.\n") );\r
cm_res_release( p_conn );\r
break;\r
\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
ib_ca_attr_t *p_ca_attr;\r
ib_qp_mod_t qp_mod;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
status = __get_port_attr( &p_conn->new_alt_path.sgid,\r
p_conn->new_alt_path.slid, &p_port_cm, &p_ca_attr );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__get_port_attr returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
status = ib_modify_qp( p_conn->h_qp, &qp_mod );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("ib_modify_qp for LAP returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
\r
cl_memcpy( &p_conn->path[(p_conn->idx_primary + 1) & 0x1],\r
&p_conn->new_alt_path, sizeof(ib_path_rec_t) );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
uint64_t key;\r
ib_cm_apr_rec_t apr_rec;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_async_mad = PARENT_STRUCT( p_item, cm_async_mad_t, item );\r
p_port_cm = p_async_mad->p_port_cm;\r
if( p_map_item == cl_qmap_end( &gp_cm->conn_map ) )\r
{\r
cl_spinlock_release( &gp_cm->obj.lock );\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("APR received that could not be matched.\n") );\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
\r
default:\r
cm_res_release( p_conn );\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("APR received in invalid state.\n") );\r
break;\r
}\r
ib_cm_drep_rec_t drep_rec;\r
ib_cm_drep_t cm_drep;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn = PARENT_STRUCT( p_item, al_conn_t, timeout_item );\r
\r
\r
/* Release the reference taken when sending. */\r
__deref_conn( p_conn );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
IN const uint8_t ack_delay,\r
OUT req_path_info_t* const p_req_path )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_req_path->local_lid = p_path_rec->slid;\r
p_req_path->remote_lid = p_path_rec->dlid;\r
\r
conn_req_path_clr_rsvd_fields( p_req_path );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
if( p_cm_req->p_alt_path )\r
{\r
if( ib_path_rec_mtu( p_cm_req->p_primary_path ) !=\r
ib_path_rec_mtu( p_cm_req->p_alt_path ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Mismatched primary and alternate path MTUs.\n") );\r
return IB_INVALID_SETTING;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
- CL_EXIT( AL_DBG_ERROR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_ERROR );\r
return status;\r
}\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
- CL_EXIT( AL_DBG_ERROR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_ERROR );\r
return status;\r
}\r
\r
IN const ib_cm_rep_t* const p_cm_rep,\r
IN OUT al_conn_t* const p_conn )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn->mads.rep.hdr.attr_id = CM_REP_ATTR_ID;\r
p_conn->mads.rep.local_comm_id = p_conn->local_comm_id;\r
\r
conn_rep_clr_rsvd_fields( &p_conn->mads.rep );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
IN const ib_cm_rtu_t* const p_cm_rtu,\r
IN OUT al_conn_t* const p_conn )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn->mads.rtu.hdr.attr_id = CM_RTU_ATTR_ID;\r
\r
conn_rtu_set_pdata( p_cm_rtu->p_rtu_pdata, p_cm_rtu->rtu_length,\r
&p_conn->mads.rtu );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Cache the local QPN. */\r
p_conn->p_req_info->local_qpn = p_conn->h_qp->num;\r
status = __validate_primary_path( p_conn, pp_port_cm );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Primary path validation failed: %s.\n", ib_get_err_str(status)) );\r
\r
/* Reject and abort the connection. */\r
status = __validate_alt_path( p_conn );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Alternate path validation failed: %s.\n",\r
ib_get_err_str(status)) );\r
\r
\r
if( p_cm_rep->qp_type != p_conn->p_req_info->xport_type )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("qp_type mistach!\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("qp_type mistach!\n") );\r
return IB_REJ_INVALID_XPORT;\r
}\r
\r
set_al_obj_timeout( &p_cm_rep->h_qp->obj,\r
p_conn->retry_timeout * p_conn->max_cm_retries + 2000 );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return 0;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
status = __get_port_attr( &p_conn->path[0].sgid, p_conn->path[0].slid,\r
pp_port_cm, NULL );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__get_port_attr returned %s.\n", ib_get_err_str(status)) );\r
/*\r
* Don't fail the connection since the remote side will repeat\r
\r
cm_save_rtu_qp_attr( p_cm_rtu, &p_conn->p_req_info->qp_mod_rtr );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
IN const uint8_t ack_delay,\r
OUT lap_path_info_t* const p_lap_path )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_lap_path->local_lid = p_path_rec->slid;\r
p_lap_path->remote_lid = p_path_rec->dlid;\r
\r
conn_lap_path_clr_rsvd_fields( p_lap_path );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
cm_port_agent_t *p_port_cm;\r
ib_ca_attr_t *p_ca_attr, *p_alt_ca_attr;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_conn );\r
CL_ASSERT( pp_port_cm );\r
if( status != IB_SUCCESS )\r
{\r
/* Primary path invalid. Should have received a path migration. */\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Primary connection path invalid!\n") );\r
return IB_INVALID_SETTING;\r
}\r
if( status != IB_SUCCESS )\r
{\r
/* Alternate path invalid. */\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Alternate path invalid!\n") );\r
return status;\r
}\r
if( p_ca_attr->ca_guid != p_alt_ca_attr->ca_guid )\r
{\r
/* Paths are not on the same CA. */\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Primary and alternate paths must be on the same CA.\n") );\r
return IB_INVALID_SETTING;\r
}\r
\r
*p_ack_delay = p_ca_attr->local_ack_delay;\r
*pp_port_cm = p_port_cm;\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
IN const ib_cm_dreq_t* const p_cm_dreq,\r
OUT al_conn_t* const p_conn )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn->mads.dreq.hdr.attr_id = CM_DREQ_ATTR_ID;\r
p_conn->mads.dreq.local_comm_id = p_conn->local_comm_id;\r
&p_conn->mads.dreq );\r
conn_dreq_clr_rsvd_fields( &p_conn->mads.dreq );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
void\r
IN const ib_cm_drep_t* const p_cm_drep,\r
OUT al_conn_t* const p_conn )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn->mads.drep.hdr.attr_id = CM_DREP_ATTR_ID;\r
p_conn->mads.drep.local_comm_id = p_conn->local_comm_id;\r
conn_drep_set_pdata( p_cm_drep->p_drep_pdata, p_cm_drep->drep_length,\r
&p_conn->mads.drep );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
ib_api_status_t status;\r
cm_port_agent_t *p_port_cm;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
switch( p_conn->state )\r
{\r
\r
default:\r
/* Invalid state. Fail the request. */\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid state for sending MRA.\n") );\r
return IB_INVALID_STATE;\r
}\r
p_conn->path[p_conn->idx_primary].slid, &p_port_cm, NULL );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__get_port_attr for MRA returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
\r
status = __cm_send( p_port_cm, p_conn );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
__conn_abort(\r
IN al_conn_t* const p_conn )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
switch( p_conn->state )\r
{\r
/* Should never get here. */\r
break;\r
}\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
struct _qp_rts *p_rts;\r
uint8_t pkt_life;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Format the request info. */\r
p_conn->p_req_info->svc_id = p_cm_req->svc_id;\r
(uint8_t*)cl_malloc( p_cm_req->compare_length );\r
if( !p_conn->p_req_info->p_compare_buffer )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_malloc failed for compare buffer [%d bytes].\n",\r
p_cm_req->compare_length) );\r
return IB_INSUFFICIENT_MEMORY;\r
status = __validate_primary_path( p_conn, pp_port_cm );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Primary path validation failure: %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
status = __validate_alt_path( p_conn );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Alternate path validation failure: %s\n",\r
ib_get_err_str(status)) );\r
return status;\r
&p_rtr->alternate_av );\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Exported QPs have done this in user-mode already. */\r
if( AL_OBJ_IS_SUBTYPE( p_conn->h_qp, AL_OBJ_SUBTYPE_UM_EXPORT ) )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
(IB_AC_RDMA_READ | IB_AC_RDMA_WRITE | IB_AC_LOCAL_WRITE | IB_AC_MW_BIND) );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cm_init_qp returned %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Exported QPs have done this in user-mode already. */\r
if( AL_OBJ_IS_SUBTYPE( p_conn->h_qp, AL_OBJ_SUBTYPE_UM_EXPORT ) )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
p_conn->path[0].pkey, p_cm_rep->access_ctrl );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cm_init_qp returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
p_cm_rep->pp_recv_failure );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_post_recv returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
&p_conn->p_req_info->qp_mod_rts );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cm_rts_qp returned %s.\n", ib_get_err_str(status)) );\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Exported QPs have done this in user-mode already. */\r
if( AL_OBJ_IS_SUBTYPE( p_conn->h_qp, AL_OBJ_SUBTYPE_UM_EXPORT ) )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
&p_conn->p_req_info->qp_mod_rts );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cm_rts_qp returned %s.\n", ib_get_err_str(status)) );\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !p_cm_listen || !pfn_listen_err_cb || !ph_cm_listen )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( status == IB_SUCCESS )\r
deref_al_obj( &(*ph_cm_listen)->obj );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
ib_api_status_t status;\r
al_conn_t *p_conn;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
if( !h_cm )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !p_cm_rej )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
/* Release the reference taken for the callback. */\r
__deref_conn( p_conn );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
al_conn_t *p_conn;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
if( !h_cm )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !p_cm_mra )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
cm_res_release( p_conn );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__cm_send for MRA returned %s.\n", ib_get_err_str(status)) );\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
if( !p_cm_req )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( ( p_cm_req->p_req_pdata ) &&\r
( p_cm_req->req_length > IB_REQ_PDATA_SIZE ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid pdata length.\n") );\r
return IB_INVALID_SETTING;\r
}\r
/* Make sure there's a primary path. Both SIDR and CM require it. */\r
if( !p_cm_req->p_primary_path )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid primary path record.\n") );\r
return IB_INVALID_SETTING;\r
}\r
switch( p_cm_req->qp_type )\r
{\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid qp_type.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid qp_type.\n") );\r
return IB_INVALID_SETTING;\r
\r
case IB_QPT_RELIABLE_CONN:\r
if( AL_OBJ_INVALID_HANDLE( p_cm_req->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
(p_cm_req->h_qp->type != p_cm_req->qp_type) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
case IB_QPT_UNRELIABLE_DGRM:\r
if( AL_OBJ_INVALID_HANDLE( p_cm_req->h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
break;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
ib_al_handle_t h_al;\r
al_conn_t *p_conn;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
if( !h_cm_req )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !p_cm_rep )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( ( p_cm_rep->p_rep_pdata ) &&\r
( p_cm_rep->rep_length > IB_REP_PDATA_SIZE ) )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid pdata length.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid pdata length.\n") );\r
cm_res_release( p_conn );\r
__deref_conn( p_conn );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_INVALID_SETTING;\r
}\r
\r
if( p_conn->state != CM_CONN_REQ_RCVD &&\r
p_conn->state != CM_CONN_REQ_MRA_SENT )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Connection in invalid state (%d).\n", p_conn->state) );\r
/*\r
* The connection will get cleaned up by whatever put it in the\r
switch( p_cm_rep->qp_type )\r
{\r
default:\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid qp_type.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid qp_type.\n") );\r
status = IB_INVALID_SETTING;\r
break;\r
\r
if( AL_OBJ_INVALID_HANDLE( p_cm_rep->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
(p_cm_rep->h_qp->type != p_cm_rep->qp_type) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("IB_INVALID_QP_HANDLE\n") );\r
status = IB_INVALID_QP_HANDLE;\r
}\r
(AL_OBJ_INVALID_HANDLE( p_cm_rep->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
(p_cm_rep->h_qp->type != p_cm_rep->qp_type) ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("IB_INVALID_QP_HANDLE\n") );\r
status = IB_INVALID_QP_HANDLE;\r
}\r
cm_res_release( p_conn );\r
__deref_conn( p_conn );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
/* Release the reference taken for the callback. */\r
__deref_conn( p_conn );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
al_conn_t *p_conn;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
if( !h_cm_rep )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !p_cm_rtu )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( ( p_cm_rtu->p_rtu_pdata ) &&\r
( p_cm_rtu->rtu_length > IB_RTU_PDATA_SIZE ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid pdata length.\n") );\r
\r
cm_res_release( p_conn );\r
if( p_conn->state != CM_CONN_REP_RCVD &&\r
p_conn->state != CM_CONN_REP_MRA_SENT )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Connection in invalid state (%d) for RTU.\n", p_conn->state) );\r
\r
cm_res_release( p_conn );\r
*/\r
if( p_conn->p_sync_event )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Connection in invalid state. Sync call in progress.\n" ) );\r
\r
cm_res_release( p_conn );\r
/* Release the reference taken for the callback. */\r
__deref_conn( p_conn );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
al_conn_t *p_conn;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
if( !p_cm_dreq )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
switch( p_cm_dreq->qp_type )\r
{\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid qp_type.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid qp_type.\n") );\r
return IB_INVALID_SETTING;\r
\r
case IB_QPT_RELIABLE_CONN:\r
if( AL_OBJ_INVALID_HANDLE( p_cm_dreq->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
(p_cm_dreq->h_qp->type != p_cm_dreq->qp_type) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
\r
if( !((al_conn_qp_t*)p_cm_dreq->h_qp)->p_conn )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("No connection info!\n") );\r
\r
return IB_INVALID_SETTING;\r
*/\r
if( p_conn->state != CM_CONN_ESTABLISHED )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Invalid state (%d) for sending DREQ.\n", p_conn->state) );\r
\r
cm_res_release( p_conn );\r
if( ( p_cm_dreq->p_dreq_pdata ) &&\r
( p_cm_dreq->dreq_length > IB_DREQ_PDATA_SIZE ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid pdata length.\n") );\r
\r
cm_res_release( p_conn );\r
cm_res_release( p_conn );\r
__deref_conn( p_conn );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
al_conn_t *p_conn;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
if( !h_cm_dreq )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !p_cm_drep )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
cm_res_acquire( p_conn );\r
if( p_conn->state != CM_CONN_DREQ_RCVD )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Invalid state (%d) for DREP.\n", p_conn->state) );\r
\r
cm_res_release( p_conn );\r
/* Release the reference taken while processing. */\r
__deref_conn( p_conn );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
if( !p_cm_lap )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
switch( p_cm_lap->qp_type )\r
{\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid qp_type.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid qp_type.\n") );\r
return IB_INVALID_SETTING;\r
\r
case IB_QPT_RELIABLE_CONN:\r
if( AL_OBJ_INVALID_HANDLE( p_cm_lap->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
(p_cm_lap->h_qp->type != p_cm_lap->qp_type) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
/* Make sure a path was provided. */\r
if( !p_cm_lap->p_alt_path )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Path missing.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Path missing.\n") );\r
return IB_INVALID_SETTING;\r
}\r
\r
status = cm_conn_lap( p_cm_lap );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
if( !h_cm_lap )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !p_cm_apr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
switch( p_cm_apr->qp_type )\r
{\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid qp_type.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid qp_type.\n") );\r
return IB_INVALID_SETTING;\r
\r
case IB_QPT_RELIABLE_CONN:\r
if( AL_OBJ_INVALID_HANDLE( p_cm_apr->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
(p_cm_apr->h_qp->type != p_cm_apr->qp_type) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
\r
status = cm_conn_apr( h_cm_lap, p_cm_apr );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_qp, AL_OBJ_TYPE_H_QP ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
\r
status = cm_force_apm( h_qp );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
ib_api_status_t status;\r
al_conn_t *p_conn;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
if( !h_cm_req )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !svc_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("IB_INVALID_PARAMETER\n" ) );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( p_conn->state != CM_CONN_REQ_RCVD )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("State not valid for handoff\n" ) );\r
return IB_INVALID_STATE;\r
}\r
/* only the passive side or the server can handoff */\r
if( p_conn->was_active == TRUE )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("State not valid for handoff\n" ) );\r
return IB_INVALID_STATE;\r
}\r
\r
if( p_conn->qp_type != IB_QPT_RELIABLE_CONN )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid conn handle for handoff\n" ) );\r
return IB_INVALID_STATE;\r
}\r
/* Release the reference taken for the callback. */\r
__deref_conn( p_conn );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
\r
ib_api_status_t status;\r
al_conn_t *p_conn;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/*\r
* We need to serialize with the destruction of the connection object.\r
{\r
/* The connection object has already been unbound. */\r
cl_spinlock_release( &gp_cm->obj.lock );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return;\r
}\r
\r
}\r
\r
__deref_conn( p_conn );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
al_conn_t *p_conn;\r
ib_cm_rej_rec_t rej_rec;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn = PARENT_STRUCT( p_item, al_conn_t, timeout_item );\r
\r
default:\r
/* Something changed our state, so ignore the timeout. */\r
cm_res_release( p_conn );\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("Connection in invalid state for send timeout.\n") );\r
break;\r
}\r
/* Release the reference taken for the send. */\r
__deref_conn( p_conn );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
/*\r
{\r
al_conn_t *p_conn;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn = PARENT_STRUCT( p_item, al_conn_t, timeout_item );\r
\r
default:\r
cm_res_release( p_conn );\r
/* Something changed our state, so ignore the timeout. */\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("Connection in invalid state for send timeout.\n") );\r
break;\r
}\r
/* Release the reference taken for the send. */\r
__deref_conn( p_conn );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
{\r
ib_qp_handle_t h_qp;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/*\r
* See if we've already been unbound. Note that if we haven't, then we\r
deref_al_obj( &h_qp->obj );\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
uint32_t timewait = 0;\r
uint8_t pkt_life;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
switch( p_conn->state )\r
{\r
/* Set the timer. */\r
if( cl_timer_start( &p_conn->timer, timewait ) != CL_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Timer failed to start for comm_id( x%x )!\n",\r
p_conn->local_comm_id) );\r
/* Never mind the timer then, just release the connection now. */\r
break;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
ib_port_attr_t *p_port_attr;\r
uint16_t i_pkey;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* A full wildcard listen should have been trapped elsewhere. */\r
CL_ASSERT( !(p_info->ca_guid == IB_ALL_CAS &&\r
p_info->ca_guid != p_ca_attr->ca_guid )\r
{\r
/* CA GUID is not wildcard and does not match. */\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_INVALID_GUID;\r
}\r
/* CA GUID is either wildcard or matches. */\r
p_info->port_guid != p_port_attr->port_guid )\r
{\r
/* Port GUID is not wildcard and does not match. */\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_INVALID_GUID;\r
}\r
/* Port GUID is either wildcard or matches. */\r
* LID is not wildcard and does not match the LID range for\r
* the port.\r
*/\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_INVALID_LID;\r
}\r
/* LID is either wildcard or is within range. */\r
if( p_info->pkey == IB_ALL_PKEYS )\r
{\r
/* PKey is wildcard. */\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
if( p_info->pkey == p_port_attr->p_pkey_table[i_pkey] )\r
{\r
/* PKey is valid for the port. */\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
}\r
/* No PKey match. */\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_INVALID_PKEY;\r
}\r
\r
cm_port_agent_t *p_port_cm;\r
al_listen_t *p_listen;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_port_cm = PARENT_STRUCT(\r
PARENT_STRUCT( p_list_item, al_obj_t, pool_item ),\r
\r
p_listen->err_code = __is_listen_valid( p_port_cm, &p_listen->info );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
\r
return( p_listen->err_code == IB_SUCCESS ? CL_SUCCESS : CL_NOT_FOUND );\r
}\r
cl_list_item_t *p_port_item;\r
al_listen_t *p_listen;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
UNUSED_PARAM( context );\r
p_listen = PARENT_STRUCT( p_list_item, al_listen_t, list_item );\r
p_listen->info.lid == IB_ALL_LIDS &&\r
p_listen->info.pkey == IB_ALL_PKEYS )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_NOT_FOUND;\r
}\r
\r
__port_cm_validate_listen, p_listen );\r
if( p_port_item == cl_qlist_end( &gp_cm->obj.obj_list ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Invalid listen found.\n") );\r
/* Reference the listen and queue it for a callback. */\r
ref_al_obj( &p_listen->obj );\r
cl_async_proc_queue( gp_async_proc_mgr, &p_listen->async_item );\r
return CL_SUCCESS;\r
}\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
\r
return CL_NOT_FOUND;\r
}\r
void\r
__validate_listens( void )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Move all invalid listens to a temporary list. */\r
cl_spinlock_acquire( &gp_cm->obj.lock );\r
&gp_cm->inactive_listen_list, __is_listen_bad, NULL );\r
cl_spinlock_release( &gp_cm->obj.lock );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
al_listen_t *p_listen;\r
ib_listen_err_rec_t err_rec;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_listen = PARENT_STRUCT( p_item, al_listen_t, async_item );\r
\r
/* Release the reference to the listen to allow destruction to complete. */\r
deref_al_obj( &p_listen->obj );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
IN const ib_listen_handle_t h_cm_listen,\r
IN const ib_pfn_destroy_cb_t pfn_destroy_cb OPTIONAL )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_cm_listen, AL_OBJ_TYPE_H_LISTEN ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
\r
ref_al_obj( &h_cm_listen->obj );\r
h_cm_listen->obj.pfn_destroy( &h_cm_listen->obj, pfn_destroy_cb );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
cl_list_item_t *p_port_item;\r
al_listen_t listen;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/*\r
* Check validity of CA GUID, Port GUID, LID, and PKey if any\r
if( p_port_item == cl_qlist_end( &gp_cm->obj.obj_list ) )\r
{\r
/* No port could accomodate the listen. */\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Invalid listen request.\n") );\r
return listen.err_code;\r
}\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return __is_listen_unique( p_new_listen );\r
}\r
\r
al_listen_t *p_listen;\r
size_t alloc_size;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_spinlock_acquire( &gp_cm->obj.lock );\r
/* Validate the listen paramters to make sure they are unique. */\r
{\r
cl_spinlock_release( &gp_cm->obj.lock );\r
p_listen->obj.pfn_destroy( &p_listen->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
\r
*ph_cm_listen = p_listen;\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_api_status_t ib_status = IB_SUCCESS;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
switch( p_conn->state )\r
{\r
default:\r
break;\r
}\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return ib_status;\r
}\r
\r
cl_event_t sync_event;\r
cl_event_t *p_sync_event = NULL;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Get a connection object from the pool. */\r
p_conn = __get_conn( h_al, p_cm_req->qp_type );\r
if( !p_conn )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("__get_conn failed.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("__get_conn failed.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
if( ((al_conn_qp_t*)p_cm_req->h_qp)->p_conn )\r
{\r
cl_spinlock_release( &p_cm_req->h_qp->obj.lock );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("QP already connected.\n") );\r
return IB_INVALID_STATE;\r
}\r
if( status != IB_SUCCESS )\r
{\r
__deref_conn( p_conn );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__conn_save_user_req failed.\n") );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
__deref_conn( p_conn );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__format_mad_req failed.\n") );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
__deref_conn( p_conn );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__cm_pre_req returned %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( p_sync_event )\r
cl_event_destroy( p_sync_event );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__cm_send returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
/* wait on event if synchronous operation */\r
if( p_sync_event )\r
{\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("event blocked on REQ...\n") );\r
cl_event_wait_on( p_sync_event, EVENT_NO_TIMEOUT, FALSE );\r
\r
}\r
\r
/* We will set the retry timer upon completion. */\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
cm_port_agent_t *p_port_cm;\r
ib_rej_status_t rej_status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_spinlock_acquire( &p_cm_rep->h_qp->obj.lock );\r
if( ((al_conn_qp_t*)p_cm_rep->h_qp)->p_conn )\r
cl_spinlock_release( &p_cm_rep->h_qp->obj.lock );\r
__conn_reject( p_conn, IB_REJ_INSUF_QP, NULL, 0, NULL );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("QP already connected.\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
/* Reject and abort the connection. */\r
__conn_reject( p_conn, rej_status, NULL, 0, NULL );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__conn_save_user_rep failed.\n") );\r
return IB_INVALID_SETTING;\r
}\r
/* Reject and abort the connection. */\r
__conn_reject( p_conn, IB_REJ_INSUF_QP, NULL, 0, NULL );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__format_mad_rep failed.\n") );\r
return status;\r
}\r
/* Reject and abort the connection. */\r
__conn_reject( p_conn, IB_REJ_INSUF_QP, NULL, 0, NULL );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__cm_pre_req returned %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
/* Reject and abort the connection. */\r
__conn_reject( p_conn, IB_REJ_INSUF_QP, NULL, 0, NULL );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__cm_send returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
cm_port_agent_t *p_port_cm;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* save user info */\r
status = __conn_save_user_rtu( p_cm_rtu, p_conn, &p_port_cm );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__conn_save_user_rtu returned %s.\n", ib_get_err_str(status)) );\r
/*\r
* Don't fail the connection since the remote side will repeat\r
/* Reject and abort the connection. */\r
__conn_reject( p_conn, IB_REJ_INSUF_QP, NULL, 0, NULL );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cm_pre_rtu to RTS returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
/* No need to check the send status since the RTU is unreliable. */\r
__cm_send( p_port_cm, p_conn );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
uint8_t ack_delay;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn = ((al_conn_qp_t*)p_cm_lap->h_qp)->p_conn;\r
\r
if( !p_conn )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid connection info.\n") );\r
return IB_INVALID_STATE;\r
}\r
if( !p_conn->was_active )\r
{\r
/* Only the side that took the active role can initialte a LAP. */\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Only the active side of a connection can initiate a LAP.\n") );\r
\r
cm_res_release( p_conn );\r
if( p_conn->state != CM_CONN_ESTABLISHED )\r
{\r
/* Only allow sending LAP if in the established state. */\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid connection state (%d) for sending LAP.\n",\r
p_conn->state) );\r
\r
status = __validate_lap_path( p_conn, &p_port_cm, &ack_delay );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__validate_lap_path returned %s.\n", ib_get_err_str(status)) );\r
\r
cm_res_release( p_conn );\r
&p_conn->mads.lap.alternate_path );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__format_mad_lap_path returned %s.\n", ib_get_err_str(status)) );\r
\r
cm_res_release( p_conn );\r
&p_conn->mads.lap );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("lap pdata invalid.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("lap pdata invalid.\n") );\r
\r
cm_res_release( p_conn );\r
return status;\r
uint8_t ack_delay;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn = h_cm_lap;\r
\r
if( p_conn->was_active )\r
{\r
/* Only the side that took the active role can initiate a LAP. */\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Only the inactive side of a connection can initiate a APR.\n") );\r
\r
cm_res_release( p_conn );\r
if( p_conn->state != CM_CONN_LAP_RCVD )\r
{\r
/* Only allow sending LAP if in the established state. */\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid connection state (%d) for sending APR.\n",\r
p_conn->state) );\r
\r
status = __validate_lap_path( p_conn, &p_port_cm, &ack_delay );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__validate_lap_path returned %s.\n", ib_get_err_str(status)) );\r
\r
cm_res_release( p_conn );\r
status = __cm_lap_qp( p_conn );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("lap failed on qp with %s.\n", ib_get_err_str(status)) );\r
\r
cm_res_release( p_conn );\r
p_cm_apr->info_length, &p_conn->mads.apr );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("apr_info invalid\n") );\r
\r
cm_res_release( p_conn );\r
p_cm_apr->apr_length, &p_conn->mads.apr );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("apr pdata invalid\n") );\r
\r
cm_res_release( p_conn );\r
ib_api_status_t status;\r
cm_port_agent_t *p_port_cm;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn = ((al_conn_qp_t*)p_cm_dreq->h_qp)->p_conn;\r
\r
p_conn->path[p_conn->idx_primary].slid, &p_port_cm, NULL );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__get_port_attr for DREQ returned %s.\n",\r
ib_get_err_str(status)) );\r
return status;\r
status = __cm_send( p_port_cm, p_conn );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__cm_send for DREQ returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
/* Set the state. */\r
p_conn->state = CM_CONN_DREQ_SENT;\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
cm_port_agent_t *p_port_cm;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Format the DREP. */\r
__format_mad_drep( p_cm_drep, p_conn );\r
__cm_send( p_port_cm, p_conn );\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return status;\r
}\r
ib_api_status_t status;\r
cm_port_agent_t *p_port_cm;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_conn );\r
CL_ASSERT( p_conn->p_req_info );\r
&p_port_cm, &p_conn->p_req_info->p_ca_attr );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__get_port_attr failed for primary path.\n") );\r
return status;\r
}\r
p_conn->p_req_info->port_idx = p_port_cm->port_idx;\r
*pp_port_cm = p_port_cm;\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
IN const ib_cm_req_t* const p_cm_req,\r
IN OUT al_conn_t* const p_conn )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Format the rest of the REQ. */\r
p_conn->mads.sidr_req.hdr.attr_id = CM_SIDR_REQ_ATTR_ID;\r
IN OUT al_conn_t* const p_conn,\r
IN const mad_cm_sidr_req_t* const p_req )\r
{\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Store pertinent information in the connection. */\r
p_conn->remote_comm_id = p_req->req_id;\r
al_conn_t *p_conn;\r
cm_port_agent_t *p_port_cm;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_cm_req->pfn_cm_rep_cb );\r
\r
p_conn = __get_conn( h_al, p_cm_req->qp_type );\r
if( !p_conn )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("__get_conn failed.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("__get_conn failed.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
__deref_conn( p_conn );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Primary path validation failure: %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
__deref_conn( p_conn );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__format_sidr_mad_req failed.\n") );\r
return status;\r
}\r
{\r
cm_res_release( p_conn );\r
__deref_conn( p_conn );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__cm_send returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
cm_res_release( p_conn );\r
\r
/* We will set the retry timer upon completion. */\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
mad_cm_sidr_req_t *p_sidr_req;\r
al_listen_t *p_listen;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_list_item );\r
CL_ASSERT( context );\r
\r
if( p_sidr_req->hdr.class_ver != IB_MCLASS_CM_VER_2 )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Class ver mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
if( p_sidr_req->sid != p_listen->info.svc_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl, ("Svc ID mismatch.\n") );\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM, ("Svc ID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
p_sidr_req->pkey &&\r
( p_sidr_req->pkey != p_listen->info.pkey ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl, ("pkey mismatch.\n") );\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM, ("pkey mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
p_listen->info.p_compare_buffer,\r
p_listen->info.compare_length ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Svc ID match but compare buffer mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
/* Reference the listen so that it doesn't go away. */\r
ref_al_obj( &p_listen->obj );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
{\r
mad_cm_sidr_req_t *p_req;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_mad );\r
CL_ASSERT( p_req_rec );\r
\r
p_req_rec->qp_type = IB_QPT_UNRELIABLE_DGRM;\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
void\r
mad_cm_sidr_req_t *p_req;\r
mad_cm_sidr_rep_t *p_rep;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_port_cm );\r
CL_ASSERT( p_mad );\r
\r
__cm_send_mad( p_port_cm, p_mad );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
void\r
mad_cm_sidr_req_t *p_req;\r
ib_cm_req_rec_t req_rec;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
CL_ASSERT( p_port_cm );\r
CL_ASSERT( p_listen );\r
{\r
/* Reject the request for insufficient resources. */\r
__reject_sidr_req( p_port_cm, p_mad, IB_SIDR_REJECT );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("REJ sent for insufficient resources.\n") );\r
return;\r
}\r
/* Return the REQ to the mad pool */\r
ib_put_mad( p_mad );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
void\r
cl_list_item_t *p_list_item;\r
al_listen_t *p_listen;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_async_mad = PARENT_STRUCT( p_item, cm_async_mad_t, item );\r
p_req = (mad_cm_sidr_req_t*)p_async_mad->p_mad->p_mad_buf;\r
cl_spinlock_release( &gp_cm->obj.lock );\r
__reject_sidr_req( p_port_cm, p_async_mad->p_mad, IB_SIDR_UNSUPPORTED );\r
cl_free( p_async_mad );\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("REQ received but no match found.\n") );\r
return;\r
}\r
\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl, ("REQ matched a listen.\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM, ("REQ matched a listen.\n") );\r
\r
cl_spinlock_release( &gp_cm->obj.lock );\r
p_listen = PARENT_STRUCT( p_list_item, al_listen_t, list_item );\r
deref_al_obj( &p_listen->obj );\r
cl_free( p_async_mad );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
ib_api_status_t status;\r
ib_qp_attr_t qp_attr;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Initialize the QP. */\r
if( ( p_cm_rep->status == IB_SIDR_SUCCESS ) && !p_cm_rep->h_qp )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid h_qp\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid h_qp\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
\r
&p_conn->mads.sidr_rep );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid p_data\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid p_data\n") );\r
return status;\r
}\r
\r
status = ib_query_qp( p_cm_rep->h_qp, &qp_attr );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_query_qp failed with status %s\n",\r
ib_get_err_str(status)) );\r
return status;\r
*/\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__cm_send returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return IB_SUCCESS;\r
}\r
\r
al_conn_t *p_conn;\r
mad_cm_sidr_rep_t *p_rep;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_conn = PARENT_STRUCT( p_list_item, al_conn_t, map_item );\r
p_rep = (mad_cm_sidr_rep_t*)context;\r
\r
- CL_PRINT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("p_conn:: local_comm_id (x%x)\n"\r
"p_rep:: local_comm_id (x%x)\n",\r
p_conn->local_comm_id,\r
\r
if( p_conn->local_comm_id != p_rep->req_id )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Local comm ID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
if( p_conn->p_req_info->svc_id != p_rep->sid )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("Service ID mismatch.\n") );\r
return CL_NOT_FOUND;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
al_conn_t *p_conn;\r
ib_cm_rep_rec_t rep_rec;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
p_async_mad = PARENT_STRUCT( p_item, cm_async_mad_t, item );\r
p_rep = (mad_cm_sidr_rep_t*)p_async_mad->p_mad->p_mad_buf;\r
cl_spinlock_release( &gp_cm->obj.lock );\r
if( p_list_item == cl_qlist_end( &gp_cm->pending_list ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_WARNING, AL_DBG_CM,\r
("REP received that could not be matched.\n") );\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
break;\r
\r
default:\r
- CL_TRACE( AL_DBG_CM, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CM,\r
("REP received in invalid state.\n") );\r
cm_res_release( p_conn );\r
break;\r
\r
ib_put_mad( p_async_mad->p_mad );\r
cl_free( p_async_mad );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
#include "al_common.h"\r
#include "al_cq.h"\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_dev.tmh"\r
+#endif\r
#include "al_dev.h"\r
#include "al_qp.h"\r
#include "al_mgr.h"\r
IO_STACK_LOCATION *p_io_stack;\r
ULONG *p_ver;\r
\r
- CL_ENTER( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_DEV );\r
\r
p_io_stack = IoGetCurrentIrpStackLocation( h_ioctl );\r
\r
!p_ver ||\r
cl_ioctl_out_size( h_ioctl ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("context already exists or bad parameters.\n") );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( *p_ver != AL_IOCTL_VERSION )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Unsupported client version: %d\n", *p_ver) );\r
return CL_INVALID_PARAMETER;\r
}\r
cl_zalloc( sizeof(al_dev_open_context_t) );\r
if( !p_context )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_malloc( %d ) failed.\n", sizeof(al_dev_open_context_t)) );\r
return CL_INSUFFICIENT_MEMORY;\r
}\r
cl_status = CL_INSUFFICIENT_RESOURCES;\r
}\r
\r
- CL_EXIT( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_DEV );\r
return cl_status;\r
}\r
\r
al_handle_t *p_h;\r
size_t i;\r
\r
- CL_ENTER( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_DEV );\r
\r
cl_spinlock_acquire( &p_context->h_al->obj.lock );\r
for( i = 0; i < cl_vector_get_size( &p_context->h_al->hdl_vector ); i++ )\r
}\r
cl_spinlock_release( &p_context->h_al->obj.lock );\r
\r
- CL_EXIT( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_DEV );\r
}\r
\r
\r
al_dev_open_context_t *p_context;\r
IO_STACK_LOCATION *p_io_stack;\r
\r
- CL_ENTER( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_DEV );\r
\r
p_io_stack = IoGetCurrentIrpStackLocation( h_ioctl );\r
\r
p_context = (al_dev_open_context_t*)p_io_stack->FileObject->FsContext;\r
if( !p_context )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Client closed with a null open context .\n") );\r
return CL_SUCCESS;\r
}\r
ASSERT( cl_status == IB_SUCCESS );\r
if( cl_status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR, ("Waiting on ref_cnt timed out!\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Waiting on ref_cnt timed out!\n") );\r
break;\r
}\r
#else\r
__destroy_open_context( p_context );\r
cl_free( p_context );\r
\r
- CL_EXIT( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_DEV );\r
return CL_SUCCESS;\r
}\r
\r
void *p_open_context;\r
IO_STACK_LOCATION *p_io_stack;\r
\r
- CL_ENTER( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_DEV );\r
\r
p_io_stack = IoGetCurrentIrpStackLocation( h_ioctl );\r
p_open_context = p_io_stack->FileObject->FsContext;\r
\r
- CL_TRACE( AL_DBG_DEV, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_DEV,\r
("al_dev_ioctl: buf_size (%ld) p_buf (%p).\n",\r
cl_ioctl_in_size( h_ioctl ), cl_ioctl_in_buf( h_ioctl )) );\r
\r
cl_ioctl_complete( h_ioctl, cl_status, ret_bytes );\r
}\r
\r
- CL_EXIT( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_DEV );\r
return cl_status;\r
}\r
\r
ph_ioctl = &p_context->h_misc_ioctl;\r
break;\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid CB type\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid CB type\n") );\r
ph_ioctl = NULL;\r
break;\r
}\r
}\r
cl_spinlock_release( &p_context->cb_lock );\r
\r
- CL_EXIT( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_DEV );\r
}\r
\r
\r
#include "al_pnp.h"\r
#include "al_ioc_pnp.h"\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_ioc_pnp.tmh"\r
+#endif\r
#include "ib_common.h"\r
#include "al_mgr.h"\r
#include "al_ca.h"\r
gp_ioc_pnp = (ioc_pnp_mgr_t*)cl_zalloc( sizeof(ioc_pnp_mgr_t) );\r
if( !gp_ioc_pnp )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Failed to allocate IOC PnP manager.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( status != IB_SUCCESS )\r
{\r
__free_ioc_pnp( &gp_ioc_pnp->obj );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__construct_ioc_pnp returned %s\n", ib_get_err_str( status )) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_ioc_pnp->obj.pfn_destroy( &gp_ioc_pnp->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_ioc_pnp->obj.pfn_destroy( &gp_ioc_pnp->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_reg_pnp failed with status %s.\n",\r
ib_get_err_str( status )) );\r
return status;\r
cl_status = cl_spinlock_init( &p_ioc_mgr->iou_pool_lock );\r
if( cl_status != CL_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_spinlock_init returned %s\n", cl_status_text[cl_status]) );\r
return ib_convert_cl_status( cl_status );\r
}\r
cl_status = cl_spinlock_init( &p_ioc_mgr->path_pool_lock );\r
if( cl_status != CL_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_spinlock_init returned %s\n", cl_status_text[cl_status]) );\r
return ib_convert_cl_status( cl_status );\r
}\r
cl_status = cl_spinlock_init( &p_ioc_mgr->ioc_pool_lock );\r
if( cl_status != CL_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_spinlock_init returned %s\n", cl_status_text[cl_status]) );\r
return ib_convert_cl_status( cl_status );\r
}\r
sizeof(iou_node_t), __init_iou, NULL, p_ioc_mgr );\r
if( cl_status != CL_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_qpool_init returned %s\n", cl_status_text[cl_status]) );\r
return ib_convert_cl_status( cl_status );\r
}\r
sizeof(iou_path_t), NULL, NULL, NULL );\r
if( cl_status != CL_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_qpool_init returned %s\n", cl_status_text[cl_status]) );\r
return ib_convert_cl_status( cl_status );\r
}\r
sizeof(iou_ioc_t), NULL, NULL, NULL );\r
if( cl_status != CL_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_qpool_init returned %s\n", cl_status_text[cl_status]) );\r
return ib_convert_cl_status( cl_status );\r
}\r
__ioc_pnp_timer_cb, p_ioc_mgr );\r
if( cl_status != CL_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_timer_init failed with %s\n", cl_status_text[cl_status]) );\r
return ib_convert_cl_status( cl_status );\r
}\r
__destroying_ioc_pnp, NULL, __free_ioc_pnp );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_al_obj returned %s\n", ib_get_err_str( status )) );\r
return status;\r
}\r
h_ca = acquire_ca( p_pnp_port_rec->p_ca_attr->ca_guid );\r
if( !h_ca )\r
{\r
- AL_TRACE_EXIT( AL_DBG_PNP, ("acquire_ca failed.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("acquire_ca failed.\n") );\r
return IB_INVALID_GUID;\r
}\r
p_ioc_pnp_svc->obj.p_ci_ca = h_ca->obj.p_ci_ca;\r
/* Check for failure allocating the QP. */\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_get_spl_qp failed with status %s\n",\r
ib_get_err_str( status )) );\r
return status;\r
&p_ioc_pnp_svc->h_mad_svc );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_reg_mad_svc failed with status %s\n",\r
ib_get_err_str( status )) );\r
return status;\r
p_ioc_pnp_svc = (ioc_pnp_svc_t*)cl_zalloc( sizeof(ioc_pnp_svc_t) );\r
if( !p_ioc_pnp_svc )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Failed to cl_zalloc port CM agent.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( status != IB_SUCCESS )\r
{\r
__free_ioc_pnp_svc( &p_ioc_pnp_svc->obj );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_al_obj failed with status %s.\n",\r
ib_get_err_str( status )) );\r
return status;\r
if( status != IB_SUCCESS )\r
{\r
p_ioc_pnp_svc->obj.pfn_destroy( &p_ioc_pnp_svc->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_ioc_pnp_svc->obj.pfn_destroy( &p_ioc_pnp_svc->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("__init_data_svc failed with status %s.\n",\r
ib_get_err_str( status )) );\r
return status;\r
\r
if( p_mgr->obj.state == CL_DESTROYING )\r
{\r
- AL_TRACE_EXIT( AL_DBG_PNP,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_INFORMATION, AL_DBG_PNP,\r
("Destroying - not resetting timer.\n") );\r
return;\r
}\r
\r
if( p_svc->obj.state == CL_DESTROYING )\r
{\r
- AL_TRACE_EXIT( AL_DBG_PNP,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_INFORMATION, AL_DBG_PNP,\r
("Destroying - not resetting timer.\n") );\r
return IB_NOT_DONE;\r
}\r
{\r
cl_atomic_dec( &p_svc->query_cnt );\r
deref_al_obj( &p_svc->obj );\r
- AL_TRACE_EXIT( AL_DBG_PNP | AL_DBG_WARN,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_PNP,\r
("ib_query returned %s\n", ib_get_err_str( status )) );\r
return status;\r
}\r
{\r
cl_atomic_dec( &p_svc->query_cnt );\r
deref_al_obj( &p_svc->obj );\r
- AL_TRACE_EXIT( AL_DBG_PNP | AL_DBG_WARN,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_PNP,\r
("ib_query returned %s\n", ib_get_err_str( status )) );\r
}\r
\r
MAD_BLOCK_SIZE, &p_mad );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_get_mad for IOU Info query returned %s.\n",\r
ib_get_err_str( status )) );\r
break;\r
status = ib_send_mad( p_results->p_svc->h_mad_svc, p_mad_list, &p_mad );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_send_mad returned %s\n", ib_get_err_str( status )) );\r
\r
/* If some sends succeeded, change the status. */\r
p_rec = cl_zalloc( event.rec_size * 2 );\r
if( !p_rec )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Failed to allocate user record.\n") );\r
return;\r
}\r
default:\r
CL_ASSERT( pnp_get_class( p_reg->pnp_class ) == IB_PNP_IOU ||\r
pnp_get_class( p_reg->pnp_class ) == IB_PNP_IOC );\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Invalid PnP registartion type.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid PnP registartion type.\n") );\r
}\r
\r
/* Release the reference we took for processing the deregistration. */\r
#include "al.h"\r
#include "al_ci_ca.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_mad_pool.tmh"\r
+#endif\r
+\r
#include "al_mad_pool.h"\r
#include "al_pd.h"\r
#include "al_verbs.h"\r
ib_pool_handle_t h_pool;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_POOL );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !ph_pool )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
__free_pool( &h_pool->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_al_obj failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
h_pool->obj.pfn_destroy( &h_pool->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &h_pool->obj );\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_POOL );\r
return IB_SUCCESS;\r
}\r
\r
ib_pool_handle_t h_pool;\r
ib_al_handle_t h_al;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_POOL );\r
\r
CL_ASSERT( p_obj );\r
h_pool = PARENT_STRUCT( p_obj, al_pool_t, obj );\r
/* Deregister this MAD pool from all protection domains. */\r
al_dereg_pool( h_al, h_pool );\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_POOL );\r
}\r
\r
\r
al_obj_t* p_obj;\r
boolean_t busy;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_POOL );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pool, AL_OBJ_TYPE_H_MAD_POOL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
\r
/* Return an error if the pool is busy. */\r
if( busy )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("h_pool (0x%p) is busy!.\n", h_pool) );\r
return IB_RESOURCE_BUSY;\r
}\r
ref_al_obj( &h_pool->obj );\r
h_pool->obj.pfn_destroy( &h_pool->obj, NULL );\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_POOL );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_POOL );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pool, AL_OBJ_TYPE_H_MAD_POOL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
/* Alias keys require an alias PD. */\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
\r
if( status == IB_SUCCESS )\r
deref_al_obj( &(*pp_pool_key)->obj );\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_POOL );\r
return status;\r
}\r
\r
ib_api_status_t status;\r
al_key_type_t key_type;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_POOL );\r
\r
if( !pp_pool_key )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
{\r
__free_pool_key( &p_pool_key->obj );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_al_obj failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_pool_key->obj.pfn_destroy( &p_pool_key->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_reg_phys returned %s\n", ib_get_err_str( status )) );\r
return status;\r
}\r
{\r
p_pool_key->obj.pfn_destroy( &p_pool_key->obj, NULL );\r
\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
/* Return the pool key. */\r
*pp_pool_key = (ib_pool_key_t)p_pool_key;\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_POOL );\r
return IB_SUCCESS;\r
}\r
\r
status = ib_put_mad( p_mad_element_list );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_put_mad failed with status %s, continuing.\n",\r
ib_get_err_str(status)) );\r
}\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_POOL );\r
\r
if( AL_OBJ_INVALID_HANDLE( pool_key, AL_OBJ_TYPE_H_POOL_KEY ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( status != IB_SUCCESS )\r
deref_al_obj( &pool_key->obj );\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_POOL );\r
return status;\r
}\r
\r
*/\r
ib_api_status_t\r
dereg_mad_pool(\r
- IN const ib_pool_key_t pool_key ,\r
+ IN const ib_pool_key_t pool_key,\r
IN const al_key_type_t expected_type )\r
{\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_POOL );\r
\r
if( pool_key->type != expected_type )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
/* Check mad_cnt to see if MADs are still outstanding. */\r
//if( pool_key->mad_cnt )\r
//{\r
- // CL_TRACE_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl, ("IB_RESOURCE_BUSY\n") );\r
+ // AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_MAD_POOL, ("IB_RESOURCE_BUSY\n") );\r
// return IB_RESOURCE_BUSY;\r
//}\r
\r
pool_key->obj.pfn_destroy( &pool_key->obj, NULL );\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_POOL );\r
return IB_SUCCESS;\r
}\r
\r
mad_item_t* p_mad_item;\r
net32_t lkey;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_POOL );\r
\r
CL_ASSERT( pool_key );\r
CL_ASSERT( pp_mad_element );\r
/* Return the MAD element. */\r
*pp_mad_element = &p_mad_item->al_mad_element;\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_POOL );\r
return IB_SUCCESS;\r
}\r
\r
al_mad_element_t* p_mad;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD_POOL );\r
\r
if( AL_OBJ_INVALID_HANDLE( pool_key, AL_OBJ_TYPE_H_POOL_KEY ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
if( !buf_size || !pp_mad_element )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = __get_mad_element( pool_key, &p_mad );\r
if( status != IB_SUCCESS )\r
{\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_POOL );\r
return status;\r
}\r
\r
if( !p_mad->p_al_mad_buf )\r
{\r
__put_mad_element( p_mad );\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_POOL );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
p_mad->element.p_mad_buf = p_mad->p_al_mad_buf;\r
/* Return the MAD element to the client. */\r
*pp_mad_element = &p_mad->element;\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD_POOL );\r
return IB_SUCCESS;\r
}\r
\r
\r
if( !p_mad_element_list )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
#include "al.h"\r
#include "al_cm_cep.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_mgr.tmh"\r
+#endif\r
+\r
#include "al_dm.h"\r
#include "al_mad_pool.h"\r
#include "al_mcast.h"\r
cl_status_t cl_status;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MGR );\r
\r
CL_ASSERT( !gp_al_mgr );\r
\r
gp_al_mgr = cl_zalloc( sizeof( al_mgr_t ) );\r
if( !gp_al_mgr )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl, ("cl_zalloc failed.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("cl_zalloc failed.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
__free_al_mgr( &gp_al_mgr->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_al_obj failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
if( cl_status != CL_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_spinlock_init failed\n") );\r
return ib_convert_cl_status( cl_status );\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_open_al failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_pnp_create failed with %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_create_mad_pool failed with %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("create_res_mgr failed with %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("create_spl_qp_mgr failed with %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("create_sa_req_mgr failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("create_cm_mgr failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("create_dm_agent failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("create_ioc_pnp failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &gp_al_mgr->obj );\r
\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
return IB_SUCCESS;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MGR );\r
\r
if( !p_ci )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
CL_ASSERT( !find_ci_ca( p_ci->guid ) );\r
\r
- CL_TRACE( AL_DBG_MGR, g_al_dbg_lvl,\r
- ("CA guid %"PRIx64".\n", p_ci->guid) );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MGR,\r
+ ("CA guid %I64x.\n", p_ci->guid) );\r
\r
/* Check the channel interface verbs version. */\r
if( p_ci->version != VERBS_VERSION )\r
{\r
- CL_TRACE_EXIT( AL_DBG_MGR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Unsupported channel interface version, "\r
"expected = 0x%x, actual = 0x%x.\n",\r
VERBS_VERSION, p_ci->version) );\r
status = create_ci_ca( &gp_al_mgr->obj, p_ci );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("al_mgr_ca_init failed.\n") );\r
return status;\r
}\r
\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
return status;\r
}\r
\r
{\r
al_ci_ca_t *p_ci_ca;\r
\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MGR );\r
\r
- CL_TRACE( AL_DBG_MGR, g_al_dbg_lvl,\r
- ("Deregistering CA guid %"PRIx64".\n", ca_guid) );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_MGR,\r
+ ("Deregistering CA guid %I64x.\n", ca_guid) );\r
\r
/* Locate the CA. */\r
cl_spinlock_acquire( &gp_al_mgr->obj.lock );\r
\r
if( !p_ci_ca )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("CA not found.\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("CA not found.\n") );\r
return IB_NOT_FOUND;\r
}\r
\r
ref_al_obj( &p_ci_ca->obj );\r
p_ci_ca->obj.pfn_destroy( &p_ci_ca->obj, NULL );\r
\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
return IB_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MGR );\r
\r
if( !ph_al )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
h_al = cl_zalloc( sizeof( ib_al_t ) );\r
if( !h_al )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("cl_zalloc failed\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("cl_zalloc failed\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
free_al( &h_al->obj );\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
return status;\r
}\r
status = attach_al_obj( &gp_al_mgr->obj, &h_al->obj );\r
if( status != IB_SUCCESS )\r
{\r
h_al->obj.pfn_destroy( &h_al->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &h_al->obj );\r
\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MGR );\r
return IB_SUCCESS;\r
}\r
\r
#include <iba/ib_al.h>\r
\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_mr.tmh"\r
+#endif\r
#include "al_mr.h"\r
#include "al_pd.h"\r
#include "al_res_mgr.h"\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
\r
if( !p_fmr_create || !ph_fmr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
h_fmr = alloc_mlnx_fmr();\r
if( !h_fmr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("unable to allocate memory handle\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( status != IB_SUCCESS )\r
{\r
h_fmr->obj.pfn_destroy( &h_fmr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
h_fmr->obj.pfn_destroy( &h_fmr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("unable to register memory: %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
\r
if( AL_OBJ_INVALID_HANDLE( h_fmr, AL_OBJ_TYPE_H_FMR ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_FMR_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_FMR_HANDLE\n") );\r
return IB_INVALID_FMR_HANDLE;\r
}\r
\r
if( !paddr_list || !p_vaddr || !p_lkey || !p_rkey )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
//TODO: do we need to do something more about the error ?\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("unable to map FMR: %s\n", ib_get_err_str(status)) );\r
}\r
\r
\r
if( AL_OBJ_INVALID_HANDLE( h_fmr, AL_OBJ_TYPE_H_FMR ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_FMR_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_FMR_HANDLE\n") );\r
return IB_INVALID_FMR_HANDLE;\r
}\r
\r
\r
if( AL_OBJ_INVALID_HANDLE( h_fmr, AL_OBJ_TYPE_H_FMR ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_FMR_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_FMR_HANDLE\n") );\r
return IB_INVALID_FMR_HANDLE;\r
}\r
\r
if( !verbs_check_mlnx_fmr( h_fmr ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_FMR_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_FMR_HANDLE\n") );\r
return IB_INVALID_FMR_HANDLE;\r
}\r
\r
net32_t rkey;\r
ib_mr_handle_t h_mr;\r
\r
- CL_ENTER( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MR );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
if( !p_mr_create || !p_lkey || !p_rkey || !ph_mr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = ib_reg_mem( h_pd, p_mr_create, &lkey, &rkey, &h_mr );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("unable to register memory: %s\n", ib_get_err_str(status)) );\r
return status;\r
}\r
h_mr->p_shmid = __create_shmid( shmid );\r
if( !h_mr->p_shmid )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("unable to allocate shmid\n") );\r
ib_dereg_mr( h_mr );\r
return IB_INSUFFICIENT_MEMORY;\r
*p_lkey = lkey;\r
*p_rkey = rkey;\r
*ph_mr = h_mr;\r
- CL_EXIT( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return IB_SUCCESS;\r
}\r
\r
net32_t rkey;\r
ib_mr_handle_t h_mr, h_reg_mr;\r
\r
- CL_ENTER( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MR );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
if( !p_vaddr || !p_lkey || !p_rkey || !ph_mr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = acquire_shmid( h_pd->obj.p_ci_ca, shmid, &p_shmid );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("shmid not found: %s\n", ib_get_err_str(status)) );\r
return IB_NOT_FOUND;\r
}\r
if( cl_is_list_empty( &p_shmid->mr_list ) )\r
{\r
/* There are no registrations left to share. */\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("shmid not found\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("shmid not found\n") );\r
cl_spinlock_release( &p_shmid->obj.lock );\r
release_shmid( p_shmid );\r
return IB_NOT_FOUND;\r
&lkey, &rkey, &h_mr );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
- ("unable to register shared memory: 0x%0"PRIx64" %s\n",\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
+ ("unable to register shared memory: 0x%0I64x %s\n",\r
vaddr, ib_get_err_str(status)) );\r
release_shmid( p_shmid );\r
return status;\r
cl_status = cl_list_insert_head( &p_shmid->mr_list, h_mr );\r
if( cl_status != CL_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("insertion into shmid list failed\n") );\r
cl_spinlock_release( &p_shmid->obj.lock );\r
release_shmid( p_shmid );\r
*p_lkey = lkey;\r
*p_rkey = rkey;\r
*ph_mr = h_mr;\r
- CL_EXIT( AL_DBG_MR, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return IB_SUCCESS;\r
#endif\r
}\r
\r
#include "al.h"\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_pnp.tmh"\r
+#endif\r
#include "al_mgr.h"\r
#include "al_pnp.h"\r
#include "ib_common.h"\r
ib_api_status_t status;\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
CL_ASSERT( gp_pnp == NULL );\r
\r
gp_pnp = (al_pnp_mgr_t*)cl_zalloc( sizeof(al_pnp_mgr_t) );\r
if( !gp_pnp )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Failed to allocate PnP manager.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( cl_status != CL_SUCCESS )\r
{\r
__pnp_free( &gp_pnp->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_ptr_vector_init failed with status %s.\n",\r
CL_STATUS_MSG( cl_status )) );\r
return IB_ERROR;\r
if( status != IB_SUCCESS )\r
{\r
__pnp_free( &gp_pnp->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_al_obj() failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_pnp->obj.pfn_destroy( &gp_pnp->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &gp_pnp->obj );\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
return( IB_SUCCESS );\r
}\r
\r
__pnp_free(\r
IN al_obj_t *p_obj )\r
{\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
CL_ASSERT( PARENT_STRUCT( p_obj, al_pnp_mgr_t, obj ) == gp_pnp );\r
CL_ASSERT( cl_is_qlist_empty( &gp_pnp->ca_reg_list ) );\r
cl_free( gp_pnp );\r
gp_pnp = NULL;\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
}\r
\r
\r
{\r
al_pnp_t* p_reg;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
p_reg = PARENT_STRUCT( p_item, al_pnp_t, dereg_item );\r
\r
default:\r
CL_ASSERT( pnp_get_class( p_reg->pnp_class ) == IB_PNP_CA ||\r
pnp_get_class( p_reg->pnp_class ) == IB_PNP_PORT );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid PnP registartion type.\n") );\r
}\r
\r
/* Release the reference we took for processing the deregistration. */\r
deref_al_obj( &p_reg->obj );\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
}\r
\r
\r
cl_map_item_t *p_item;\r
IRP *p_irp;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
p_reg = PARENT_STRUCT( p_obj, al_pnp_t, obj );\r
\r
/* Dereference the PnP manager. */\r
deref_al_obj( &gp_pnp->obj );\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
}\r
\r
\r
al_pnp_t *p_reg;\r
cl_map_item_t *p_item;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
p_reg = PARENT_STRUCT( p_obj, al_pnp_t, obj );\r
\r
destroy_al_obj( &p_reg->obj );\r
cl_free( p_reg );\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
}\r
\r
\r
ib_pnp_port_rec_t port_rec;\r
} u;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
CL_ASSERT( p_reg );\r
CL_ASSERT( p_context );\r
\r
default:\r
/* Invalid event type. */\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid event type (%d).\n", p_event_rec->pnp_event) );\r
CL_ASSERT( p_event_rec->pnp_event == IB_PNP_CA_ADD ||\r
p_event_rec->pnp_event == IB_PNP_PORT_ADD ||\r
cl_free( p_context );\r
}\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
return status;\r
}\r
\r
al_pnp_context_t *p_context;\r
cl_map_item_t *p_item;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
CL_ASSERT( p_reg );\r
\r
p_context = (al_pnp_context_t*)cl_pzalloc( sizeof(al_pnp_context_t) );\r
if( !p_context )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
- ("Failed to cl_zalloc al_pnp_context_t (%"PRIdSIZE_T" bytes).\n",\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
+ ("Failed to cl_zalloc al_pnp_context_t (%I64d bytes).\n",\r
sizeof(al_pnp_context_t)) );\r
return NULL;\r
}\r
p_item = cl_qmap_insert( &p_reg->context_map, p_context->guid,\r
&p_context->map_item );\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
return p_context;\r
}\r
\r
ib_port_attr_t *p_port_attr;\r
al_pnp_ca_event_t event_rec;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
event_rec.p_ci_ca = p_ci_ca;\r
\r
}\r
}\r
}\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
}\r
\r
\r
size_t i;\r
al_pnp_context_t *p_context;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
for( i = 0; i < cl_ptr_vector_get_size( &gp_pnp->ca_vector ); i++ )\r
{\r
/* Notify the user that the registration is complete. */\r
pnp_reg_complete( p_reg );\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
}\r
\r
\r
{\r
al_pnp_t* p_reg;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
p_reg = PARENT_STRUCT( p_item, al_pnp_t, async_item );\r
\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &p_reg->obj );\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
}\r
\r
\r
ib_api_status_t status;\r
KEVENT event;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !p_pnp_req || !ph_pnp )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
ib_api_status_t status;\r
al_pnp_t* p_reg;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
/* Allocate a new registration info structure. */\r
p_reg = (al_pnp_t*)cl_zalloc( sizeof(al_pnp_t) );\r
if( !p_reg )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
- ("Failed to cl_zalloc al_pnp_t (%"PRIdSIZE_T" bytes).\n",\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
+ ("Failed to cl_zalloc al_pnp_t (%I64d bytes).\n",\r
sizeof(al_pnp_t)) );\r
return( IB_INSUFFICIENT_MEMORY );\r
}\r
if( status != IB_SUCCESS )\r
{\r
__pnp_reg_free( &p_reg->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_al_obj() failed with status %s.\n", ib_get_err_str(status)) );\r
return( status );\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_reg->obj.pfn_destroy( &p_reg->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
/* Set the user handle. */\r
*ph_pnp = p_reg;\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
return( IB_SUCCESS );\r
}\r
\r
IN const ib_pnp_handle_t h_pnp,\r
IN const ib_pfn_destroy_cb_t pfn_destroy_cb OPTIONAL )\r
{\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pnp, AL_OBJ_TYPE_H_PNP ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
\r
ref_al_obj( &h_pnp->obj );\r
h_pnp->obj.pfn_destroy( &h_pnp->obj, pfn_destroy_cb );\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
return( IB_SUCCESS );\r
}\r
\r
cl_status_t cl_status;\r
size_t i;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
p_event_rec = PARENT_STRUCT( p_item, al_pnp_ca_event_t, async_item );\r
\r
deref_al_obj( &gp_pnp->obj );\r
cl_free( p_event_rec );\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
}\r
\r
\r
al_pnp_ca_event_t event_rec;\r
ib_port_attr_t *p_port_attr;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
CL_ASSERT( p_event_rec->p_ci_ca->p_pnp_attr );\r
CL_ASSERT( p_event_rec->p_ci_ca->p_pnp_attr->p_port_attr );\r
}\r
}\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
}\r
\r
\r
al_pnp_context_t *p_context = NULL;\r
size_t i;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
p_event_rec = PARENT_STRUCT( p_item, al_pnp_ca_event_t, async_item );\r
\r
deref_al_obj( &gp_pnp->obj );\r
cl_free( p_event_rec );\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
}\r
\r
\r
al_pnp_ca_event_t *p_event_rec;\r
ib_ca_attr_t *p_old_ca_attr;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
/* Allocate an event record. */\r
p_event_rec = (al_pnp_ca_event_t*)cl_zalloc( sizeof(al_pnp_ca_event_t) );\r
if( !p_event_rec )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
- ("Failed to cl_zalloc al_pnp_ca_event_t (%"PRIdSIZE_T" bytes).\n",\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
+ ("Failed to cl_zalloc al_pnp_ca_event_t (%I64d bytes).\n",\r
sizeof(al_pnp_ca_event_t)) );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( cl_status != CL_SUCCESS )\r
{\r
cl_free( p_event_rec );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_ptr_vector_set_size failed with status %s.\n",\r
CL_STATUS_MSG( cl_status )) );\r
return ib_convert_cl_status( cl_status );\r
CL_ASSERT( cl_status == CL_SUCCESS );\r
cl_spinlock_release( &gp_pnp->obj.lock );\r
cl_free( p_event_rec );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ci_ca_update_attr failed.\n") );\r
return status;\r
}\r
{\r
/* The CA was never added by the PNP manager. */\r
cl_free( p_event_rec );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Ignoring removal request for unknown CA.\n") );\r
return IB_NOT_FOUND;\r
}\r
/* Invalid event for this function. */\r
CL_ASSERT( event == IB_PNP_CA_ADD || event == IB_PNP_CA_REMOVE );\r
cl_free( p_event_rec );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Invalid event type.\n") );\r
return IB_ERROR;\r
}\r
ref_al_obj( &gp_pnp->obj );\r
cl_async_proc_queue( gp_async_pnp_mgr, &p_event_rec->async_item );\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
return IB_SUCCESS;\r
}\r
\r
al_pnp_context_t *p_context;\r
ib_port_attr_t *p_port_attr;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
/* Walk the list of registrants for notification. */\r
for( p_reg_item = cl_qlist_head( &gp_pnp->port_reg_list );\r
__pnp_notify_user( p_reg, p_context, p_event_rec );\r
}\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
}\r
\r
\r
al_pnp_context_t *p_context;\r
ib_port_attr_t *p_port_attr;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
/* Walk the list of registrants for notification. */\r
for( p_reg_item = cl_qlist_tail( &gp_pnp->port_reg_list );\r
__pnp_notify_user( p_reg, p_context, p_event_rec );\r
}\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
}\r
\r
\r
al_pnp_ca_event_t event_rec;\r
ib_port_attr_t *p_old_port_attr, *p_new_port_attr;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
/* Store the event information. */\r
event_rec.p_ci_ca = p_ci_ca;\r
ib_ca_attr_t *p_old_ca_attr;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
UNUSED_PARAM( p_item );\r
CL_ASSERT( gp_pnp );\r
deref_al_obj( &gp_pnp->obj );\r
gp_pnp->async_item_is_busy = FALSE;\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
}\r
\r
\r
pnp_poll(\r
void )\r
{\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
CL_ASSERT( gp_pnp );\r
\r
/* Queue the request to check for PnP events. */\r
cl_async_proc_queue( gp_async_pnp_mgr, &gp_pnp->async_item );\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
}\r
\r
\r
ib_ca_attr_t *p_old_ca_attr;\r
al_ci_ca_t *p_ci_ca;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
CL_ASSERT( p_item );\r
CL_ASSERT( gp_pnp );\r
/* Dereference the PnP Manager. */\r
deref_al_obj( &gp_pnp->obj );\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
}\r
\r
\r
al_pnp_ca_change_t* p_pnp_ca_change;\r
size_t size;\r
\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
CL_ASSERT( p_ci_ca );\r
CL_ASSERT( p_ca_attr );\r
p_new_ca_attr = (ib_ca_attr_t*)cl_zalloc( size );\r
if( !p_new_ca_attr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_PNP, g_al_dbg_lvl,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR,AL_DBG_PNP,\r
("Unable to allocate buffer for changed CA attributes\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
/* Queue the CA change event. */\r
cl_async_proc_queue( gp_async_pnp_mgr, &p_pnp_ca_change->async_item );\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
return IB_SUCCESS;\r
}\r
\r
IN const ib_al_handle_t h_al,\r
IN const ib_pnp_handle_t h_event )\r
{\r
- CL_ENTER( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !h_event )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
\r
- CL_EXIT( AL_DBG_PNP, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PNP );\r
return IB_UNSUPPORTED;\r
}\r
#include "al.h"\r
#include "al_mr.h"\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_proxy.tmh"\r
+#endif\r
#include "al_dev.h"\r
#include "al_ci_ca.h"\r
#include "al_mgr.h"\r
uint64_t vaddr;\r
net32_t lkey, rkey;\r
\r
- CL_ENTER( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_DEV );\r
\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) < sizeof(ual_reg_shmid_ioctl_t) ||\r
cl_ioctl_out_size( h_ioctl ) < sizeof(ual_reg_shmid_ioctl_t) )\r
{\r
- CL_EXIT( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_DEV );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
\r
done:\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
- CL_EXIT( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_DEV );\r
return CL_SUCCESS;\r
}\r
\r
cl_ioctl_handle_t *ph_ioctl;\r
uintn_t ioctl_size;\r
\r
- CL_ENTER( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_DEV );\r
\r
/* Set up the appropriate callback list. */\r
switch( cb_type )\r
break;\r
\r
default:\r
- CL_EXIT( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_DEV );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
cl_ioctl_out_buf( h_ioctl ), &p_cb_info->cb_type, ioctl_size );\r
cl_ioctl_complete( h_ioctl, CL_SUCCESS, ioctl_size );\r
cl_spinlock_release( &p_context->cb_lock );\r
- CL_EXIT( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_DEV );\r
return CL_COMPLETED;\r
}\r
if( p_cb_info->p_al_obj )\r
proxy_context_ref( p_context );\r
cl_spinlock_release( &p_context->cb_lock );\r
\r
- CL_EXIT( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_DEV );\r
return CL_PENDING;\r
}\r
\r
p_context = (al_dev_open_context_t*)p_io_stack->FileObject->FsContext;\r
if( (uintn_t)p_io_stack->FileObject->FsContext2 != AL_OBJ_TYPE_CM )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
- ("Invalid file object type for request: %d\n",\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
+ ("Invalid file object type for request: %p\n",\r
p_io_stack->FileObject->FsContext2) );\r
return CL_INVALID_PARAMETER;\r
}\r
if( !p_context || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(cm_cb_ioctl_info_t) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("No output buffer, or buffer too small.\n") );\r
return CL_INVALID_PARAMETER;\r
}\r
p_context = (al_dev_open_context_t*)p_io_stack->FileObject->FsContext;\r
if( (uintn_t)p_io_stack->FileObject->FsContext2 != AL_OBJ_TYPE_H_CQ )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
- ("Invalid file object type for request: %d\n",\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
+ ("Invalid file object type for request: %p\n",\r
p_io_stack->FileObject->FsContext2) );\r
return CL_INVALID_PARAMETER;\r
}\r
if( !p_context || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(comp_cb_ioctl_info_t) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("No output buffer, or buffer too small.\n") );\r
return CL_INVALID_PARAMETER;\r
}\r
p_context = (al_dev_open_context_t*)p_io_stack->FileObject->FsContext;\r
if( (uintn_t)p_io_stack->FileObject->FsContext2 != AL_OBJ_TYPE_AL_MGR )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
- ("Invalid file object type for request: %d\n",\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
+ ("Invalid file object type for request: %p\n",\r
p_io_stack->FileObject->FsContext2) );\r
return CL_INVALID_PARAMETER;\r
}\r
if( !p_context || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(misc_cb_ioctl_info_t) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("No output buffer, or buffer too small.\n") );\r
return CL_INVALID_PARAMETER;\r
}\r
misc_cb_ioctl_rec_t *p_misc_rec = &misc_cb_info.ioctl_rec;\r
al_dev_open_context_t *p_context;\r
\r
- CL_ENTER( AL_DBG_PROXY_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PROXY_CB );\r
\r
p_context = p_pnp_rec->pnp_context;\r
\r
}\r
\r
proxy_context_deref( p_context );\r
- CL_EXIT( AL_DBG_PROXY_CB, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PROXY_CB );\r
return IB_SUCCESS;\r
}\r
\r
ib_ca_attr_t *p_ca_attr;\r
uint64_t hdl;\r
\r
- CL_ENTER( AL_DBG_PROXY_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PROXY_CB );\r
\r
p_context = p_pnp_rec->pnp_context;\r
\r
p_ca_attr = cl_zalloc( p_port_rec->p_ca_attr->size );\r
if( !p_ca_attr )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_malloc( %d ) failed.\n", p_port_rec->p_ca_attr->size) );\r
break;\r
}\r
}\r
\r
proxy_context_deref( p_context );\r
- CL_EXIT( AL_DBG_PROXY_CB, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PROXY_CB );\r
return IB_SUCCESS;\r
}\r
\r
ual_ca_attr_info_ioctl_t *p_ioctl;\r
ib_ca_attr_t *p_src;\r
\r
- CL_ENTER( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_DEV );\r
\r
/* Check the size of the ioctl */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) < sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) < sizeof(p_ioctl->out) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("invalid buffer size\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("invalid buffer size\n") );\r
return CL_INVALID_PARAMETER;\r
}\r
p_context = (al_dev_open_context_t*)p_open_context;\r
p_context->h_al, p_ioctl->in.h_ca_attr, AL_OBJ_TYPE_H_CA_ATTR );\r
if( !p_src )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("invalid attr handle\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("invalid attr handle\n") );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_DEV );\r
return CL_SUCCESS;\r
}\r
\r
!cl_ioctl_in_buf( h_ioctl ) || cl_ioctl_out_size( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(ual_bind_file_ioctl_t) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("No input buffer, or buffer too small.\n") );\r
return CL_INVALID_PARAMETER;\r
}\r
&p_file_obj, NULL );\r
if( !NT_SUCCESS(status) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ObReferenceObjectByHandle returned 0x%08X\n", status) );\r
return CL_INVALID_PARAMETER;\r
}\r
cl_status_t cl_status;\r
ib_api_status_t ret_status;\r
\r
- AL_ENTER( AL_DBG_DEV | AL_DBG_PNP );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
p_rec = (proxy_pnp_recs_t*)p_pnp_rec;\r
\r
p_irp = InterlockedExchangePointer( &p_pnp_rec->h_pnp->p_rearm_irp, NULL );\r
if( !p_irp )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("No rearm IRP queued for PnP event.\n") );\r
return ret_status;\r
}\r
if( hdl == AL_INVALID_HANDLE )\r
{\r
cl_free( p_evt );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Failed to insert PnP event in handle map.\n") );\r
return ret_status;\r
}\r
cl_event_destroy( &p_evt->event );\r
cl_free( p_evt );\r
\r
- AL_EXIT( AL_DBG_DEV | AL_DBG_PNP );\r
+ AL_EXIT( AL_DBG_PNP );\r
return ret_status;\r
}\r
\r
KEVENT *p_sync_event;\r
NTSTATUS nt_status;\r
\r
- AL_ENTER( AL_DBG_DEV | AL_DBG_PNP );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
p_context = p_open_context;\r
\r
p_io_stack = IoGetCurrentIrpStackLocation( h_ioctl );\r
if( (uintn_t)p_io_stack->FileObject->FsContext2 != AL_OBJ_TYPE_PNP_MGR )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
- ("Invalid file object type for request: %d\n",\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
+ ("Invalid file object type for request: %p\n",\r
p_io_stack->FileObject->FsContext2) );\r
return CL_INVALID_PARAMETER;\r
}\r
if( cl_ioctl_in_size( h_ioctl ) < sizeof(ual_reg_pnp_ioctl_in_t) ||\r
cl_ioctl_out_size( h_ioctl ) < sizeof(ual_rearm_pnp_ioctl_out_t) )\r
{\r
- AL_EXIT( AL_DBG_DEV | AL_DBG_PNP );\r
+ AL_EXIT( AL_DBG_PNP );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
(PVOID*)&p_sync_event, NULL );\r
if( !NT_SUCCESS( nt_status ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Invalid sync event handle\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid sync event handle\n") );\r
return CL_INVALID_PARAMETER;\r
}\r
}\r
cl_copy_to_user( p_user_status, &status, sizeof(ib_api_status_t) );\r
cl_mutex_release( &p_context->pnp_mutex );\r
\r
- AL_EXIT( AL_DBG_DEV | AL_DBG_PNP );\r
+ AL_EXIT( AL_DBG_PNP );\r
return cl_status;\r
}\r
\r
al_dev_open_context_t *p_context;\r
proxy_pnp_evt_t *p_evt;\r
\r
- AL_ENTER( AL_DBG_DEV | AL_DBG_PNP );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
p_context = p_open_context;\r
\r
if( cl_ioctl_in_size( h_ioctl ) < sizeof(uint64_t) ||\r
cl_ioctl_out_size( h_ioctl ) < sizeof(ib_pnp_rec_t) )\r
{\r
- AL_EXIT( AL_DBG_DEV | AL_DBG_PNP );\r
+ AL_EXIT( AL_DBG_PNP );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( cl_ioctl_out_size( h_ioctl ) < p_evt->rec_size )\r
{\r
cl_spinlock_release( &p_context->h_al->obj.lock );\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Buffer too small!\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Buffer too small!\n") );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
}\r
cl_spinlock_release( &p_context->h_al->obj.lock );\r
\r
- AL_EXIT( AL_DBG_DEV | AL_DBG_PNP );\r
+ AL_EXIT( AL_DBG_PNP );\r
return CL_SUCCESS;\r
}\r
\r
ib_pnp_handle_t h_pnp;\r
IRP *p_old_irp;\r
\r
- AL_ENTER( AL_DBG_DEV | AL_DBG_PNP );\r
+ AL_ENTER( AL_DBG_PNP );\r
\r
p_context = p_open_context;\r
\r
p_io_stack = IoGetCurrentIrpStackLocation( h_ioctl );\r
if( (uintn_t)p_io_stack->FileObject->FsContext2 != AL_OBJ_TYPE_PNP_MGR )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
- ("Invalid file object type for request: %d\n",\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
+ ("Invalid file object type for request: %p\n",\r
p_io_stack->FileObject->FsContext2) );\r
return CL_INVALID_PARAMETER;\r
}\r
if( cl_ioctl_in_size( h_ioctl ) != sizeof(ual_rearm_pnp_ioctl_in_t) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(ual_rearm_pnp_ioctl_out_t) )\r
{\r
- AL_EXIT( AL_DBG_DEV | AL_DBG_PNP );\r
+ AL_EXIT( AL_DBG_PNP );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
al_hdl_ref( p_context->h_al, p_ioctl->pnp_hdl, AL_OBJ_TYPE_H_PNP );\r
if( !h_pnp )\r
{\r
- AL_TRACE_EXIT( AL_DBG_WARN | AL_DBG_DEV | AL_DBG_PNP,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_WARNING, AL_DBG_PNP,\r
("Invalid PNP handle.\n") );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
deref_al_obj( &h_pnp->obj );\r
\r
- AL_EXIT( AL_DBG_DEV | AL_DBG_PNP );\r
+ AL_EXIT( AL_DBG_PNP );\r
return CL_PENDING;\r
}\r
\r
IO_STACK_LOCATION *p_io_stack;\r
ib_pnp_handle_t h_pnp;\r
\r
- AL_ENTER( AL_DBG_DEV | AL_DBG_PNP );\r
+ AL_ENTER( AL_DBG_PNP );\r
p_context = p_open_context;\r
\r
p_io_stack = IoGetCurrentIrpStackLocation( h_ioctl );\r
if( (uintn_t)p_io_stack->FileObject->FsContext2 != AL_OBJ_TYPE_PNP_MGR )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
- ("Invalid file object type for request: %d\n",\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
+ ("Invalid file object type for request: %p\n",\r
p_io_stack->FileObject->FsContext2) );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
h_pnp->obj.pfn_destroy( &h_pnp->obj, NULL );\r
\r
- AL_EXIT( AL_DBG_DEV | AL_DBG_PNP );\r
+ AL_EXIT( AL_DBG_PNP );\r
return CL_PENDING;\r
}\r
\r
\r
\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_proxy_cep.tmh"\r
+#endif\r
#include "al_cm_cep.h"\r
#include "al_dev.h"\r
#include <iba/ib_al_ioctl.h>\r
p_io_stack = IoGetCurrentIrpStackLocation( h_ioctl );\r
if( (uintn_t)p_io_stack->FileObject->FsContext2 != AL_OBJ_TYPE_CM )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
- ("Invalid file object type for request: %d\n",\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
+ ("Invalid file object type for request: %p\n",\r
p_io_stack->FileObject->FsContext2) );\r
return CL_INVALID_PARAMETER;\r
}\r
/* Check the size of the ioctl */\r
if( cl_ioctl_in_size( h_ioctl ) != sizeof(net32_t) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Invalid IOCTL input buffer.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid IOCTL input buffer.\n") );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
uint8_t *dest;\r
uint64_t hdl;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_memclr(&cb_info, sizeof(cb_info));\r
\r
proxy_queue_cb_buf( UAL_GET_CM_CB_INFO, p_context, &cb_info, NULL );\r
}\r
proxy_context_deref( p_context );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
al_dev_open_context_t *p_context;\r
uint64_t hdl;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_memclr(&cb_info, sizeof(cb_info));\r
cb_info.rec_type = CM_DREQ_REC;\r
}\r
\r
proxy_context_deref( p_context );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
struct _cm_rtu_cb_ioctl_rec *p_ioctl_rec;\r
al_dev_open_context_t *p_context;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_memclr(&cb_info, sizeof(cb_info));\r
cb_info.rec_type = CM_RTU_REC;\r
}\r
\r
proxy_context_deref( p_context );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
uint64_t hdl;\r
al_obj_t *p_al_obj;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_memclr(&cb_info, sizeof(cb_info));\r
cb_info.rec_type = CM_REP_REC;\r
\r
proxy_queue_cb_buf( UAL_GET_CM_CB_INFO, p_context, &cb_info, p_al_obj );\r
proxy_context_deref( p_context );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
&cb_info.ioctl_rec.cm_drep_cb_ioctl_rec;\r
al_dev_open_context_t *p_context;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
cl_memclr(&cb_info, sizeof(cb_info));\r
cb_info.rec_type = CM_DREP_REC;\r
p_ioctl_rec->drep_rec = *p_cm_drep_rec;\r
}\r
\r
proxy_context_deref( p_context );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
&cb_info.ioctl_rec.cm_mra_cb_ioctl_rec;\r
al_dev_open_context_t *p_context;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_memclr( &cb_info, sizeof(cb_info) );\r
cb_info.rec_type = CM_MRA_REC;\r
}\r
\r
proxy_context_deref( p_context );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
&cb_info.ioctl_rec.cm_rej_cb_ioctl_rec;\r
al_dev_open_context_t *p_context;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
cl_memclr(&cb_info, sizeof(cb_info));\r
cb_info.rec_type = CM_REJ_REC;\r
}\r
\r
proxy_context_deref( p_context );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
al_dev_open_context_t *p_context;\r
uint64_t hdl;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
cl_memclr(&cb_info, sizeof(cb_info));\r
cb_info.rec_type = CM_LAP_REC;\r
p_ioctl_rec->lap_rec = *p_cm_lap_rec;\r
}\r
\r
proxy_context_deref( p_context );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
&cb_info.ioctl_rec.cm_apr_cb_ioctl_rec;\r
al_dev_open_context_t *p_context;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
cl_memclr( &cb_info, sizeof(cb_info) );\r
cb_info.rec_type = CM_APR_REC;\r
p_ioctl_rec->apr_rec = *p_cm_apr_rec;\r
}\r
\r
proxy_context_deref( p_context );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
al_dev_open_context_t *p_context;\r
misc_cb_ioctl_info_t cb_info;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/*\r
* If we're already closing the device - do not queue a callback, since\r
if( !proxy_context_ref( p_context ) )\r
{\r
proxy_context_deref( p_context );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return;\r
}\r
\r
&p_err_rec->h_cm_listen->obj );\r
proxy_context_deref( p_context );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
}\r
\r
\r
size_t in_buf_sz;\r
uint8_t *p_buf;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) < sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
\r
if( cl_ioctl_in_size( h_ioctl ) != in_buf_sz )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_qp )\r
{\r
p_ioctl->out.status = IB_INVALID_QP_HANDLE;\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return CL_SUCCESS;\r
}\r
p_ioctl->in.cm_req.h_qp = h_qp;\r
if( h_qp )\r
deref_al_obj( &h_qp->obj );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
ib_qp_handle_t h_qp;\r
size_t in_buf_sz;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) < sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
\r
if( cl_ioctl_in_size( h_ioctl ) != in_buf_sz )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_qp )\r
{\r
p_ioctl->out.status = IB_INVALID_QP_HANDLE;\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
p_ioctl->in.cm_rep.h_qp = h_qp;\r
{\r
deref_al_obj( &h_qp->obj );\r
p_ioctl->out.status = IB_INVALID_HANDLE;\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
__deref_conn( h_cm_req );\r
deref_al_obj( &h_qp->obj );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
ib_qp_handle_t h_qp;\r
size_t in_buf_sz;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) < sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
\r
if( cl_ioctl_in_size( h_ioctl ) != in_buf_sz )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_qp )\r
{\r
p_ioctl->out.status = IB_INVALID_QP_HANDLE;\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
p_ioctl->in.cm_dreq.h_qp = h_qp;\r
if( h_qp )\r
deref_al_obj( &h_qp->obj );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
ib_cm_handle_t h_cm_dreq;\r
size_t in_buf_sz;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) < sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
\r
if( cl_ioctl_in_size( h_ioctl ) != in_buf_sz )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
\r
__deref_conn( h_cm_dreq );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
(al_dev_open_context_t *)p_open_context;\r
size_t in_buf_sz;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) < sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
\r
if( cl_ioctl_in_size( h_ioctl ) != in_buf_sz )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.h_cm_listen = AL_INVALID_HANDLE;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
al_dev_open_context_t *p_context =\r
(al_dev_open_context_t *)p_open_context;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
h_cm_listen->obj.pfn_destroy( &h_cm_listen->obj, ib_sync_destroy );\r
p_ioctl->out.status = IB_SUCCESS;\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
ib_cm_handle_t h_cm_rep;\r
size_t in_buf_sz;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) < sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
\r
if( cl_ioctl_in_size( h_ioctl ) != in_buf_sz )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_cm_rep )\r
{\r
p_ioctl->out.status = IB_INVALID_HANDLE;\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
\r
__deref_conn( h_cm_rep );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
size_t in_buf_sz;\r
uint8_t *p_buf;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) < sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
\r
if( cl_ioctl_in_size( h_ioctl ) != in_buf_sz )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_cm )\r
{\r
p_ioctl->out.status = IB_INVALID_HANDLE;\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
\r
__deref_conn( h_cm );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
ib_cm_handle_t h_cm;\r
size_t in_buf_sz;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) < sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
\r
if( cl_ioctl_in_size( h_ioctl ) != in_buf_sz )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_cm )\r
{\r
p_ioctl->out.status = IB_INVALID_HANDLE;\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
\r
__deref_conn( h_cm );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
ib_qp_handle_t h_qp;\r
size_t in_buf_sz;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) < sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
\r
if( cl_ioctl_in_size( h_ioctl ) != in_buf_sz )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_qp )\r
{\r
p_ioctl->out.status = IB_INVALID_QP_HANDLE;\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
p_ioctl->in.cm_lap.h_qp = h_qp;\r
\r
deref_al_obj( &h_qp->obj );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
size_t in_buf_sz;\r
uint8_t *p_buf;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CM );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) < sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
\r
if( cl_ioctl_in_size( h_ioctl ) != in_buf_sz )\r
{\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_cm_lap )\r
{\r
p_ioctl->out.status = IB_INVALID_HANDLE;\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
{\r
__deref_conn( h_cm_lap );\r
p_ioctl->out.status = IB_INVALID_QP_HANDLE;\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
p_ioctl->in.cm_apr.h_qp = h_qp;\r
__deref_conn( h_cm_lap );\r
deref_al_obj( &h_qp->obj );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CM );\r
return CL_SUCCESS;\r
}\r
\r
break;\r
}\r
\r
- CL_EXIT( AL_DBG_DEV, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_DEV );\r
return cl_status;\r
}\r
#include "al_ca.h"\r
#include "al_cq.h"\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_proxy_subnet.tmh"\r
+#endif\r
#include "al_dev.h"\r
#include "al_mad_pool.h"\r
#include "al_mr.h"\r
al_dev_open_context_t *p_context;\r
uint64_t hdl;\r
\r
- AL_ENTER( AL_DBG_DEV | AL_DBG_QUERY );\r
+ AL_ENTER( AL_DBG_QUERY );\r
\r
p_irp = (IRP*)p_sa_req->user_context;\r
CL_ASSERT( p_irp );\r
if( p_io_stack->FileObject->FsContext2 &&\r
(uintn_t)p_io_stack->FileObject->FsContext2 != AL_OBJ_TYPE_SA_REQ_SVC )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
- ("Invalid file object type for request: %d\n",\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
+ ("Invalid file object type for request: %p\n",\r
p_io_stack->FileObject->FsContext2) );\r
return CL_INVALID_PARAMETER;\r
}\r
if( cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Invalid IOCTL buffers.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid IOCTL buffers.\n") );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( p_ioctl->in.sa_req.attr_size > IB_SA_DATA_SIZE )\r
{\r
ib_status = IB_INVALID_SETTING;\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Invalid SA data size: %d\n",\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid SA data size: %d\n",\r
p_ioctl->in.sa_req.attr_size) );\r
goto proxy_send_sa_req_err1;\r
}\r
if( !p_sa_req )\r
{\r
ib_status = IB_INSUFFICIENT_MEMORY;\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Failed to allocate SA req.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Failed to allocate SA req.\n") );\r
goto proxy_send_sa_req_err1;\r
}\r
\r
if( hdl == AL_INVALID_HANDLE )\r
{\r
ib_status = IB_INSUFFICIENT_MEMORY;\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Failed to create handle.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Failed to create handle.\n") );\r
goto proxy_send_sa_req_err2;\r
}\r
\r
if( cl_ioctl_in_size( h_ioctl ) != sizeof(ual_cancel_sa_req_ioctl_t) ||\r
cl_ioctl_out_size( h_ioctl ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Invalid input buffer.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Invalid input buffer.\n") );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
ib_grh_t *p_grh, *p_usr_grh;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD );\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
return CL_SUCCESS;\r
}\r
\r
ib_mad_element_t *p_mad;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->in.p_user_mad, p_mad, sizeof(ib_mad_element_t) ) );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Unable to copy element to user's MAD\n") );\r
goto proxy_mad_comp_err2;\r
}\r
p_ioctl->in.p_mad_buf, p_mad->p_mad_buf, p_mad->size ) );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Unable to copy buffer to user's MAD\n") );\r
goto proxy_mad_comp_err2;\r
}\r
p_ioctl->in.p_grh, p_mad->p_grh, sizeof(ib_grh_t) ) );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Unable to copy GRH to user's MAD\n") );\r
goto proxy_mad_comp_err2;\r
}\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
return CL_SUCCESS;\r
}\r
\r
al_dev_open_context_t *p_context;\r
al_mad_element_t *p_al_el;\r
\r
- CL_ENTER( ( AL_DBG_PROXY_CB | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD );\r
\r
CL_ASSERT( p_mad_element );\r
CL_ASSERT( !p_mad_element->p_next );\r
ib_put_mad( p_mad_element );\r
\r
proxy_context_deref( p_context );\r
- CL_EXIT( ( AL_DBG_PROXY_CB | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
}\r
\r
\r
al_mad_element_t *p_al_mad;\r
uint64_t hdl;\r
\r
- CL_ENTER( ( AL_DBG_PROXY_CB | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD );\r
\r
p_context = h_mad_svc->obj.h_al->p_context;\r
\r
if( !proxy_context_ref( p_context ) )\r
{\r
proxy_put_mad( p_mad_element );\r
- CL_EXIT( ( AL_DBG_PROXY_CB | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
return;\r
}\r
\r
\r
proxy_context_deref( p_context );\r
\r
- CL_EXIT( ( AL_DBG_PROXY_CB | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
}\r
\r
\r
ib_qp_handle_t h_qp;\r
ib_mad_svc_handle_t h_mad_svc;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
{\r
p_ioctl->out.status = IB_INVALID_QP_HANDLE;\r
p_ioctl->out.h_mad_svc = AL_INVALID_HANDLE;\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
return CL_SUCCESS;\r
}\r
\r
\r
deref_al_obj( &h_qp->obj );\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
return CL_SUCCESS;\r
}\r
\r
al_dev_open_context_t *p_context;\r
ib_mad_svc_handle_t h_mad_svc;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD );\r
\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("IOCTL buffer is invalid\n") );\r
return CL_INVALID_PARAMETER;\r
}\r
if( !h_mad_svc )\r
{\r
p_ioctl->out.status = IB_INVALID_HANDLE;\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return CL_SUCCESS;\r
}\r
\r
h_mad_svc->obj.pfn_destroy( &h_mad_svc->obj, ib_sync_destroy );\r
p_ioctl->out.status = IB_SUCCESS;\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
return CL_SUCCESS;\r
}\r
\r
ib_pd_handle_t h_pd;\r
ib_pool_key_t pool_key;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
{\r
p_ioctl->out.status = IB_INVALID_PD_HANDLE;\r
p_ioctl->out.pool_key = AL_INVALID_HANDLE;\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PD_HANDLE\n") );\r
return CL_SUCCESS;\r
}\r
\r
else\r
{\r
p_ioctl->out.pool_key = AL_INVALID_HANDLE;\r
- AL_TRACE( AL_DBG_ERROR, ("reg_mad_pool returned %s.\n",\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("reg_mad_pool returned %s.\n",\r
ib_get_err_str(p_ioctl->out.status)) );\r
}\r
\r
deref_al_obj( &h_pd->obj );\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
return CL_SUCCESS;\r
}\r
\r
(al_dev_open_context_t *)p_open_context;\r
ib_pool_key_t pool_key;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("IOCTL buffer is invalid\n") );\r
return CL_INVALID_PARAMETER;\r
}\r
if( !pool_key )\r
{\r
p_ioctl->out.status = IB_INVALID_HANDLE;\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("User-mode provided pool key is invalid\n") );\r
return CL_SUCCESS;\r
}\r
if( p_ioctl->out.status != IB_SUCCESS )\r
{\r
deref_al_obj( &pool_key->obj );\r
- AL_TRACE( AL_DBG_ERROR, ("dereg_mad_pool failed: %s\n",\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("dereg_mad_pool failed: %s\n",\r
ib_get_err_str( p_ioctl->out.status )) );\r
}\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
return CL_SUCCESS;\r
}\r
\r
al_dev_open_context_t *p_context;\r
ib_mad_svc_handle_t h_mad_svc;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_mad_svc )\r
{\r
p_ioctl->out.status = IB_INVALID_HANDLE;\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
return CL_SUCCESS;\r
}\r
\r
* The clean up of resources allocated for the sent mad will\r
* be handled in the send completion callback\r
*/\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MAD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
return CL_SUCCESS;\r
}\r
\r
ib_ca_handle_t h_ca;\r
ib_api_status_t status;\r
\r
- CL_ENTER(AL_DBG_MAD , g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MAD );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( AL_DBG_MAD , g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( ((ib_mad_t*)p_ioctl->in.mad_in)->method != IB_MAD_METHOD_GET )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("invalid method %d\n", ((ib_mad_t*)p_ioctl->in.mad_in)->method) );\r
status = IB_UNSUPPORTED;\r
goto proxy_local_mad_err;\r
proxy_local_mad_err:\r
p_ioctl->out.status = status;\r
\r
- CL_EXIT(AL_DBG_MAD ,g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MAD );\r
return CL_SUCCESS;\r
}\r
\r
#include <iba/ib_al_ioctl.h>\r
#include "al.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_proxy_verbs.tmh"\r
+#endif\r
+\r
#include "al_dev.h"\r
/* Get the internal definitions of apis for the proxy */\r
#include "al_ca.h"\r
(ual_get_uvp_name_ioctl_t*)cl_ioctl_in_buf( h_ioctl );\r
al_ci_ca_t *p_ci_ca;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
UNUSED_PARAM( p_open_context );\r
\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
/* Find the CAguid */\r
- CL_TRACE( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl,\r
- ("CA guid %"PRIx64".\n", p_ioctl->in.ca_guid) );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CA,\r
+ ("CA guid %I64x.\n", p_ioctl->in.ca_guid) );\r
\r
cl_spinlock_acquire( &gp_al_mgr->obj.lock );\r
p_ci_ca = find_ci_ca( p_ioctl->in.ca_guid );\r
else\r
{\r
/* found the ca guid, copy the user-mode verbs provider libname */\r
- CL_TRACE( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl,\r
- ("CA guid %"PRIx64". libname (%s)\n",\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_CA,\r
+ ("CA guid %I64x. libname (%s)\n",\r
p_ioctl->in.ca_guid, p_ci_ca->verbs.libname) );\r
cl_memcpy( p_ioctl->out.uvp_lib_name, p_ci_ca->verbs.libname,\r
sizeof(p_ci_ca->verbs.libname));\r
p_ioctl->out.status = IB_SUCCESS;\r
}\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return CL_SUCCESS;\r
}\r
\r
}\r
cl_spinlock_release( &p_context->cb_lock );\r
\r
- AL_EXIT(AL_DBG_DEV);\r
+ AL_EXIT( AL_DBG_DEV );\r
return TRUE;\r
}\r
\r
ci_umv_buf_t *p_umv_buf = NULL;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
\r
p_ioctl->out.status = status;\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return CL_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
uint32_t byte_cnt = 0;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
}\r
__except(EXCEPTION_EXECUTE_HANDLER)\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Failed to copy CA attributes to user buffer %p\n",\r
p_ioctl->in.p_ca_attr) );\r
status = IB_INVALID_PERMISSION;\r
p_ioctl->out.status = status;\r
p_ioctl->out.byte_cnt = byte_cnt;\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return CL_SUCCESS;\r
}\r
\r
(al_dev_open_context_t *)p_open_context;\r
ib_ca_handle_t h_ca;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_ca )\r
{\r
p_ioctl->out.status = IB_INVALID_CA_HANDLE;\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return CL_SUCCESS;\r
}\r
\r
\r
deref_al_obj( &h_ca->obj );\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return CL_SUCCESS;\r
}\r
\r
(al_dev_open_context_t *)p_open_context;\r
ib_ca_handle_t h_ca;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_ca )\r
{\r
p_ioctl->out.status = IB_INVALID_CA_HANDLE;\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return CL_SUCCESS;\r
}\r
\r
h_ca->obj.pfn_destroy( &h_ca->obj, ib_sync_destroy );\r
p_ioctl->out.status = IB_SUCCESS;\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return CL_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
uint32_t num_handles;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_PD ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CA );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) < sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( num_handles > 1 &&\r
cl_ioctl_in_size( h_ioctl ) != (sizeof(uint64_t) * (num_handles - 1)) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_ca )\r
{\r
p_ioctl->out.status = IB_INVALID_CA_HANDLE;\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return CL_SUCCESS;\r
}\r
\r
{\r
p_ioctl->out.status = IB_INSUFFICIENT_MEMORY;\r
deref_al_obj( &h_ca->obj );\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Failed to allocate handle array.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Failed to allocate handle array.\n") );\r
return CL_SUCCESS;\r
}\r
\r
cl_free( p_handle_array );\r
p_ioctl->out.status = status;\r
deref_al_obj( &h_ca->obj );\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Failed to convert handles.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("Failed to convert handles.\n") );\r
return CL_SUCCESS;\r
}\r
}\r
\r
deref_al_obj( &h_ca->obj );\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CA ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CA );\r
return CL_SUCCESS;\r
}\r
\r
ci_umv_buf_t *p_umv_buf = NULL;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_PD ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PD );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_PD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PD );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_PD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PD );\r
return CL_SUCCESS;\r
}\r
\r
(al_dev_open_context_t *)p_open_context;\r
ib_pd_handle_t h_pd;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_PD ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_PD );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_PD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PD );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_pd )\r
{\r
p_ioctl->out.status = IB_INVALID_PD_HANDLE;\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_PD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PD );\r
return CL_SUCCESS;\r
}\r
\r
h_pd->obj.pfn_destroy( &h_pd->obj, ib_sync_destroy );\r
p_ioctl->out.status = IB_SUCCESS;\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_PD ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_PD );\r
return CL_SUCCESS;\r
}\r
\r
al_dev_open_context_t *p_context = h_qp->obj.h_al->p_context;\r
misc_cb_ioctl_info_t cb_info;\r
\r
- AL_ENTER( AL_DBG_DEV | AL_DBG_QP );\r
+ AL_ENTER( AL_DBG_QP );\r
\r
/*\r
* If we're already closing the device - do not queue a callback, since\r
\r
proxy_context_deref( p_context );\r
\r
- AL_EXIT( AL_DBG_DEV | AL_DBG_QP );\r
+ AL_EXIT( AL_DBG_QP );\r
}\r
\r
\r
ib_api_status_t status;\r
ib_pfn_event_cb_t pfn_ev;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QP );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( h_sq_cq )\r
deref_al_obj( &h_sq_cq->obj );\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return CL_SUCCESS;\r
}\r
\r
ci_umv_buf_t *p_umv_buf = NULL;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QP );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return CL_SUCCESS;\r
}\r
\r
ci_umv_buf_t *p_umv_buf = NULL;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QP );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return CL_SUCCESS;\r
}\r
\r
(al_dev_open_context_t *)p_open_context;\r
ib_qp_handle_t h_qp;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QP );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
al_hdl_ref( p_context->h_al, p_ioctl->in.h_qp, AL_OBJ_TYPE_H_QP );\r
if( !h_qp )\r
{\r
- AL_TRACE( AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_QP_HANDLE\n") );\r
p_ioctl->out.status = IB_INVALID_QP_HANDLE;\r
}\r
else\r
p_ioctl->out.status = IB_SUCCESS;\r
}\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return CL_SUCCESS;\r
}\r
\r
ci_umv_buf_t *p_umv_buf = NULL;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_AV ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_AV );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_AV ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AV );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_AV ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AV );\r
return CL_SUCCESS;\r
}\r
\r
ci_umv_buf_t *p_umv_buf = NULL;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_AV ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_AV );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_AV ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AV );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_AV ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AV );\r
return CL_SUCCESS;\r
}\r
\r
ci_umv_buf_t *p_umv_buf = NULL;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_AV ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_AV );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_AV ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AV );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_AV ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AV );\r
return CL_SUCCESS;\r
}\r
\r
(al_dev_open_context_t *)p_open_context;\r
ib_av_handle_t h_av;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_AV ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_AV );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_AV ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AV );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_av )\r
{\r
p_ioctl->out.status = IB_INVALID_AV_HANDLE;\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_AV ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AV );\r
return CL_SUCCESS;\r
}\r
\r
h_av->obj.pfn_destroy( &h_av->obj, NULL );\r
p_ioctl->out.status = IB_SUCCESS;\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_AV ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_AV );\r
return CL_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
uint32_t size;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CQ );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
ib_pfn_event_cb_t pfn_ev;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CQ );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_SUCCESS;\r
}\r
\r
ci_umv_buf_t *p_umv_buf = NULL;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CQ );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_SUCCESS;\r
}\r
\r
ib_cq_handle_t h_cq;\r
cl_waitobj_handle_t h_wait_obj;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CQ );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_cq )\r
{\r
p_ioctl->out.status = IB_INVALID_CQ_HANDLE;\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_SUCCESS;\r
}\r
\r
\r
p_ioctl->out.status = IB_SUCCESS;\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
size_t in_buf_sz;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QP );\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) < sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
in_buf_sz += sizeof(ib_local_ds_t) * p_ioctl->in.num_ds;\r
if( cl_ioctl_in_size( h_ioctl ) != in_buf_sz )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return CL_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
size_t in_buf_sz;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QP );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) < sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
in_buf_sz += sizeof(ib_local_ds_t) * p_ioctl->in.num_ds;\r
if( cl_ioctl_in_size( h_ioctl ) != in_buf_sz )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return CL_SUCCESS;\r
}\r
\r
(al_dev_open_context_t *)p_open_context;\r
ib_cq_handle_t h_cq;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CQ );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
{\r
p_ioctl->out.status = IB_INVALID_CQ_HANDLE;\r
p_ioctl->out.n_cqes = 0;\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_SUCCESS;\r
}\r
\r
\r
deref_al_obj( &h_cq->obj );\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_SUCCESS;\r
}\r
\r
size_t out_buf_sz;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CQ );\r
\r
p_ioctl = (ual_poll_cq_ioctl_t*)cl_ioctl_in_buf( h_ioctl );\r
p_context = (al_dev_open_context_t*)p_open_context;\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) < sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
out_buf_sz += sizeof(ib_wc_t) * (p_ioctl->in.num_wc - 1);\r
if( cl_ioctl_out_size( h_ioctl ) != out_buf_sz )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( p_ioctl->out.num_wc )\r
*p_ret_bytes += (sizeof(ib_wc_t) * (p_ioctl->out.num_wc));\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_SUCCESS;\r
}\r
\r
(al_dev_open_context_t *)p_open_context;\r
ib_cq_handle_t h_cq;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CQ );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_cq )\r
{\r
p_ioctl->out.status = IB_INVALID_CQ_HANDLE;\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_SUCCESS;\r
}\r
\r
\r
deref_al_obj( &h_cq->obj );\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_SUCCESS;\r
}\r
\r
(al_dev_open_context_t *)p_open_context;\r
ib_cq_handle_t h_cq;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_CQ );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_cq )\r
{\r
p_ioctl->out.status = IB_INVALID_CQ_HANDLE;\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_SUCCESS;\r
}\r
\r
\r
deref_al_obj( &h_cq->obj );\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_CQ ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_CQ );\r
return CL_SUCCESS;\r
}\r
\r
ib_mr_handle_t h_mr;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MR ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MR );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MR ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MR ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return CL_SUCCESS;\r
}\r
\r
proxy_query_mr(\r
IN void *p_open_context,\r
IN cl_ioctl_handle_t h_ioctl,\r
- OUT size_t *p_ret_bytes )\r
+ OUT size_t *p_ret_bytes )\r
{\r
ual_query_mr_ioctl_t *p_ioctl =\r
(ual_query_mr_ioctl_t *)cl_ioctl_in_buf( h_ioctl );\r
ib_mr_handle_t h_mr;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MR ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MR );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MR ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MR ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return CL_SUCCESS;\r
}\r
\r
ib_mr_create_t *p_mr_create;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MR ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MR );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MR ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MR ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return CL_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
uint64_t vaddr;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MR ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MR );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MR ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MR ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return CL_SUCCESS;\r
}\r
\r
(al_dev_open_context_t *)p_open_context;\r
ib_mr_handle_t h_mr;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MR ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MR );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MR ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_mr )\r
{\r
p_ioctl->out.status = IB_INVALID_MR_HANDLE;\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MR ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return CL_SUCCESS;\r
}\r
\r
if( p_ioctl->out.status != IB_SUCCESS )\r
deref_al_obj( &h_mr->obj );\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MR ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MR );\r
return CL_SUCCESS;\r
}\r
\r
ci_umv_buf_t *p_umv_buf = NULL;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MW ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MW );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MW ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MW );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MW ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MW );\r
return CL_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
ib_pd_handle_t h_pd;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MW ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MW );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MW ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MW );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MW ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MW );\r
return CL_SUCCESS;\r
}\r
\r
ib_mr_handle_t h_mr;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MW ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MW );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MW ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MW );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MW ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MW );\r
return CL_SUCCESS;\r
}\r
\r
(al_dev_open_context_t *)p_open_context;\r
ib_mw_handle_t h_mw;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MW ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MW );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MW ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MW );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_mw )\r
{\r
p_ioctl->out.status = IB_INVALID_MW_HANDLE;\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MW ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MW );\r
return CL_SUCCESS;\r
}\r
p_ioctl->out.status = destroy_mw( h_mw );\r
if( p_ioctl->out.status != IB_SUCCESS )\r
deref_al_obj( &h_mw->obj );\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MW ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MW );\r
return CL_SUCCESS;\r
}\r
\r
ci_umv_buf_t *p_umv_buf = NULL;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_QP );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_QP ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_QP );\r
return CL_SUCCESS;\r
}\r
\r
ci_umv_buf_t *p_umv_buf = NULL;\r
ib_api_status_t status;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MCAST ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MCAST );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MCAST ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MCAST );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
p_ioctl->out.status = status;\r
*p_ret_bytes = sizeof(p_ioctl->out);\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MCAST ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MCAST );\r
return CL_SUCCESS;\r
}\r
\r
(al_dev_open_context_t *)p_open_context;\r
al_attach_handle_t h_attach;\r
\r
- CL_ENTER( ( AL_DBG_DEV | AL_DBG_MCAST ), g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_MCAST );\r
\r
/* Validate input buffers. */\r
if( !cl_ioctl_in_buf( h_ioctl ) || !cl_ioctl_out_buf( h_ioctl ) ||\r
cl_ioctl_in_size( h_ioctl ) != sizeof(p_ioctl->in) ||\r
cl_ioctl_out_size( h_ioctl ) != sizeof(p_ioctl->out) )\r
{\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MCAST ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MCAST );\r
return CL_INVALID_PARAMETER;\r
}\r
\r
if( !h_attach )\r
{\r
p_ioctl->out.status = IB_INVALID_MCAST_HANDLE;\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MCAST ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MCAST );\r
return CL_SUCCESS;\r
}\r
\r
h_attach->obj.pfn_destroy( &h_attach->obj, ib_sync_destroy );\r
p_ioctl->out.status = IB_SUCCESS;\r
\r
- CL_EXIT( ( AL_DBG_DEV | AL_DBG_MCAST ), g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_MCAST );\r
return CL_SUCCESS;\r
}\r
\r
#include "al_ca.h"\r
#include "al_common.h"\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_sa_req.tmh"\r
+#endif\r
#include "al_mgr.h"\r
#include "al_query.h"\r
#include "ib_common.h"\r
ib_pnp_req_t pnp_req;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SA_REQ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SA_REQ );\r
CL_ASSERT( p_parent_obj );\r
CL_ASSERT( gp_sa_req_mgr == NULL );\r
\r
gp_sa_req_mgr = cl_zalloc( sizeof( sa_req_mgr_t ) );\r
if( gp_sa_req_mgr == NULL )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_zalloc failed\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( status != IB_SUCCESS )\r
{\r
free_sa_req_mgr( &gp_sa_req_mgr->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_spinlock_init failed\n") );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_sa_req_mgr->obj.pfn_destroy( &gp_sa_req_mgr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if (status != IB_SUCCESS)\r
{\r
gp_sa_req_mgr->obj.pfn_destroy( &gp_sa_req_mgr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_reg_pnp failed: %s\n", ib_get_err_str( status ) ) );\r
return status;\r
}\r
* a call to ref_al_obj and deref_al_obj.\r
*/\r
\r
- CL_EXIT( AL_DBG_SA_REQ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SA_REQ );\r
return IB_SUCCESS;\r
}\r
\r
ib_pd_handle_t h_pd;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SA_REQ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SA_REQ );\r
CL_ASSERT( p_pnp_rec );\r
CL_ASSERT( p_pnp_rec->pnp_context == &gp_sa_req_mgr->obj );\r
\r
status = create_sa_req_svc( (ib_pnp_port_rec_t*)p_pnp_rec );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("create_sa_req_svc failed: %s\n", ib_get_err_str(status)) );\r
}\r
break;\r
case IB_PNP_PORT_ACTIVE:\r
case IB_PNP_SM_CHANGE:\r
CL_ASSERT( p_pnp_rec->context );\r
- CL_TRACE( AL_DBG_SA_REQ, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_SA_REQ,\r
("updating SM information\n") );\r
\r
p_sa_req_svc = p_pnp_rec->context;\r
status = ib_query_av( p_sa_req_svc->h_av, &av_attr, &h_pd );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("AV query failed: %s\n", ib_get_err_str(status)) );\r
status = IB_SUCCESS;\r
break;\r
status = ib_modify_av( p_sa_req_svc->h_av, &av_attr );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("modify AV failed: %s\n", ib_get_err_str(status) ) );\r
status = IB_SUCCESS;\r
break;\r
status = IB_SUCCESS;\r
break;\r
}\r
- CL_EXIT( AL_DBG_SA_REQ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SA_REQ );\r
return status;\r
}\r
\r
sa_req_svc_t* p_sa_req_svc;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SA_REQ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SA_REQ );\r
CL_ASSERT( p_pnp_rec );\r
CL_ASSERT( p_pnp_rec->p_ca_attr );\r
CL_ASSERT( p_pnp_rec->p_port_attr );\r
if( status != IB_SUCCESS )\r
{\r
p_sa_req_svc->obj.pfn_destroy( &p_sa_req_svc->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_sa_req_svc->obj.pfn_destroy( &p_sa_req_svc->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_sa_req_svc failed: %s\n", ib_get_err_str(status) ) );\r
return status;\r
}\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &p_sa_req_svc->obj );\r
\r
- CL_EXIT( AL_DBG_SA_REQ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SA_REQ );\r
return IB_SUCCESS;\r
}\r
\r
ib_ca_handle_t h_ca;\r
ib_av_attr_t av_attr;\r
\r
- CL_ENTER( AL_DBG_SA_REQ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SA_REQ );\r
CL_ASSERT( p_sa_req_svc && p_pnp_rec );\r
\r
/* Acquire the correct CI CA for this port. */\r
h_ca = acquire_ca( p_pnp_rec->p_ca_attr->ca_guid );\r
if( !h_ca )\r
{\r
- AL_TRACE_EXIT( AL_DBG_SA_REQ, ("Failed to acquire CA\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_INFORMATION, AL_DBG_SA_REQ, ("Failed to acquire CA\n") );\r
return IB_INVALID_GUID;\r
}\r
p_sa_req_svc->obj.p_ci_ca = h_ca->obj.p_ci_ca;\r
p_sa_req_svc->port_num = p_pnp_rec->p_port_attr->port_num;\r
p_sa_req_svc->sm_lid = p_pnp_rec->p_port_attr->sm_lid;\r
p_sa_req_svc->sm_sl = p_pnp_rec->p_port_attr->sm_sl;\r
- CL_TRACE( AL_DBG_SA_REQ, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_SA_REQ,\r
("using port: 0x%x\tsm lid: 0x%x\tsm sl: 0x%x\n",\r
p_sa_req_svc->port_num, p_sa_req_svc->sm_lid, p_sa_req_svc->sm_sl) );\r
\r
/* Check for failure allocating the QP. */\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("failed to create QP1 alias: %s\n", ib_get_err_str(status) ) );\r
return status;\r
}\r
&p_sa_req_svc->h_mad_svc );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("failed to register MAD service: %s\n", ib_get_err_str(status) ) );\r
return status;\r
}\r
&av_attr, &p_sa_req_svc->h_av );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("failed to create AV: %s\n", ib_get_err_str(status) ) );\r
return status;\r
}\r
\r
- CL_EXIT( AL_DBG_SA_REQ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SA_REQ );\r
return IB_SUCCESS;\r
}\r
\r
ib_sa_mad_t *p_sa_mad;\r
KEVENT event;\r
\r
- CL_ENTER( AL_DBG_SA_REQ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SA_REQ );\r
\r
if( flags & IB_FLAGS_SYNC )\r
{\r
if( !cl_is_blockable() )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Thread context not blockable\n") );\r
return IB_INVALID_SETTING;\r
}\r
p_sa_req->p_sa_req_svc = acquire_sa_req_svc( port_guid );\r
if( !p_sa_req->p_sa_req_svc )\r
{\r
- AL_TRACE_EXIT( AL_DBG_QUERY | AL_DBG_WARN, ("invalid port GUID\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_INFORMATION, AL_DBG_QUERY, ("invalid port GUID\n") );\r
return IB_INVALID_GUID;\r
}\r
\r
KeWaitForSingleObject( &event, Executive, KernelMode, FALSE, NULL );\r
}\r
\r
- CL_EXIT( AL_DBG_SA_REQ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SA_REQ );\r
return status;\r
}\r
\r
sa_req_svc_t *p_sa_req_svc;\r
KEVENT *p_sync_event;\r
\r
- CL_ENTER( AL_DBG_SA_REQ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SA_REQ );\r
\r
UNUSED_PARAM( h_mad_svc );\r
UNUSED_PARAM( mad_svc_context );\r
if( p_request_mad->status != IB_WCS_SUCCESS )\r
{\r
/* Notify the requestor of the result. */\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("request failed - notifying user\n") );\r
\r
p_sa_req = p_request_mad->send_context1;\r
/* Return the MAD. */\r
ib_put_mad( p_request_mad );\r
\r
- CL_EXIT( AL_DBG_SA_REQ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SA_REQ );\r
}\r
\r
\r
ib_sa_mad_t *p_sa_mad;\r
KEVENT *p_sync_event;\r
\r
- CL_ENTER( AL_DBG_SA_REQ, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SA_REQ );\r
\r
UNUSED_PARAM( h_mad_svc );\r
UNUSED_PARAM( mad_svc_context );\r
p_sa_req->status = IB_REMOTE_ERROR;\r
\r
/* Notify the requestor of the result. */\r
- CL_TRACE( AL_DBG_SA_REQ, g_al_dbg_lvl, ("notifying user\n") );\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_SA_REQ, ("notifying user\n") );\r
p_sa_req->pfn_sa_req_cb( p_sa_req, p_mad_response );\r
if( p_sync_event )\r
KeSetEvent( p_sync_event, 0, FALSE );\r
deref_al_obj( &p_sa_req_svc->obj );\r
\r
- CL_EXIT( AL_DBG_SA_REQ, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SA_REQ );\r
}\r
\r
\r
#include "ib_common.h"\r
#include "al_common.h"\r
#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_smi.tmh"\r
+#endif\r
#include "al_verbs.h"\r
#include "al_mgr.h"\r
#include "al_pnp.h"\r
ib_api_status_t status;\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( p_parent_obj );\r
CL_ASSERT( !gp_spl_qp_mgr );\r
gp_spl_qp_mgr = cl_zalloc( sizeof( spl_qp_mgr_t ) );\r
if( !gp_spl_qp_mgr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("IB_INSUFFICIENT_MEMORY\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( status != IB_SUCCESS )\r
{\r
free_spl_qp_mgr( &gp_spl_qp_mgr->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("init_al_obj failed, %s\n", ib_get_err_str( status ) ) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_spl_qp_mgr->obj.pfn_destroy( &gp_spl_qp_mgr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( cl_status != CL_SUCCESS )\r
{\r
gp_spl_qp_mgr->obj.pfn_destroy( &gp_spl_qp_mgr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_timer_init failed, status 0x%x\n", cl_status ) );\r
return ib_convert_cl_status( cl_status );\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_spl_qp_mgr->obj.pfn_destroy( &gp_spl_qp_mgr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_reg_pnp QP0 failed, %s\n", ib_get_err_str( status ) ) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_spl_qp_mgr->obj.pfn_destroy( &gp_spl_qp_mgr->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_reg_pnp QP1 failed, %s\n", ib_get_err_str( status ) ) );\r
return status;\r
}\r
* because we need one on behalf of the ib_reg_pnp call.\r
*/\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return IB_SUCCESS;\r
}\r
\r
IN ib_pnp_rec_t* p_pnp_rec )\r
{\r
ib_api_status_t status;\r
- CL_ENTER( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI_CB );\r
\r
status = spl_qp_agent_pnp( p_pnp_rec, IB_QPT_QP0 );\r
\r
- CL_EXIT( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI_CB );\r
return status;\r
}\r
\r
IN ib_pnp_rec_t* p_pnp_rec )\r
{\r
ib_api_status_t status;\r
- CL_ENTER( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI_CB );\r
\r
status = spl_qp_agent_pnp( p_pnp_rec, IB_QPT_QP1 );\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return status;\r
}\r
\r
ib_api_status_t status;\r
al_obj_t* p_obj;\r
\r
- CL_ENTER( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI_CB );\r
\r
CL_ASSERT( p_pnp_rec );\r
p_obj = p_pnp_rec->context;\r
break;\r
}\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return status;\r
}\r
\r
ib_mad_svc_t mad_svc;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( p_pnp_rec );\r
\r
if( ( qp_type != IB_QPT_QP0 ) && ( qp_type != IB_QPT_QP1 ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
p_spl_qp_svc = cl_zalloc( sizeof( spl_qp_svc_t ) );\r
if( !p_spl_qp_svc )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("IB_INSUFFICIENT_MEMORY\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_spl_qp_svc->obj.pfn_destroy( &p_spl_qp_svc->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( !h_ca )\r
{\r
p_spl_qp_svc->obj.pfn_destroy( &p_spl_qp_svc->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("acquire_ca failed.\n") );\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR, ("acquire_ca failed.\n") );\r
return IB_INVALID_GUID;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
p_spl_qp_svc->obj.pfn_destroy( &p_spl_qp_svc->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_create_cq send CQ failed, %s\n", ib_get_err_str( status ) ) );\r
return status;\r
}\r
if( cq_create.size < p_spl_qp_svc->max_qp_depth )\r
{\r
p_spl_qp_svc->obj.pfn_destroy( &p_spl_qp_svc->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_create_cq allocated insufficient send CQ size\n") );\r
return IB_INSUFFICIENT_RESOURCES;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_spl_qp_svc->obj.pfn_destroy( &p_spl_qp_svc->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_create_cq recv CQ failed, %s\n", ib_get_err_str( status ) ) );\r
return status;\r
}\r
if( cq_create.size < p_spl_qp_svc->max_qp_depth )\r
{\r
p_spl_qp_svc->obj.pfn_destroy( &p_spl_qp_svc->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_create_cq allocated insufficient recv CQ size\n") );\r
return IB_INSUFFICIENT_RESOURCES;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_spl_qp_svc->obj.pfn_destroy( &p_spl_qp_svc->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_get_spl_qp failed, %s\n", ib_get_err_str( status ) ) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_spl_qp_svc->obj.pfn_destroy( &p_spl_qp_svc->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_query_qp failed, %s\n", ib_get_err_str( status ) ) );\r
return status;\r
}\r
( qp_attr.sq_sge < 3 ) || ( qp_attr.rq_sge < 1 ) )\r
{\r
p_spl_qp_svc->obj.pfn_destroy( &p_spl_qp_svc->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_get_spl_qp allocated attributes are insufficient\n") );\r
return IB_INSUFFICIENT_RESOURCES;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_spl_qp_svc->obj.pfn_destroy( &p_spl_qp_svc->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_init_dgrm_svc failed, %s\n", ib_get_err_str( status ) ) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_spl_qp_svc->obj.pfn_destroy( &p_spl_qp_svc->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("spl_qp_svc_post_recvs failed, %s\n",\r
ib_get_err_str( status ) ) );\r
return status;\r
if( status != IB_SUCCESS )\r
{\r
p_spl_qp_svc->obj.pfn_destroy( &p_spl_qp_svc->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("create_mad_disp failed, %s\n", ib_get_err_str( status ) ) );\r
return status;\r
}\r
if (status != IB_SUCCESS)\r
{\r
p_spl_qp_svc->obj.pfn_destroy( &p_spl_qp_svc->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_get_spl_qp alias failed, %s\n",\r
ib_get_err_str( status ) ) );\r
return status;\r
if( status != IB_SUCCESS )\r
{\r
p_spl_qp_svc->obj.pfn_destroy( &p_spl_qp_svc->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("ib_reg_mad_svc failed, %s\n", ib_get_err_str( status ) ) );\r
return status;\r
}\r
if( cl_status != CL_SUCCESS )\r
{\r
p_spl_qp_svc->obj.pfn_destroy( &p_spl_qp_svc->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("cl_timer_start failed, status 0x%x\n", cl_status ) );\r
return ib_convert_cl_status( cl_status );\r
}\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &p_spl_qp_svc->obj );\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return IB_SUCCESS;\r
}\r
\r
\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( p_obj );\r
p_spl_qp_svc = PARENT_STRUCT( p_obj, spl_qp_svc_t, obj );\r
CL_ASSERT( status == IB_SUCCESS );\r
}\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
}\r
\r
\r
al_mad_element_t* p_al_mad;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( p_obj );\r
p_spl_qp_svc = PARENT_STRUCT( p_obj, spl_qp_svc_t, obj );\r
destroy_al_obj( &p_spl_qp_svc->obj );\r
cl_free( p_spl_qp_svc );\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
}\r
\r
\r
{\r
spl_qp_svc_t* p_spl_qp_svc;\r
\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( p_obj );\r
CL_ASSERT( p_pnp_rec );\r
p_spl_qp_svc->base_lid = p_pnp_rec->p_port_attr->lid;\r
p_spl_qp_svc->lmc = p_pnp_rec->p_port_attr->lmc;\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
}\r
\r
\r
mad_route_t route;\r
boolean_t local, loopback, discard;\r
\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( p_spl_qp_svc );\r
CL_ASSERT( p_send_wr );\r
*/\r
if( ( p_smp->hop_count == 0 ) || ( p_smp->hop_ptr == 0 ) )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("hop cnt or hop ptr set to 0...discarding\n") );\r
discard = TRUE;\r
}\r
else if( p_smp->hop_count != ( p_smp->hop_ptr - 1 ) )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("hop cnt != (hop ptr - 1)...discarding\n") );\r
discard = TRUE;\r
}\r
else if( p_smp->hop_count >= IB_SUBNET_PATH_HOPS_MAX )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("hop cnt > max hops...discarding\n") );\r
discard = TRUE;\r
}\r
( p_smp->return_path[ p_smp->hop_ptr - 1 ] !=\r
p_spl_qp_svc->port_num ) )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("return path[hop ptr - 1] != port num...discarding\n") );\r
discard = TRUE;\r
}\r
if( loopback && local ) route = ROUTE_LOOPBACK;\r
if( discard ) route = ROUTE_DISCARD;\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return route;\r
}\r
\r
mad_route_t route;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( h_qp );\r
CL_ASSERT( p_send_wr );\r
*/\r
cl_spinlock_release( &p_spl_qp_svc->obj.lock );\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return IB_RESOURCE_BUSY;\r
}\r
\r
cl_spinlock_release( &p_spl_qp_svc->obj.lock );\r
}\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return status;\r
}\r
\r
ib_smp_t* p_smp;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( p_spl_qp_svc );\r
CL_ASSERT( p_mad_wr );\r
}\r
}\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return status;\r
}\r
\r
status = complete_local_mad( p_spl_qp_svc, p_mad_wr, p_mad_resp );\r
}\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return status;\r
}\r
\r
status = complete_local_mad( p_spl_qp_svc, p_mad_wr, p_mad_resp );\r
}\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return status;\r
}\r
\r
ib_api_status_t status = IB_SUCCESS;\r
boolean_t smp_is_set;\r
\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( p_spl_qp_svc );\r
CL_ASSERT( p_mad_wr );\r
status = get_resp_mad( p_spl_qp_svc, p_mad_wr, &p_mad_response );\r
if( status != IB_SUCCESS )\r
{\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return status;\r
}\r
p_mad_response_buf = p_mad_response->p_mad_buf;\r
\r
__complete_send_mad( p_spl_qp_svc->h_mad_disp, p_mad_wr,\r
IB_WCS_LOCAL_OP_ERR );\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return status;\r
}\r
\r
p_spl_qp_svc->lmc = ib_port_info_get_lmc( p_port_info );\r
if (p_port_info->subnet_timeout & 0x80)\r
{\r
- AL_TRACE(AL_DBG_PNP,\r
+ AL_PRINT( TRACE_LEVEL_INFORMATION, AL_DBG_PNP,\r
("Client reregister event, setting sm_lid to 0.\n"));\r
ci_ca_lock_attr(p_spl_qp_svc->obj.p_ci_ca);\r
p_spl_qp_svc->obj.p_ci_ca->p_pnp_attr->\r
if( status == IB_SUCCESS && !smp_is_set )\r
status = IB_NOT_DONE;\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return status;\r
}\r
\r
spl_qp_svc_t* p_spl_qp_svc;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI_CB );\r
\r
CL_ASSERT( p_item );\r
p_spl_qp_svc = PARENT_STRUCT( p_item, spl_qp_svc_t, send_async );\r
/* No longer in use by the asynchronous processing thread. */\r
cl_atomic_dec( &p_spl_qp_svc->in_use_cnt );\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
}\r
\r
\r
{\r
spl_qp_svc_t* p_spl_qp_svc;\r
\r
- CL_ENTER( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI_CB );\r
\r
CL_ASSERT( cq_context );\r
p_spl_qp_svc = cq_context;\r
\r
#endif\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
}\r
\r
\r
spl_qp_svc_t* p_spl_qp_svc;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI_CB );\r
\r
CL_ASSERT( p_item );\r
p_spl_qp_svc = PARENT_STRUCT( p_item, spl_qp_svc_t, send_async_cb );\r
\r
deref_al_obj( &p_spl_qp_svc->obj );\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
}\r
#endif\r
\r
{\r
spl_qp_svc_t* p_spl_qp_svc;\r
\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( cq_context );\r
p_spl_qp_svc = cq_context;\r
\r
#endif\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
}\r
\r
\r
{\r
spl_qp_svc_t* p_spl_qp_svc;\r
\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( p_item );\r
p_spl_qp_svc = PARENT_STRUCT( p_item, spl_qp_svc_t, recv_async_cb );\r
\r
deref_al_obj( &p_spl_qp_svc->obj );\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
}\r
#endif\r
\r
ib_smp_t* p_smp;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI_CB );\r
\r
CL_ASSERT( p_spl_qp_svc );\r
CL_ASSERT( h_cq );\r
\r
if( wc.status != IB_WCS_SUCCESS )\r
{\r
- CL_TRACE( CL_DBG_ERROR, g_al_dbg_lvl,\r
- ("special QP completion error: %s! internal syndrome 0x%x\n",\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
+ ("special QP completion error: %s! internal syndrome 0x%I64x\n",\r
ib_get_wc_status_str( wc.status ), wc.vendor_specific) );\r
\r
/* Reset the special QP service and return. */\r
CL_ASSERT( status == IB_SUCCESS );\r
\r
cl_atomic_dec( &p_spl_qp_svc->in_use_cnt );\r
- CL_EXIT( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI_CB );\r
}\r
\r
\r
mad_route_t route;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( p_spl_qp_svc );\r
CL_ASSERT( p_mad_element );\r
else\r
status = recv_local_mad( p_spl_qp_svc, p_mad_element );\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return status;\r
}\r
\r
{\r
mad_route_t route;\r
\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( p_mad_element );\r
\r
break;\r
}\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return route;\r
}\r
\r
{\r
mad_route_t route;\r
\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( p_mad_element );\r
\r
break;\r
}\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return route;\r
}\r
\r
{\r
mad_route_t route;\r
\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( p_mad_element );\r
\r
break;\r
}\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return route;\r
}\r
\r
{\r
mad_route_t route;\r
\r
- CL_ENTER( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI );\r
\r
CL_ASSERT( p_mad_element );\r
\r
else\r
route = ROUTE_DISPATCHER;\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return route;\r
}\r
\r
ib_av_attr_t av_attr;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI_CB );\r
\r
CL_ASSERT( p_spl_qp_svc );\r
CL_ASSERT( p_mad_element );\r
* "C14-5: Only a SM shall originate a directed route SMP."\r
* Therefore all traps should be LID routed; drop this one.\r
*/\r
- CL_EXIT( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI_CB );\r
return IB_ERROR;\r
}\r
\r
\r
if( status != IB_SUCCESS )\r
{\r
- CL_EXIT( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI_CB );\r
return status;\r
}\r
\r
if( status != IB_SUCCESS )\r
ib_destroy_av( p_mad_element->h_av );\r
\r
- CL_EXIT( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI_CB );\r
return status;\r
}\r
\r
ib_mad_t* p_mad_hdr;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI_CB );\r
\r
CL_ASSERT( p_spl_qp_svc );\r
CL_ASSERT( p_mad_request );\r
/* Send the locally addressed MAD request to the CA for processing. */\r
status = ib_send_mad( p_spl_qp_svc->h_mad_svc, p_mad_request, NULL );\r
\r
- CL_EXIT( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI_CB );\r
return status;\r
}\r
\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI_CB );\r
\r
UNUSED_PARAM( h_mad_svc );\r
UNUSED_PARAM( mad_svc_context );\r
status = ib_put_mad( p_mad_element );\r
CL_ASSERT( status == IB_SUCCESS );\r
\r
- CL_EXIT( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI_CB );\r
}\r
\r
\r
ib_av_attr_t av_attr;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI_CB );\r
\r
CL_ASSERT( mad_svc_context );\r
CL_ASSERT( p_mad_response );\r
{\r
ib_put_mad( p_mad_response );\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return;\r
}\r
\r
ib_put_mad( p_mad_response );\r
}\r
\r
- CL_EXIT( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI_CB );\r
}\r
\r
\r
\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT( TRACE_LEVEL_ERROR, AL_DBG_ERROR,\r
("Failed to post receive %p\n", p_al_element) );\r
cl_qlist_remove_item( &p_spl_qp_svc->recv_queue,\r
&p_al_element->list_item );\r
{\r
spl_qp_svc_t* p_spl_qp_svc;\r
\r
- CL_ENTER( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI_CB );\r
\r
CL_ASSERT( p_event_rec );\r
CL_ASSERT( p_event_rec->context );\r
\r
if( p_event_rec->code == IB_AE_SQ_DRAINED )\r
{\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
return;\r
}\r
\r
\r
spl_qp_svc_reset( p_spl_qp_svc );\r
\r
- CL_EXIT( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI_CB );\r
}\r
\r
\r
ib_qp_mod_t qp_mod;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI_CB );\r
\r
CL_ASSERT( p_item );\r
p_spl_qp_svc = PARENT_STRUCT( p_item, spl_qp_svc_t, reset_async );\r
/* No longer in use by the asynchronous processing thread. */\r
cl_atomic_dec( &p_spl_qp_svc->in_use_cnt );\r
\r
- CL_EXIT( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI_CB );\r
}\r
\r
\r
force_smi_poll(\r
void )\r
{\r
- CL_ENTER( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI_CB );\r
\r
/*\r
* Stop the poll timer. Just invoke the timer callback directly to\r
*/\r
smi_poll_timer_cb( gp_spl_qp_mgr );\r
\r
- CL_EXIT( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI_CB );\r
}\r
\r
\r
{\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI_CB );\r
\r
CL_ASSERT( context );\r
CL_ASSERT( gp_spl_qp_mgr == context );\r
}\r
cl_spinlock_release( &gp_spl_qp_mgr->obj.lock );\r
\r
- CL_EXIT( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI_CB );\r
}\r
\r
\r
al_obj_t* p_obj;\r
spl_qp_svc_t* p_spl_qp_svc;\r
\r
- CL_ENTER( AL_DBG_SMI_CB, g_al_dbg_lvl );\r
+ AL_ENTER( AL_DBG_SMI_CB );\r
\r
CL_ASSERT( p_list_item );\r
UNUSED_PARAM( context );\r
spl_qp_svc_post_recvs( p_spl_qp_svc );\r
cl_spinlock_release( &p_spl_qp_svc->obj.lock );\r
\r
- CL_EXIT( AL_DBG_SMI, g_al_dbg_lvl );\r
+ AL_EXIT( AL_DBG_SMI );\r
}\r
!else\r
TARGETNAME=ibald\r
!endif\r
+\r
TARGETPATH=..\..\..\bin\user\obj$(BUILD_ALT_DIR)\r
TARGETTYPE=DYNLINK\r
DLLENTRY=DllMain\r
+\r
+\r
+\r
+!if $(FREEBUILD)\r
+ENABLE_EVENT_TRACING=1\r
+#!else\r
+#ENABLE_EVENT_TRACING=1\r
+!endif\r
+\r
+\r
+\r
DLLDEF=$O\al_exports.def\r
USE_NTDLL=1\r
\r
\r
INCLUDES=..;..\..\..\inc;..\..\..\inc\user;\r
\r
-USER_C_FLAGS=$(USER_C_FLAGS) -DEXPORT_AL_SYMBOLS -DCL_NO_TRACK_MEM\r
+USER_C_FLAGS=$(USER_C_FLAGS) -DEXPORT_AL_SYMBOLS -DCL_NO_TRACK_MEM -DWPP_OLDCC\r
\r
TARGETLIBS= \\r
$(SDK_LIB_PATH)\kernel32.lib \\r
+ $(SDK_LIB_PATH)\Advapi32.lib \\r
!if $(FREEBUILD)\r
$(TARGETPATH)\*\complib.lib\r
!else\r
$(TARGETPATH)\*\complibd.lib\r
!endif\r
\r
+!IFDEF ENABLE_EVENT_TRACING\r
+\r
+C_DEFINES = $(C_DEFINES) -DEVENT_TRACING\r
+\r
+RUN_WPP = $(SOURCES) -ext: .c .h .C .H \\r
+ -scan:..\al_debug.h \\r
+ -func:AL_PRINT(LEVEL,FLAGS,(MSG,...)) \\r
+ -func:AL_PRINT_EXIT(LEVEL,FLAGS,(MSG,...)) \\r
+ -dll\r
+!ENDIF\r
+\r
+\r
MSC_WARNING_LEVEL= /W4\r
#include "ib_common.h"\r
#include "al_init.h"\r
\r
+#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_dll.tmh"\r
+#endif\r
+\r
+\r
\r
HANDLE g_al_device = INVALID_HANDLE_VALUE;\r
cl_mutex_t g_open_close_mutex;\r
IN DWORD ul_reason_for_call, \r
IN LPVOID lp_reserved )\r
{\r
- TCHAR dbg_lvl_str[16];\r
+\r
+#if !defined(EVENT_TRACING)\r
+#if DBG \r
+\r
+#define ENV_BUFSIZE 16\r
+\r
+ TCHAR dbg_lvl_str[ENV_BUFSIZE];\r
DWORD i;\r
+#endif\r
+#endif\r
\r
UNUSED_PARAM( lp_reserved );\r
\r
switch( ul_reason_for_call )\r
{\r
case DLL_PROCESS_ATTACH:\r
+\r
+#if defined(EVENT_TRACING)\r
+#if DBG\r
+ WPP_INIT_TRACING(L"ibald.dll");\r
+#else\r
+ WPP_INIT_TRACING(L"ibal.dll");\r
+#endif\r
+#endif \r
cl_perf_init( &g_perf, AlMaxPerf );\r
DisableThreadLibraryCalls( h_module );\r
\r
if( cl_mutex_init( &g_open_close_mutex ) != CL_SUCCESS )\r
return FALSE;\r
\r
- i = GetEnvironmentVariable( "IBAL_UAL_DBG", dbg_lvl_str, 16 );\r
- if( i && i <= 16 )\r
- {\r
- g_al_dbg_lvl = _tcstoul( dbg_lvl_str, NULL, 16 );\r
- AL_TRACE( AL_DBG_DEV,\r
- ("Given IBAL_UAL_DBG debug level:0x%X\n",\r
- g_al_dbg_lvl) );\r
- }\r
+#if !defined(EVENT_TRACING)\r
+#if DBG \r
+\r
+ i = GetEnvironmentVariable( "IBAL_UAL_DBG_LEVEL", dbg_lvl_str, ENV_BUFSIZE );\r
+ if( i && i <= 16 )\r
+ {\r
+ g_al_dbg_level = _tcstoul( dbg_lvl_str, NULL, ENV_BUFSIZE );\r
+ }\r
+\r
+ i = GetEnvironmentVariable( "IBAL_UAL_DBG_FLAGS", dbg_lvl_str, ENV_BUFSIZE );\r
+ if( i && i <= 16 )\r
+ {\r
+ g_al_dbg_flags = _tcstoul( dbg_lvl_str, NULL, ENV_BUFSIZE );\r
+ }\r
+\r
+\r
+ AL_PRINT(TRACE_LEVEL_INFORMATION ,AL_DBG_DEV ,\r
+ ("Given IBAL_UAL_DBG debug level:%d debug flags 0x%x\n",\r
+ g_al_dbg_level ,g_al_dbg_flags) );\r
+\r
+#endif\r
+#endif\r
+\r
break;\r
\r
case DLL_PROCESS_DETACH:\r
cl_mutex_destroy( &g_open_close_mutex );\r
cl_perf_destroy( &g_perf, TRUE );\r
\r
+#if defined(EVENT_TRACING)\r
+ WPP_CLEANUP();\r
+#endif\r
break;\r
}\r
return TRUE;\r
if( cl_status != CL_SUCCESS )\r
{\r
CL_ASSERT( cl_status != CL_PENDING );\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("Error performing IOCTL 0x%08x to AL driver (%s)\n",\r
command, CL_STATUS_MSG(cl_status)) );\r
return CL_ERROR;\r
#include "al.h"\r
#include "al_ci_ca.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "al_mad_pool.tmh"\r
+#endif\r
+\r
#include "al_mad_pool.h"\r
#include "al_pd.h"\r
#include "al_verbs.h"\r
ib_api_status_t status;\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_MAD_POOL);\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !ph_pool )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
__free_pool( &h_pool->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("init_al_obj failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
h_pool->obj.pfn_destroy( &h_pool->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("grow_mad_pool failed with status %s.\n",\r
ib_get_err_str(status)) );\r
return status;\r
status = ib_convert_cl_status( cl_status );\r
h_pool->obj.pfn_destroy( &h_pool->obj, NULL );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("cl_qpool_init failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
status = ib_convert_cl_status( cl_status );\r
h_pool->obj.pfn_destroy( &h_pool->obj, NULL );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("cl_qpool_init failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &h_pool->obj );\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MAD_POOL);\r
return IB_SUCCESS;\r
}\r
\r
ib_pool_handle_t h_pool;\r
ib_al_handle_t h_al;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_MAD_POOL);\r
\r
CL_ASSERT( p_obj );\r
h_pool = PARENT_STRUCT( p_obj, al_pool_t, obj );\r
/* Deregister this MAD pool from all protection domains. */\r
al_dereg_pool( h_al, h_pool );\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MAD_POOL);\r
}\r
\r
\r
al_obj_t* p_obj;\r
boolean_t busy;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_MAD_POOL);\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pool, AL_OBJ_TYPE_H_MAD_POOL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
\r
/* Return an error if the pool is busy. */\r
if( busy )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("h_pool (0x%p) is busy!.\n", h_pool) );\r
return IB_RESOURCE_BUSY;\r
}\r
ref_al_obj( &h_pool->obj );\r
h_pool->obj.pfn_destroy( &h_pool->obj, NULL );\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MAD_POOL);\r
return IB_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
al_key_type_t key_type;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_MAD_POOL);\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pool, AL_OBJ_TYPE_H_MAD_POOL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
/* Alias keys require an alias PD. */\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
if( !pp_pool_key )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
{\r
__free_pool_key( &p_pool_key->obj );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("init_al_obj failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_pool_key->obj.pfn_destroy( &p_pool_key->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
cl_spinlock_release( &h_pool->obj.lock );\r
p_pool_key->obj.pfn_destroy( &p_pool_key->obj, NULL );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("reg_mad_array failed with status %s.\n",\r
ib_get_err_str(status)) );\r
return status;\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &p_pool_key->obj );\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MAD_POOL);\r
return IB_SUCCESS;\r
}\r
\r
status = ib_put_mad( p_mad_element_list );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR , AL_DBG_ERROR ,\r
("ib_put_mad failed with status %s, continuing.\n",\r
ib_get_err_str(status)) );\r
}\r
{\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_MAD_POOL);\r
\r
if( AL_OBJ_INVALID_HANDLE( pool_key, AL_OBJ_TYPE_H_POOL_KEY ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( status != IB_SUCCESS )\r
deref_al_obj( &pool_key->obj );\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MAD_POOL);\r
return status;\r
}\r
\r
IN const ib_pool_key_t pool_key ,\r
IN const al_key_type_t expected_type )\r
{\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_MAD_POOL);\r
\r
if( pool_key->type != expected_type )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
///* Check mad_cnt to see if MADs are still outstanding. */\r
//if( pool_key->mad_cnt )\r
//{\r
- // CL_TRACE_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl, ("IB_RESOURCE_BUSY\n") );\r
+ // AL_PRINT_EXIT( TRACE_LEVEL_ERROR, AL_DBG_MAD_POOL, ("IB_RESOURCE_BUSY\n") );\r
// return IB_RESOURCE_BUSY;\r
//}\r
\r
pool_key->obj.pfn_destroy( &pool_key->obj, NULL );\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MAD_POOL);\r
return IB_SUCCESS;\r
}\r
\r
mad_item_t* p_mad_item;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_MAD_POOL);\r
\r
CL_ASSERT( pool_key );\r
CL_ASSERT( pp_mad_element );\r
status = __grow_mad_pool( h_pool, &p_mad_item );\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("grow_mad_pool failed with status %s.\n",\r
ib_get_err_str(status)) );\r
return status;\r
&p_mad_item->al_mad_element.list_item );\r
cl_spinlock_release( &h_pool->obj.lock );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("init_mad_element failed with status %s.\n",\r
ib_get_err_str(status)) );\r
return status;\r
/* Return the MAD element. */\r
*pp_mad_element = &p_mad_item->al_mad_element;\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MAD_POOL);\r
return IB_SUCCESS;\r
}\r
\r
al_pool_key_t* p_pool_key;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_MAD_POOL);\r
\r
CL_ASSERT( h_pool );\r
\r
{\r
cl_spinlock_release( &h_pool->obj.lock );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("h_pool's (0x%p) maximum has been reached.\n", h_pool) );\r
return IB_INSUFFICIENT_RESOURCES;\r
}\r
{\r
cl_spinlock_release( &h_pool->obj.lock );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("h_pool's (0x%p) will exceed maximum on grow.\n", h_pool) );\r
return IB_INSUFFICIENT_RESOURCES;\r
}\r
cl_spinlock_release( &h_pool->obj.lock );\r
__free_mad_array( &p_mad_array->obj );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("init_al_obj failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &p_mad_array->obj );\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MAD_POOL);\r
return IB_SUCCESS;\r
}\r
\r
cl_list_item_t* p_next_item;\r
mad_reg_t* p_reg;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_MAD_POOL);\r
\r
CL_ASSERT( p_obj );\r
p_mad_array = PARENT_STRUCT( p_obj, mad_array_t, obj );\r
destroy_al_obj( &p_mad_array->obj );\r
cl_free( p_mad_array->p_data );\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MAD_POOL);\r
}\r
\r
\r
al_mad_element_t* p_mad;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_MAD_POOL);\r
\r
if( AL_OBJ_INVALID_HANDLE( pool_key, AL_OBJ_TYPE_H_POOL_KEY ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
if( !buf_size || !pp_mad_element )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
status = __get_mad_element( pool_key, &p_mad );\r
if( status != IB_SUCCESS )\r
{\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MAD_POOL);\r
return status;\r
}\r
\r
if( !p_mad->p_al_mad_buf )\r
{\r
__put_mad_element( p_mad );\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MAD_POOL);\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
p_mad->element.p_mad_buf = p_mad->p_al_mad_buf;\r
/* Return the MAD element to the client. */\r
*pp_mad_element = &p_mad->element;\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MAD_POOL);\r
return IB_SUCCESS;\r
}\r
\r
\r
if( !p_mad_element_list )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
}\r
else\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("MAD has already been returned to MAD pool.\n") );\r
}\r
}\r
#include "al_pd.h"\r
#include "al_av.h"\r
\r
+#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "ual_av.tmh"\r
+#endif\r
+\r
\r
\r
ib_api_status_t\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ioctl_buf.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CREATE_AV IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
return IB_ERROR;\r
}\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ioctl_buf.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_DESTROY_AV IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
else if( ioctl_buf.out.status != IB_SUCCESS )\r
{\r
CL_ASSERT( status == IB_SUCCESS );\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_DESTROY_AV IOCTL status %s\n",\r
ib_get_err_str(ioctl_buf.out.status)) );\r
status = ioctl_buf.out.status;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ioctl_buf.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_MODIFY_AV IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ioctl_buf.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_QUERY_AV IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
#include "al.h"\r
#include "al_ca.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "ual_ca.tmh"\r
+#endif\r
+\r
#include "ual_ca.h"\r
#include "ual_ci_ca.h"\r
\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(al_ioctl.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
return IB_ERROR;\r
}\r
if( !strlen( al_ioctl.out.uvp_lib_name ) )\r
{\r
/* Vendor does not implement user-mode library */\r
- AL_TRACE_EXIT( AL_DBG_WARN | AL_DBG_CA,\r
- ("No vendor lib for CA guid %"PRIx64".\n", ca_guid) );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_WARNING ,AL_DBG_CA ,\r
+ ("No vendor lib for CA guid %I64x.\n", ca_guid) );\r
return IB_UNSUPPORTED;\r
}\r
\r
* The vendor supports a user-mode library\r
* open the library and get the interfaces supported\r
*/\r
- AL_TRACE( AL_DBG_CA,\r
+ AL_PRINT(TRACE_LEVEL_INFORMATION ,AL_DBG_CA ,\r
("Loading vendor lib (%s)\n", al_ioctl.out.uvp_lib_name) );\r
h_lib = al_load_uvp( al_ioctl.out.uvp_lib_name );\r
if (h_lib == NULL)\r
{\r
#if defined( _DEBUG_ )\r
- al_uvp_lib_err( AL_DBG_WARN,\r
+ al_uvp_lib_err( TRACE_LEVEL_WARNING,\r
"!vendor lib (%s) not found for CA guid %"PRIx64".",\r
al_ioctl.out.uvp_lib_name, ca_guid );\r
#endif\r
if( !pfn_uvp_ifc )\r
{\r
#if defined( _DEBUG_ )\r
- al_uvp_lib_err( AL_DBG_ERROR,\r
+ al_uvp_lib_err( TRACE_LEVEL_ERROR,\r
"failed to get vendor lib interface (%s) "\r
"for CA guid %"PRIx64" returned ",\r
al_ioctl.out.uvp_lib_name, ca_guid );\r
if( status != IB_SUCCESS )\r
{\r
CL_ASSERT( status != IB_VERBS_PROCESSING_DONE );\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CA);\r
return status;\r
}\r
}\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ca_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR, ("UAL_OPEN_CA IOCTL returned %s\n",\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("UAL_OPEN_CA IOCTL returned %s\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ca_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CLOSE_CA IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ca_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_QUERY_CA IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ca_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_MODIFY_CA IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
\r
if( AL_OBJ_INVALID_HANDLE( h_ca, AL_OBJ_TYPE_H_CA ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_CA_HANDLE\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("IB_INVALID_CA_HANDLE\n") );\r
return IB_INVALID_CA_HANDLE;\r
}\r
if( !p_ci_op )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(p_ca_ioctl->out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CI_CALL IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
#include "al_pd.h"\r
#include "ib_common.h"\r
\r
+\r
+#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "ual_ci_ca.tmh"\r
+#endif\r
+\r
+\r
extern ib_pool_handle_t gh_mad_pool;\r
extern ib_al_handle_t gh_al;\r
extern cl_async_proc_t *gp_async_proc_mgr;\r
cl_status_t cl_status;\r
al_ci_ca_t *p_ci_ca;\r
\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CA);\r
\r
/* Allocate a new CA structure. */\r
p_ci_ca = (al_ci_ca_t *)cl_zalloc( sizeof( al_ci_ca_t ) );\r
if( p_ci_ca == NULL )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("Failed to cl_malloc al_ci_ca_t\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( cl_status != CL_SUCCESS )\r
{\r
free_ci_ca( &p_ci_ca->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("cl_spinlock_init failed, status = 0x%x.\n",\r
ib_convert_cl_status(cl_status) ) );\r
return ib_convert_cl_status( cl_status );\r
if( cl_status != CL_SUCCESS )\r
{\r
free_ci_ca( &p_ci_ca->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("cl_qpool_init failed, status = 0x%x.\n",\r
ib_convert_cl_status(cl_status) ) );\r
return ib_convert_cl_status( cl_status );\r
if( status != IB_SUCCESS )\r
{\r
free_ci_ca( &p_ci_ca->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("init_al_obj failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_ci_ca->obj.pfn_destroy( &p_ci_ca->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("ib_open_ca failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
* and the associated destroy/cleanup in the AL's\r
* object model\r
*/\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("ual_open_ca failed, status = 0x%x.\n", status) );\r
return IB_ERROR;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_ci_ca->obj.pfn_destroy( &p_ci_ca->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("ib_alloc_pd failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_ci_ca->obj.pfn_destroy( &p_ci_ca->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("ual_allocate_pd returned %s\n", ib_get_err_str( status )) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_ci_ca->obj.pfn_destroy( &p_ci_ca->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("ib_alloc_pd failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_ci_ca->obj.pfn_destroy( &p_ci_ca->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("get_port_info failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_ci_ca->obj.pfn_destroy( &p_ci_ca->obj, NULL );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("ib_reg_mad_pool failed, status = 0x%x.\n", status) );\r
return status;\r
}\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &p_ci_ca->obj );\r
\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CA);\r
return IB_SUCCESS;\r
}\r
\r
{\r
al_ci_ca_t *p_ci_ca;\r
\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CA);\r
CL_ASSERT( p_obj );\r
p_ci_ca = PARENT_STRUCT( p_obj, al_ci_ca_t, obj );\r
\r
if( p_ci_ca->h_ca )\r
cl_async_proc_queue( gp_async_pnp_mgr, &p_ci_ca->dereg_async_item );\r
\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CA);\r
}\r
\r
\r
ib_api_status_t status;\r
al_ci_ca_t *p_ci_ca;\r
\r
- CL_ENTER( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CA);\r
\r
CL_ASSERT( p_obj );\r
p_ci_ca = PARENT_STRUCT( p_obj, al_ci_ca_t, obj );\r
\r
close_vendor_lib( &p_ci_ca->verbs );\r
\r
- CL_EXIT( AL_DBG_CA, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CA);\r
}\r
#include "al.h"\r
#include "al_cm_shared.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "ual_cm.tmh"\r
+#endif\r
+\r
#include "al_dev.h"\r
#include "al_qp.h"\r
#include "ib_common.h"\r
/* Validate input parameters. */\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Invalid AL handle.\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("Invalid AL handle.\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !p_cm_listen || !ph_cm_listen )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("NULL parameter.\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("NULL parameter.\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
h_listen = __get_listen( h_al );\r
if( !h_listen )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("Failed to allocate listen structure.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( !p_cm_ioctl )\r
{\r
h_listen->obj.pfn_destroy( &h_listen->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Failed to allocate IOCTL buffer.\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("Failed to allocate IOCTL buffer.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(p_cm_ioctl->out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CM_LISTEN IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("Failed to listen: %s.\n", ib_get_err_str(status) ) );\r
h_listen->obj.pfn_destroy( &h_listen->obj, NULL );\r
}\r
\r
if( AL_OBJ_INVALID_HANDLE( h_cm_listen, AL_OBJ_TYPE_H_LISTEN ) )\r
{\r
- AL_TRACE( AL_DBG_ERROR, ("Invalid listen handle.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid listen handle.\n") );\r
return IB_INVALID_HANDLE;\r
}\r
\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(cm_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CM_CANCEL IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
}\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("Failed to cancel: %s.\n", ib_get_err_str(status) ) );\r
deref_al_obj( &h_cm_listen->obj );\r
}\r
/* Validate input parameters. */\r
if( !p_cm_req || !p_cm_req->p_primary_path )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("NULL p_cm_req or primary path\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
p_cm_ioctl = (ual_cm_req_ioctl_t*)cl_zalloc( ioctl_buf_sz );\r
if( !p_cm_ioctl )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("Failed to allocate IOCTL buf.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( AL_OBJ_INVALID_HANDLE( p_cm_req->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
(p_cm_req->h_qp->type != p_cm_req->qp_type) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("IB_INVALID_QP_HANDLE\n") );\r
status = IB_INVALID_QP_HANDLE;\r
goto cleanup;\r
p_cm_req->h_qp->obj.p_parent_obj->p_parent_obj->p_parent_obj );\r
if( !h_conn )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR , AL_DBG_ERROR ,\r
("Failed to allocate connection structure.\n") );\r
status = IB_INSUFFICIENT_MEMORY;\r
goto cleanup;\r
if( status != IB_SUCCESS )\r
{\r
h_conn->obj.pfn_destroy( &h_conn->obj, NULL );\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("cm_init_qp returned %s\n", ib_get_err_str(status)) );\r
goto cleanup;\r
}\r
case IB_QPT_UNRELIABLE_DGRM:\r
if( AL_OBJ_INVALID_HANDLE( p_cm_req->h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("IB_INVALID_AL_HANDLE\n") );\r
status = IB_INVALID_AL_HANDLE;\r
goto cleanup;\r
h_conn = __get_conn( p_cm_req->h_al );\r
if( !h_conn )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR , AL_DBG_ERROR ,\r
("Failed to allocate connection structure.\n") );\r
status = IB_INSUFFICIENT_MEMORY;\r
goto cleanup;\r
break;\r
\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid qp_type.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid qp_type.\n") );\r
status = IB_INVALID_SETTING;\r
goto cleanup;\r
}\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(p_cm_ioctl->out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CM_REQ IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("Connection request ioctl failed with status (%s)\n",\r
ib_get_err_str(status) ) );\r
h_conn->obj.pfn_destroy( &h_conn->obj, NULL );\r
ib_port_attr_t *p_port_attr;\r
ib_qp_handle_t h_qp;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
__bind_qp_and_conn( h_conn, p_cm_rep->h_qp );\r
h_qp = p_cm_rep->h_qp;\r
if( !p_port_attr )\r
{\r
ci_ca_unlock_attr( h_qp->obj.p_ci_ca );\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl, ("invalid p_gid\n" ) );\r
+ AL_PRINT(TRACE_LEVEL_ERROR , AL_DBG_ERROR , ("invalid p_gid\n" ) );\r
return IB_INVALID_GID;\r
}\r
\r
&h_conn->p_conn_req->qp_mod_rts );\r
ci_ca_unlock_attr( h_qp->obj.p_ci_ca );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
return IB_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
/* Validate input parameters. */\r
h_conn = h_cm_req;\r
if( AL_OBJ_INVALID_HANDLE( h_conn, AL_OBJ_TYPE_H_CONN ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid REQ handle.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid REQ handle.\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !p_cm_rep )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("NULL p_cm_rep\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("NULL p_cm_rep\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
p_cm_ioctl = (ual_cm_rep_ioctl_t*)cl_zalloc( ioctl_buf_sz );\r
if( !p_cm_ioctl )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Failed to allocate IOCTL buffer.\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("Failed to allocate IOCTL buffer.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
if( AL_OBJ_INVALID_HANDLE( p_cm_rep->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
p_cm_rep->h_qp->type != p_cm_rep->qp_type )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("Invalid QP handle.\n") );\r
status = IB_INVALID_QP_HANDLE;\r
goto cleanup;\r
if( status != IB_SUCCESS )\r
{\r
__ual_conn_reject( h_conn, IB_REJ_INSUF_QP );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("__save_user_rep returned %s\n", ib_get_err_str(status) ) );\r
goto cleanup;\r
}\r
if( status != IB_SUCCESS )\r
{\r
__ual_conn_reject( h_conn, IB_REJ_INSUF_QP );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("cm_init_qp returned %s\n", ib_get_err_str(status) ) );\r
goto cleanup;\r
}\r
if( status != IB_SUCCESS )\r
{\r
__ual_conn_reject( h_conn, IB_REJ_INSUF_QP );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("ib_post_recv returned %s.\n", ib_get_err_str(status)) );\r
goto cleanup;\r
}\r
if( status != IB_SUCCESS )\r
{\r
__ual_conn_reject( h_conn, IB_REJ_INSUF_QP );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("cm_rts_qp with status (%s)\n", ib_get_err_str(status) ) );\r
goto cleanup;\r
}\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(p_cm_ioctl->out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CM_REP IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR , AL_DBG_ERROR ,\r
("Connection reply ioctl failed with status (%s)\n",\r
ib_get_err_str(status) ) );\r
cm_reset_qp( h_conn->h_qp, 0 );\r
ib_api_status_t status;\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
/* Validate input parameters. */\r
h_conn = h_cm_rep;\r
if( AL_OBJ_INVALID_HANDLE( h_conn, AL_OBJ_TYPE_H_CONN ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid rep handle.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid rep handle.\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !p_cm_rtu )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("NULL p_cm_rtu\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("NULL p_cm_rtu\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
__ual_conn_reject( h_conn, IB_REJ_INSUF_QP );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("cm_rts_qp with status (%s)\n", ib_get_err_str(status) ) );\r
return status;\r
}\r
p_cm_ioctl = (ual_cm_rtu_ioctl_t*)cl_zalloc( ioctl_buf_sz );\r
if( !p_cm_ioctl )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Failed to allocate IOCTL buffer\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("Failed to allocate IOCTL buffer\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(p_cm_ioctl->out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CM_RTU IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
\r
if( IB_SUCCESS != status )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("IOCTL status %s.\n", ib_get_err_str(status)) );\r
ref_al_obj( &h_conn->obj );\r
h_conn->obj.pfn_destroy( &h_conn->obj, NULL );\r
h_conn = h_cm_req;\r
if( AL_OBJ_INVALID_HANDLE( h_conn, AL_OBJ_TYPE_H_CONN ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Invalid REQ handle.\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("Invalid REQ handle.\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !svc_id )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("0 svc_id\n" ) );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("0 svc_id\n" ) );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(cm_ioctl.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CM_HANDOFF IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
return IB_ERROR;\r
}\r
else if( cm_ioctl.out.status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("IOCTL status %s\n", ib_get_err_str(cm_ioctl.out.status)) );\r
}\r
\r
ib_api_status_t status;\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
/* Validate input parameters. */\r
h_conn = h_cm;\r
if( AL_OBJ_INVALID_HANDLE( h_conn, AL_OBJ_TYPE_H_CONN ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid REJ handle.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid REJ handle.\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !p_cm_rej )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("NULL p_cm_rej\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("NULL p_cm_rej\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
p_cm_ioctl = (ual_cm_rej_ioctl_t*)cl_zalloc( ioctl_buf_sz );\r
if( !p_cm_ioctl )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("Failed to allocate IOCTL buffer.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(p_cm_ioctl->out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CM_REJ IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
}\r
else\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("IOCTL status %s.\n", ib_get_err_str(status)) );\r
}\r
\r
ib_api_status_t status;\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
/* Validate input parameters. */\r
h_conn = h_cm;\r
if( AL_OBJ_INVALID_HANDLE( h_conn, AL_OBJ_TYPE_H_CONN ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid CM handle.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid CM handle.\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !p_cm_mra )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("NULL p_cm_mra\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("NULL p_cm_mra\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
p_cm_ioctl = (ual_cm_mra_ioctl_t*)cl_zalloc( ioctl_buf_sz );\r
if( !p_cm_ioctl )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("Failed to allocate IOCTL buffer\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(p_cm_ioctl->out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CM_MRA IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
status = p_cm_ioctl->out.status;\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("IOCTL status %s.\n", ib_get_err_str(status)) );\r
}\r
}\r
\r
cl_free( p_cm_ioctl );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
return status;\r
}\r
\r
ib_api_status_t status;\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
/* Validate input parameters. */\r
if( !p_cm_lap || !p_cm_lap->p_alt_path )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("NULL p_cm_lap\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("NULL p_cm_lap\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
p_cm_ioctl = (ual_cm_lap_ioctl_t*)cl_zalloc( ioctl_buf_sz );\r
if( !p_cm_ioctl )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Failed to allocate IOCTL buffer.\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("Failed to allocate IOCTL buffer.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
if( AL_OBJ_INVALID_HANDLE( p_cm_lap->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
(p_cm_lap->h_qp->type != p_cm_lap->qp_type) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("IB_INVALID_QP_HANDLE\n") );\r
status = IB_INVALID_QP_HANDLE;\r
goto cleanup;\r
break;\r
\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid qp_type.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid qp_type.\n") );\r
status = IB_INVALID_SETTING;\r
goto cleanup;\r
}\r
\r
if( AL_OBJ_INVALID_HANDLE( h_conn, AL_OBJ_TYPE_H_CONN ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("No connection info!\n") );\r
status = IB_INVALID_SETTING;\r
goto cleanup;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(p_cm_ioctl->out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CM_LAP IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
status = p_cm_ioctl->out.status;\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("IOCTL status %s.\n", ib_get_err_str(status)) );\r
}\r
}\r
\r
cleanup:\r
cl_free( p_cm_ioctl );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
return status;\r
}\r
\r
ib_api_status_t status;\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
/* Clear the apm_ioctl */\r
cl_memclr( &cm_ioctl, sizeof( cm_ioctl ) );\r
/* Replace the handles with kernel handles appropriately */\r
if( AL_OBJ_INVALID_HANDLE( h_qp, AL_OBJ_TYPE_H_QP ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid QP handle.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid QP handle.\n") );\r
return IB_INVALID_QP_HANDLE;\r
}\r
\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(cm_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CM_FORCE_APM IOCTL returned %s\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
status = cm_ioctl.out.status;\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("IOCTL status %s.\n", ib_get_err_str(status)) );\r
}\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
return status;\r
}\r
\r
cl_status_t cl_status;\r
uint8_t *p_buf;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
/* Validate input parameters. */\r
h_conn = h_cm_lap;\r
if( AL_OBJ_INVALID_HANDLE( h_conn, AL_OBJ_TYPE_H_CONN ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid lap handle.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid lap handle.\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !p_cm_apr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("NULL p_cm_apr\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("NULL p_cm_apr\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
p_cm_ioctl = (ual_cm_apr_ioctl_t*)cl_zalloc( ioctl_buf_sz );\r
if( !p_cm_ioctl )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Failed to allocate IOCTL buffer.\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("Failed to allocate IOCTL buffer.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
if( AL_OBJ_INVALID_HANDLE( p_cm_apr->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
(p_cm_apr->h_qp->type != p_cm_apr->qp_type) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("IB_INVALID_QP_HANDLE\n") );\r
status = IB_INVALID_QP_HANDLE;\r
goto cleanup;\r
break;\r
\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid qp_type.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid qp_type.\n") );\r
status = IB_INVALID_SETTING;\r
goto cleanup;\r
}\r
\r
if( AL_OBJ_INVALID_HANDLE( h_conn, AL_OBJ_TYPE_H_CONN ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("No connection info!\n") );\r
status = IB_INVALID_SETTING;\r
goto cleanup;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(p_cm_ioctl->out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CM_APR IOCTL returned %s.\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
status = p_cm_ioctl->out.status;\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("IOCTL status %s.\n", ib_get_err_str(status)) );\r
}\r
}\r
\r
cleanup:\r
cl_free( p_cm_ioctl );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
return IB_SUCCESS;\r
}\r
\r
ib_api_status_t status;\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
/* Validate input parameters. */\r
if( !p_cm_dreq )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("NULL p_cm_dreq\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("NULL p_cm_dreq\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
p_cm_ioctl = (ual_cm_dreq_ioctl_t*)cl_zalloc( ioctl_buf_sz );\r
if( !p_cm_ioctl )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Failed to allocate IOCTL buffer.\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("Failed to allocate IOCTL buffer.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
if( AL_OBJ_INVALID_HANDLE( p_cm_dreq->h_qp, AL_OBJ_TYPE_H_QP ) ||\r
(p_cm_dreq->h_qp->type != p_cm_dreq->qp_type) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("IB_INVALID_QP_HANDLE\n") );\r
status = IB_INVALID_QP_HANDLE;\r
goto cleanup;\r
break;\r
\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid qp_type.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid qp_type.\n") );\r
status = IB_INVALID_SETTING;\r
goto cleanup;\r
}\r
\r
if( AL_OBJ_INVALID_HANDLE( h_conn, AL_OBJ_TYPE_H_CONN ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("No connection info!\n") );\r
status = IB_INVALID_SETTING;\r
goto cleanup;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(p_cm_ioctl->out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CM_DREQ IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
if( IB_SUCCESS != status )\r
{\r
/* We can fail if we just received a DREQ, which is not an error. */\r
- AL_TRACE( AL_DBG_CM,\r
+ AL_PRINT(TRACE_LEVEL_INFORMATION ,AL_DBG_CM ,\r
("IOCTL status %s\n", ib_get_err_str(status)) );\r
}\r
}\r
\r
cleanup:\r
cl_free( p_cm_ioctl );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
return status;\r
}\r
\r
ib_api_status_t status;\r
cl_status_t cl_status;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
/* Validate input parameters. */\r
h_conn = h_cm_dreq;\r
if( AL_OBJ_INVALID_HANDLE( h_conn, AL_OBJ_TYPE_H_CONN ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid DREP handle.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid DREP handle.\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !p_cm_drep )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("NULL p_cm_drep\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("NULL p_cm_drep\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
p_cm_ioctl = (ual_cm_drep_ioctl_t*)cl_zalloc( ioctl_buf_sz );\r
if( !p_cm_ioctl )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("Failed to allocate IOCTL buffer.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(p_cm_ioctl->out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CM_DREP IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
}\r
else\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("IOCTL status %s\n", ib_get_err_str(status)) );\r
\r
/* Release the reference taken when processing the callback. */\r
}\r
\r
cl_free( p_cm_ioctl );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
return status;\r
}\r
\r
{\r
ib_listen_handle_t h_listen;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
/* Get the listen object. */\r
h_listen = p_listen_err_rec->listen_context;\r
ref_al_obj( &h_listen->obj );\r
h_listen->obj.pfn_destroy( &h_listen->obj, NULL );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
}\r
\r
\r
ib_cm_handle_t h_conn;\r
ib_qp_handle_t h_qp;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
if( p_cm_req_rec->h_cm_listen )\r
{\r
h_conn = __get_conn( (ib_al_handle_t)h_listen->obj.p_parent_obj );\r
if( !h_conn )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("__get_conn failed.\n") );\r
__rej_conn( p_cm_req_rec->h_cm_req, IB_REJ_INSUF_RESOURCES );\r
return;\r
/* Invoke the user's callback. */\r
h_conn->p_conn_req->pfn_cm_req_cb( p_cm_req_rec );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
}\r
\r
\r
ib_cm_handle_t h_conn;\r
ib_qp_handle_t h_qp;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
/* Get the user's context. */\r
switch( p_cm_rep_rec->qp_type )\r
break;\r
\r
default:\r
- CL_TRACE( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid qp_type.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR , AL_DBG_ERROR , ("Invalid qp_type.\n") );\r
break;\r
}\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
}\r
\r
\r
ib_qp_handle_t h_qp;\r
ib_pfn_cm_rtu_cb_t pfn_cm_rtu_cb;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
h_qp = (ib_qp_handle_t)p_cm_rtu_rec->qp_context;\r
p_cm_rtu_rec->qp_context = h_qp->obj.context;\r
/* Invoke the user's callback. */\r
pfn_cm_rtu_cb( p_cm_rtu_rec );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
}\r
\r
\r
ib_qp_handle_t h_qp;\r
ib_pfn_cm_rej_cb_t pfn_cm_rej_cb;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
h_qp = (ib_qp_handle_t)p_cm_rej_rec->qp_context;\r
p_cm_rej_rec->qp_context = h_qp->obj.context;\r
if( pfn_cm_rej_cb )\r
pfn_cm_rej_cb( p_cm_rej_rec );\r
}\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
}\r
\r
\r
ib_cm_handle_t h_conn;\r
ib_qp_handle_t h_qp;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
/* Convert the user's handles. */\r
switch( p_cm_mra_rec->qp_type )\r
break;\r
\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid qp_type.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid qp_type.\n") );\r
return;\r
}\r
\r
/* Call the application callback */\r
h_conn->pfn_cm_mra_cb( p_cm_mra_rec );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
}\r
\r
\r
ib_cm_handle_t h_conn;\r
ib_qp_handle_t h_qp;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
/* Convert the user's handles. */\r
switch( p_cm_lap_rec->qp_type )\r
break;\r
\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid qp_type.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid qp_type.\n") );\r
return;\r
}\r
\r
/* Call the application callback */\r
h_conn->pfn_cm_lap_cb( p_cm_lap_rec );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
}\r
\r
\r
ib_cm_handle_t h_conn;\r
ib_qp_handle_t h_qp;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
/* Convert the user's handles. */\r
switch( p_cm_apr_rec->qp_type )\r
break;\r
\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid qp_type.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid qp_type.\n") );\r
return;\r
}\r
\r
/* Call the application callback */\r
h_conn->pfn_cm_apr_cb( p_cm_apr_rec );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
}\r
\r
\r
ib_cm_handle_t h_conn;\r
ib_qp_handle_t h_qp;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
/* Convert the user's handles. */\r
switch( p_cm_dreq_rec->qp_type )\r
break;\r
\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid qp_type.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid qp_type.\n") );\r
return;\r
}\r
\r
\r
/* Call the application callback */\r
h_conn->pfn_cm_dreq_cb( p_cm_dreq_rec );\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
}\r
\r
\r
ib_qp_handle_t h_qp;\r
ib_pfn_cm_drep_cb_t pfn_cm_drep_cb;\r
\r
- CL_ENTER( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_CM);\r
\r
/* Convert the user's handles. */\r
switch( p_cm_drep_rec->qp_type )\r
break;\r
\r
default:\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("Invalid qp_type.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Invalid qp_type.\n") );\r
return;\r
}\r
\r
/* Invoke the user's callback. */\r
pfn_cm_drep_cb( p_cm_drep_rec );\r
\r
- CL_EXIT( AL_DBG_CM, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_CM);\r
}\r
#include "al_cm_conn.h"\r
#include "al_cm_sidr.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "ual_cm_cep.tmh"\r
+#endif\r
+\r
#include "ib_common.h"\r
#include "al_mgr.h"\r
//#include "al_ca.h"\r
gp_cep_mgr = (ual_cep_mgr_t*)cl_zalloc( sizeof(ual_cep_mgr_t) );\r
if( !gp_cep_mgr )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("Failed allocation of global CEP manager.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( status != IB_SUCCESS )\r
{\r
__free_cep_mgr( &gp_cep_mgr->obj );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("init_al_obj failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_cep_mgr->obj.pfn_destroy( &gp_cep_mgr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( cl_status != CL_SUCCESS )\r
{\r
gp_cep_mgr->obj.pfn_destroy( &gp_cep_mgr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("cl_vector_init failed with status %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
return ib_convert_cl_status( cl_status );\r
if( gp_cep_mgr->h_file == INVALID_HANDLE_VALUE )\r
{\r
gp_cep_mgr->obj.pfn_destroy( &gp_cep_mgr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("ual_create_async_file for UAL_BIND_CM returned %d.\n",\r
GetLastError()) );\r
return IB_ERROR;\r
p_cep = cl_zalloc( sizeof(ucep_t) );\r
if( !p_cep )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("Failed to allocate ucep_t\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("Failed to allocate ucep_t\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
bytes_ret != sizeof(ioctl) )\r
{\r
__destroy_ucep( p_cep );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CREATE_CEP IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
if( ioctl.status != IB_SUCCESS )\r
{\r
__destroy_ucep( p_cep );\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("UAL_CREATE_CEP IOCTL returned %s\n",\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("UAL_CREATE_CEP IOCTL returned %s\n",\r
ib_get_err_str( ioctl.status )) );\r
return ioctl.status;\r
}\r
NULL, 0, NULL, &p_cep->ov ) ||\r
GetLastError() != ERROR_IO_PENDING )\r
{\r
- AL_TRACE( AL_DBG_ERROR, ("Failed to issue CEP poll IOCTL.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("Failed to issue CEP poll IOCTL.\n") );\r
cl_spinlock_acquire( &gp_cep_mgr->obj.lock );\r
cl_ptr_vector_set( &gp_cep_mgr->cep_vector, p_cep->cid, NULL );\r
cl_spinlock_release( &gp_cep_mgr->obj.lock );\r
{\r
if( p_listen_info->cmp_len > IB_REQ_PDATA_SIZE )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("Listen compare data larger than REQ private data.\n") );\r
return IB_INVALID_SETTING;\r
}\r
sizeof(ioctl), &status, sizeof(status), &bytes_ret, NULL ) ||\r
bytes_ret != sizeof(status) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("ual_cep_listen IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
{\r
if( p_cm_req->req_length > IB_REQ_PDATA_SIZE )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("private data larger than REQ private data.\n") );\r
return IB_INVALID_SETTING;\r
}\r
{\r
if( p_cm_req->compare_length > IB_REQ_PDATA_SIZE )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("REQ compare data larger than REQ private data.\n") );\r
return IB_INVALID_SETTING;\r
}\r
sizeof(ioctl.in), &ioctl, sizeof(ioctl.out), &bytes_ret, NULL ) ||\r
bytes_ret != sizeof(ioctl.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CEP_PRE_REQ IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
sizeof(cid), &status, sizeof(status), &bytes_ret, NULL ) ||\r
bytes_ret != sizeof(status) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CEP_SEND_REQ IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
{\r
if( p_cm_rep->rep_length > IB_REP_PDATA_SIZE )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("private data larger than REP private data.\n") );\r
return IB_INVALID_SETTING;\r
}\r
sizeof(ioctl.in), &ioctl, sizeof(ioctl.out), &bytes_ret, NULL ) ||\r
bytes_ret != sizeof(ioctl.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CEP_PRE_REQ IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
sizeof(cid), &status, sizeof(status), &bytes_ret, NULL ) ||\r
bytes_ret != sizeof(status) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CEP_SEND_REP IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
sizeof(cid), &ioctl, sizeof(ioctl), &bytes_ret, NULL ) ||\r
bytes_ret != sizeof(ioctl) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CEP_GET_RTR IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
sizeof(cid), &ioctl, sizeof(ioctl), &bytes_ret, NULL ) ||\r
bytes_ret != sizeof(ioctl) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CEP_GET_RTS IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
{\r
if( pdata_len > IB_RTU_PDATA_SIZE )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("private data larger than RTU private data.\n") );\r
return IB_INVALID_SETTING;\r
}\r
sizeof(ioctl), &status, sizeof(status), &bytes_ret, NULL ) ||\r
bytes_ret != sizeof(status) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CEP_RTU IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
{\r
if( ari_len > IB_ARI_SIZE )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("private data larger than REJ ARI data.\n") );\r
return IB_INVALID_SETTING;\r
}\r
{\r
if( pdata_len > IB_REJ_PDATA_SIZE )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("private data larger than REJ private data.\n") );\r
return IB_INVALID_SETTING;\r
}\r
sizeof(ioctl), &status, sizeof(status), &bytes_ret, NULL ) ||\r
bytes_ret != sizeof(status) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CEP_PRE_REQ IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
{\r
if( p_cm_mra->mra_length > IB_MRA_PDATA_SIZE )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("private data larger than MRA private data.\n") );\r
return IB_INVALID_SETTING;\r
}\r
sizeof(ioctl), &status, sizeof(status), &bytes_ret, NULL ) ||\r
bytes_ret != sizeof(status) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CEP_MRA IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
{\r
if( p_cm_lap->lap_length > IB_LAP_PDATA_SIZE )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("private data larger than LAP private data.\n") );\r
return IB_INVALID_SETTING;\r
}\r
sizeof(ioctl), &status, sizeof(status), &bytes_ret, NULL ) ||\r
bytes_ret != sizeof(status) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CEP_LAP IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
{\r
if( p_cm_apr->info_length > IB_APR_INFO_SIZE )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("private data larger than APR info data.\n") );\r
return IB_INVALID_SETTING;\r
}\r
{\r
if( p_cm_apr->apr_length > IB_REJ_PDATA_SIZE )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("private data larger than APR private data.\n") );\r
return IB_INVALID_SETTING;\r
}\r
sizeof(ioctl.in), &ioctl.out, sizeof(ioctl.out), &bytes_ret, NULL ) ||\r
bytes_ret != sizeof(ioctl.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CEP_PRE_REQ IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
sizeof(cid), &status, sizeof(status), &bytes_ret, NULL ) ||\r
bytes_ret != sizeof(status) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CEP_SEND_APR IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
{\r
if( pdata_len > IB_DREQ_PDATA_SIZE )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("private data larger than DREQ private data.\n") );\r
return IB_INVALID_SETTING;\r
}\r
sizeof(ioctl), &status, sizeof(status), &bytes_ret, NULL ) ||\r
bytes_ret != sizeof(status) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CEP_DREQ IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
{\r
if( p_cm_drep->drep_length > IB_DREP_PDATA_SIZE )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("private data larger than DREP private data.\n") );\r
return IB_INVALID_SETTING;\r
}\r
sizeof(ioctl), &status, sizeof(status), &bytes_ret, NULL ) ||\r
bytes_ret != sizeof(status) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CEP_DREP IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
&ioctl, sizeof(ioctl), &bytes_ret, NULL ) ||\r
bytes_ret != sizeof(ioctl) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CEP_DREP IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
status = ib_get_mad( g_pool_key, MAD_BLOCK_SIZE, &p_mad );\r
if( status != IB_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("ib_get_mad returned %s.\n", ib_get_err_str( status )) );\r
return status;\r
}\r
bytes_ret != sizeof(ioctl) )\r
{\r
ib_put_mad( p_mad );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CEP_GET_RTS IOCTL failed with %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
else if( GetLastError() != ERROR_INVALID_PARAMETER )\r
{\r
/* We can get ERROR_INVALID_PARAMETER if the CEP was destroyed. */\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("DeviceIoControl for CEP callback request returned %d.\n",\r
GetLastError()) );\r
}\r
}\r
else\r
{\r
- AL_TRACE( AL_DBG_WARN,\r
+ AL_PRINT(TRACE_LEVEL_WARNING ,AL_DBG_CM ,\r
("UAL_CEP_GET_EVENT IOCTL returned %d.\n", error_code) );\r
}\r
\r
#include "al_ci_ca.h"\r
#include "al_cq.h"\r
\r
+#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "ual_cq.tmh"\r
+#endif\r
\r
\r
ib_api_status_t\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(cq_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CREATE_CQ IOCTL returned %s.\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(cq_ioctl.out ) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_DESTROY_CQ IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(cq_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_MODIFY_CQ IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(cq_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_QUERY_CQ IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(cq_ioctl.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_PEEK_CQ IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
return IB_ERROR;\r
sizeof(ib_wc_t) + (sizeof(ib_wc_t) * p_cq_ioctl->out.num_wc))) )\r
{\r
cl_free( p_cq_ioctl );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_POLL_CQ IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
return IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(cq_ioctl.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_REARM_CQ IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
return IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(cq_ioctl.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_REARM_N_CQ IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
return IB_ERROR;\r
#include "al_av.h"\r
#include "al_common.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "ual_mad.tmh"\r
+#endif\r
+\r
#include "al_dev.h"\r
#include "al_qp.h"\r
#include "al_pd.h"\r
{\r
ib_mad_svc_handle_t h_mad_svc;\r
\r
- CL_ENTER( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_MAD_SVC);\r
CL_ASSERT( p_obj );\r
h_mad_svc = PARENT_STRUCT( p_obj, al_mad_svc_t, obj );\r
\r
/* Deregister the MAD service. */\r
ual_dereg_mad_svc( h_mad_svc );\r
\r
- CL_EXIT( AL_DBG_MAD_SVC, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MAD_SVC);\r
}\r
\r
\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ioctl_buf.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_REG_MAD_SVC IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
cl_status_t cl_status;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MAD, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_MAD);\r
\r
cl_memclr( &ioctl_buf, sizeof(ioctl_buf) );\r
\r
\r
if( status != IB_SUCCESS )\r
{\r
- CL_PRINT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("Error deregistering MAD svc: %s\n", ib_get_err_str( status ) ) );\r
}\r
\r
- CL_EXIT( AL_DBG_MAD, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MAD);\r
return status;\r
}\r
\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ioctl_buf.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_MAD_SEND IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ioctl_buf.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_CANCEL_MAD IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
return IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ioctl_buf.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_REG_MAD_POOL IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
return IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ioctl_buf.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
- ("UAL_DEREG_MAD_POOL IOCTL returned %s.\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
+ ("UAL_DEREG_MAD_POOL IOCTL returned %s.\n",\r
+ CL_STATUS_MSG(cl_status)));\r
}\r
else if( ioctl_buf.out.status != IB_SUCCESS )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("Error deregistering MAD pool: %s\n",\r
ib_get_err_str( ioctl_buf.out.status )) );\r
}\r
&bytes_ret );\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ioctl_buf.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_MAD_RECV_COMP IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(local_mad_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_LOCAL_MAD IOCTL returned %s\n", CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
}\r
#include "al_mad_pool.h"\r
#include "al_debug.h"\r
\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "ual_mad_pool.tmh"\r
+#endif\r
+\r
+\r
\r
\r
/*\r
al_pool_key_t* p_pool_key;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_MAD_POOL);\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pool, AL_OBJ_TYPE_H_MAD_POOL ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
if( !pp_pool_key )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
{\r
__ual_free_pool_key( &p_pool_key->obj );\r
\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("init_al_obj failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_pool_key->obj.pfn_destroy( &p_pool_key->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &p_pool_key->obj );\r
\r
- CL_EXIT( AL_DBG_MAD_POOL, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MAD_POOL);\r
return IB_SUCCESS;\r
}\r
\r
#include "ual_support.h"\r
#include "ual_mcast.h"\r
\r
+#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "ual_mcast.tmh"\r
+#endif\r
\r
ib_api_status_t\r
ual_attach_mcast(\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ioctl_buf.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_ATTACH_MCAST IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ioctl_buf.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_DETACH_MCAST IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
#include "ual_support.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "ual_mgr.tmh"\r
+#endif\r
+\r
#include "al_mgr.h"\r
#include "al_init.h"\r
#include "al_res_mgr.h"\r
__cleanup_ual_mgr(\r
IN al_obj_t *p_obj )\r
{\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_MGR);\r
\r
UNUSED_PARAM( p_obj );\r
\r
if( !PostQueuedCompletionStatus( gp_al_mgr->ual_mgr.h_cb_port,\r
0, 0, NULL ) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("PostQueuedCompletionStatus returned %d\n",\r
GetLastError()) );\r
}\r
NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL );\r
if( ioctl.h_file == INVALID_HANDLE_VALUE )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("CreateFile returned %d.\n", GetLastError()) );\r
return INVALID_HANDLE_VALUE;\r
}\r
ioctl.h_file, gp_al_mgr->ual_mgr.h_cb_port, type, 0 ) )\r
{\r
CloseHandle( ioctl.h_file );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("CreateIoCompletionPort for file of type %d returned %d.\n",\r
type, GetLastError()) );\r
return INVALID_HANDLE_VALUE;\r
if( cl_status != CL_SUCCESS )\r
{\r
CloseHandle( ioctl.h_file );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("Bind IOCTL for type %d returned %s.\n",\r
- CL_STATUS_MSG(cl_status)) );\r
+ type,CL_STATUS_MSG(cl_status)) );\r
return INVALID_HANDLE_VALUE;\r
}\r
\r
&gp_al_mgr->ual_mgr.cb_threads, cl_proc_count(), 0 );\r
if( cl_status != CL_SUCCESS )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("cl_ptr_vector_init returned %s.\n", CL_STATUS_MSG( cl_status )) );\r
return IB_ERROR;\r
}\r
h_thread = CreateThread( NULL, 0, __cb_thread_routine, NULL, 0, NULL );\r
if( !h_thread )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("CreateThread returned %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
uintn_t bytes_ret;\r
ULONG ver;\r
\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_MGR);\r
\r
CL_ASSERT( !gp_al_mgr );\r
\r
gp_al_mgr = cl_zalloc( sizeof( al_mgr_t ) );\r
if( !gp_al_mgr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("Failed to cl_zalloc ual_mgr_t.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( ib_status != IB_SUCCESS )\r
{\r
__free_ual_mgr( &gp_al_mgr->obj );\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("init_al_obj failed, status = 0x%x.\n", ib_status) );\r
return ib_status;\r
}\r
if( !gp_al_mgr->ual_mgr.h_cb_port )\r
{\r
gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("Failed to create I/O completion port.\n") );\r
return IB_ERROR;\r
}\r
if( ib_status != IB_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("ual_create_cb_threads failed.\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("ual_create_cb_threads failed.\n") );\r
return ib_status;\r
}\r
\r
//if( gp_al_mgr->ual_mgr.h_cq_file == INVALID_HANDLE_VALUE )\r
//{\r
// gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
- // AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ // AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
// ("ual_create_async_file for UAL_BIND_CM returned %d.\n",\r
// GetLastError()) );\r
// return IB_ERROR;\r
if( gp_al_mgr->ual_mgr.h_cq_file == INVALID_HANDLE_VALUE )\r
{\r
gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("ual_create_async_file for UAL_BIND_CQ returned %d.\n",\r
GetLastError()) );\r
return IB_ERROR;\r
if( gp_al_mgr->ual_mgr.h_misc_file == INVALID_HANDLE_VALUE )\r
{\r
gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("ual_create_async_file for UAL_BIND_CQ returned %d.\n",\r
GetLastError()) );\r
return IB_ERROR;\r
if ((ib_status = do_open_al(&gp_al_mgr->ual_mgr.h_al)) != IB_SUCCESS)\r
{\r
gp_al_mgr->obj.pfn_destroy(&gp_al_mgr->obj, NULL);\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("do_open_al() failed, status = 0x%x.\n", ib_status) );\r
return ( ib_status );\r
}\r
if( ib_status != IB_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy(&gp_al_mgr->obj, NULL);\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("ib_create_mad_pool failed with %s.\n", ib_get_err_str(ib_status)) );\r
return ib_status;\r
}\r
if( ib_status != IB_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy(&gp_al_mgr->obj, NULL);\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("ual_reg_global_mad_pool failed with %s.\n", ib_get_err_str(ib_status)) );\r
return ib_status;\r
}\r
if( ib_status != IB_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy(&gp_al_mgr->obj, NULL);\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("al_pnp_create failed with %s.\n", ib_get_err_str(ib_status)) );\r
return ib_status;\r
}\r
if( ib_status != IB_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy(&gp_al_mgr->obj, NULL);\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("create_res_mgr failed with %s.\n", ib_get_err_str(ib_status)) );\r
return ib_status;\r
}\r
if( ib_status != IB_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy(&gp_al_mgr->obj, NULL);\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("create_sa_req_mgr failed with %s.\n", ib_get_err_str(ib_status)) );\r
return ib_status;\r
}\r
if( ib_status != IB_SUCCESS )\r
{\r
gp_al_mgr->obj.pfn_destroy( &gp_al_mgr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("create_cm_mgr failed, status = 0x%x.\n", ib_status) );\r
return ib_status;\r
}\r
{\r
if( GetLastError() != ERROR_IO_PENDING )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("DeviceIoControl for misc callback request returned %d.\n",\r
GetLastError()) );\r
gp_al_mgr->obj.pfn_destroy(&gp_al_mgr->obj, NULL);\r
//{\r
// if( GetLastError() != ERROR_IO_PENDING )\r
// {\r
- // AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ // AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
// ("DeviceIoControl for CM callback request returned %d.\n",\r
// GetLastError()) );\r
// gp_al_mgr->obj.pfn_destroy(&gp_al_mgr->obj, NULL);\r
{\r
if( GetLastError() != ERROR_IO_PENDING )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("DeviceIoControl for CM callback request returned %d.\n",\r
GetLastError()) );\r
gp_al_mgr->obj.pfn_destroy(&gp_al_mgr->obj, NULL);\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &gp_al_mgr->obj );\r
\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MGR);\r
return IB_SUCCESS;\r
}\r
\r
// {\r
// if( GetLastError() != ERROR_IO_PENDING )\r
// {\r
-// AL_TRACE_EXIT( AL_DBG_ERROR,\r
+// AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
// ("DeviceIoControl for CM callback request returned %d.\n",\r
// GetLastError()) );\r
// }\r
{\r
if( GetLastError() != ERROR_IO_PENDING )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("DeviceIoControl for CM callback request returned %d.\n",\r
GetLastError()) );\r
}\r
{\r
if( GetLastError() != ERROR_IO_PENDING )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("DeviceIoControl for misc callback request returned %d.\n",\r
GetLastError()) );\r
}\r
&bytes_ret );\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(ioctl_buf.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_MAD_RECV_COMP IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
ib_al_handle_t h_al;\r
ib_api_status_t status;\r
\r
- CL_ENTER( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_ENTER(AL_DBG_MGR);\r
\r
if( !ph_al )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
al_cleanup();\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("ual_init failed, status = %s\n", ib_get_err_str(status) ) );\r
return status;\r
}\r
h_al = (ib_al_handle_t)cl_zalloc( sizeof( ib_al_t ) );\r
if( !h_al )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("cl_malloc failed\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("cl_malloc failed\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
free_al( &h_al->obj );\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MGR);\r
return status;\r
}\r
attach_al_obj( &gp_al_mgr->obj, &h_al->obj );\r
/* Release the reference taken in init_al_obj. */\r
deref_al_obj( &h_al->obj );\r
\r
- CL_EXIT( AL_DBG_MGR, g_al_dbg_lvl );\r
+ AL_EXIT(AL_DBG_MGR);\r
return IB_SUCCESS;\r
}\r
\r
#include "al.h"\r
#include "ual_support.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "ual_mr.tmh"\r
+#endif\r
+\r
#include "al_mr.h"\r
#include "al_pd.h"\r
#include "al_res_mgr.h"\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(mr_ioctl.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_REG_MR IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
return IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(mr_ioctl.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_DEREG_MR IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
return IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(mr_ioctl.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_MODIFY_MR IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
return IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(mr_ioctl.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_QUERY_MR IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
return IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(mr_ioctl.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_REG_SHARED IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
return IB_ERROR;\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pd, AL_OBJ_TYPE_H_PD ) )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PD_HANDLE\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IB_INVALID_PD_HANDLE\n") );\r
return IB_INVALID_PD_HANDLE;\r
}\r
if( !p_mr_create || !p_vaddr || !p_lkey || !p_rkey || !ph_mr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
h_mr = alloc_mr();\r
if( !h_mr )\r
{\r
- CL_TRACE_EXIT( AL_DBG_ERROR, g_al_dbg_lvl,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("unable to allocate memory handle\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(mr_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_REG_SHMID IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
#include "al_mr.h"\r
\r
\r
+#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "ual_mw.tmh"\r
+#endif\r
+\r
ib_api_status_t\r
ual_create_mw(\r
IN const ib_pd_handle_t h_pd,\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(mw_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CREATE_MW IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(mw_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_DESTROY_MW IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(mw_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_QUERY_MW IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(mw_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_BIND_MW IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
#include "al_pd.h"\r
\r
\r
+#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "ual_pd.tmh"\r
+#endif\r
+\r
ib_api_status_t\r
ual_allocate_pd(\r
IN ib_ca_handle_t h_ca,\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(pd_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_ALLOC_PD IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(pd_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_DEALLOC_PD IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
#include "al.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "ual_pnp.tmh"\r
+#endif\r
+\r
#include "al_mgr.h"\r
#include "al_pnp.h"\r
#include "ib_common.h"\r
gp_pnp = (ual_pnp_mgr_t*)cl_zalloc( sizeof(ual_pnp_mgr_t) );\r
if( !gp_pnp )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("Failed to allocate PnP manager.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( status != IB_SUCCESS )\r
{\r
__pnp_free( &gp_pnp->obj );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("init_al_obj() failed with status %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( status != IB_SUCCESS )\r
{\r
gp_pnp->obj.pfn_destroy( &gp_pnp->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( gp_pnp->h_file == INVALID_HANDLE_VALUE )\r
{\r
gp_pnp->obj.pfn_destroy( &gp_pnp->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("ual_create_async_file for UAL_BIND_PNP returned %d.\n",\r
GetLastError()) );\r
return IB_ERROR;\r
if( gp_pnp->h_destroy_file == INVALID_HANDLE_VALUE )\r
{\r
gp_pnp->obj.pfn_destroy( &gp_pnp->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("ual_create_async_file for UAL_BIND_DESTROY returned %d.\n",\r
GetLastError()) );\r
return IB_ERROR;\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !p_pnp_req || !ph_pnp )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("IB_INVALID_PARAMETER\n") );\r
return IB_INVALID_PARAMETER;\r
}\r
\r
p_reg = (al_pnp_t*)cl_zalloc( sizeof(al_pnp_t) );\r
if( !p_reg )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
- ("Failed to cl_zalloc al_pnp_t (%"PRIdSIZE_T" bytes).\n",\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
+ ("Failed to cl_zalloc al_pnp_t (%I64d bytes).\n",\r
sizeof(al_pnp_t)) );\r
return( IB_INSUFFICIENT_MEMORY );\r
}\r
if( status != IB_SUCCESS )\r
{\r
__pnp_reg_free( &p_reg->obj );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("init_al_obj() failed with status %s.\n", ib_get_err_str(status)) );\r
return( status );\r
}\r
if( status != IB_SUCCESS )\r
{\r
p_reg->obj.pfn_destroy( &p_reg->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( !in.sync_event )\r
{\r
p_reg->obj.pfn_destroy( &p_reg->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("CreateEvent returned %d\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
\r
if( AL_OBJ_INVALID_HANDLE( h_pnp, AL_OBJ_TYPE_H_PNP ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
\r
\r
if( AL_OBJ_INVALID_HANDLE( h_al, AL_OBJ_TYPE_H_AL ) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("IB_INVALID_AL_HANDLE\n") );\r
return IB_INVALID_AL_HANDLE;\r
}\r
if( !h_event )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("IB_INVALID_HANDLE\n") );\r
return IB_INVALID_HANDLE;\r
}\r
\r
return;\r
}\r
\r
- AL_TRACE( AL_DBG_ERROR, ("IOCTL failed with error code %d\n",\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("IOCTL failed with error code %d\n",\r
error_code) );\r
p_reg->rearm.evt_hdl = AL_INVALID_HANDLE;\r
p_reg->rearm.evt_size = 0;\r
#include "ual_support.h"\r
\r
\r
+#include "al_debug.h"\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "ual_qp.tmh"\r
+#endif\r
ib_api_status_t\r
ual_post_send(\r
IN const ib_qp_handle_t h_qp,\r
p_qp_ioctl = (ual_post_send_ioctl_t*)cl_zalloc( ioctl_buf_sz );\r
if( !p_qp_ioctl )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("Failed to allocate IOCTL buffer.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
{\r
if( pp_send_failure )\r
*pp_send_failure = p_send_wr;\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_POST_SEND IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
p_qp_ioctl = (ual_post_recv_ioctl_t*)cl_zalloc( ioctl_buf_sz );\r
if( !p_qp_ioctl )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("Failed to allocate IOCTL buffer.\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
if( pp_recv_failure )\r
*pp_recv_failure = p_recv_wr;\r
\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_POST_RECV IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(qp_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_CREATE_QP IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(qp_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_DESTROY_QP IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(qp_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_MODIFY_QP IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(qp_ioctl.out) )\r
{\r
- AL_TRACE( AL_DBG_ERROR,\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR ,\r
("UAL_QUERY_QP IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
status = IB_ERROR;\r
\r
if( cl_status != CL_SUCCESS || bytes_ret != sizeof(qp_ioctl.out) )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("UAL_GET_SPL_QP_ALIAS IOCTL returned %s.\n",\r
CL_STATUS_MSG(cl_status)) );\r
return IB_ERROR;\r
#include "al_ca.h"\r
#include "al_common.h"\r
#include "al_debug.h"\r
+\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "ual_sa_req.tmh"\r
+#endif\r
+\r
#include "al_mgr.h"\r
#include "al_query.h"\r
#include "ib_common.h"\r
gp_sa_req_mgr = cl_zalloc( sizeof( sa_req_mgr_t ) );\r
if( gp_sa_req_mgr == NULL )\r
{\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("cl_zalloc failed\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("cl_zalloc failed\n") );\r
return IB_INSUFFICIENT_MEMORY;\r
}\r
\r
if( status != IB_SUCCESS )\r
{\r
free_sa_req_mgr( &gp_sa_req_mgr->obj );\r
- AL_TRACE_EXIT( AL_DBG_ERROR, ("cl_spinlock_init failed\n") );\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("cl_spinlock_init failed\n") );\r
return status;\r
}\r
status = attach_al_obj( p_parent_obj, &gp_sa_req_mgr->obj );\r
if( status != IB_SUCCESS )\r
{\r
gp_sa_req_mgr->obj.pfn_destroy( &gp_sa_req_mgr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("attach_al_obj returned %s.\n", ib_get_err_str(status)) );\r
return status;\r
}\r
if( gp_sa_req_mgr->h_sa_dev == INVALID_HANDLE_VALUE )\r
{\r
gp_sa_req_mgr->obj.pfn_destroy( &gp_sa_req_mgr->obj, NULL );\r
- AL_TRACE_EXIT( AL_DBG_ERROR,\r
+ AL_PRINT_EXIT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR,\r
("ual_create_async_file returned %d.\n", GetLastError()) );\r
return IB_ERROR;\r
}\r
if( GetLastError() != ERROR_IO_PENDING )\r
{\r
status = p_sa_req->status;\r
- AL_TRACE( AL_DBG_ERROR, ("UAL_SEND_SA_REQ IOCTL returned %s\n",\r
+ AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR , ("UAL_SEND_SA_REQ IOCTL returned %s\n",\r
ib_get_err_str(status)) );\r
}\r
else\r
#include <iba/ib_al_ioctl.h>\r
#include "al_dev.h"\r
#include "al_debug.h"\r
+\r
+\r
+\r
#include <strsafe.h>\r
\r
\r
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),\r
(LPSTR)&error, 0, NULL ) )\r
{\r
- AL_TRACE( dbg_lvl, ("%s (%d)\n", buffer, GetLastError()) );\r
+ //AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("%s (%d)\n", buffer, GetLastError()) );\r
}\r
else\r
{\r
- AL_TRACE( dbg_lvl, ("%s (%s)\n", buffer, error) );\r
+ //AL_PRINT(TRACE_LEVEL_ERROR ,AL_DBG_ERROR, ("%s (%s)\n", buffer, error) );\r
LocalFree( error );\r
}\r
}\r
TARGETPATH=..\..\..\bin\kernel\obj$(BUILD_ALT_DIR)\r
TARGETTYPE=DRIVER\r
\r
+\r
+!if $(FREEBUILD)\r
+ENABLE_EVENT_TRACING=1\r
+!else\r
+#ENABLE_EVENT_TRACING=1\r
+!endif\r
+\r
+\r
SOURCES= ibbus.rc \\r
bus_driver.c \\r
bus_pnp.c \\r
TARGETLIBS= $(TARGETLIBS) $(DDK_LIB_PATH)\ntstrsafe.lib\r
!endif\r
\r
+!IFDEF ENABLE_EVENT_TRACING\r
+\r
+C_DEFINES = $(C_DEFINES) -DEVENT_TRACING\r
+\r
+RUN_WPP = $(SOURCES) -km -ext: .c .h .C .H \r
+\r
+!ENDIF\r
+\r
+\r
MSC_WARNING_LEVEL= /W4\r
#include <complib/cl_init.h>\r
\r
\r
+#if defined(EVENT_TRACING)\r
+#ifdef offsetof\r
+#undef offsetof\r
+#endif\r
+#include "bus_driver.tmh"\r
+#endif\r
+\r
+\r
#define DEFAULT_NODE_DESC "OpenIB Windows® Host"\r
\r
\r
UNICODE_STRING hostNameW;\r
ANSI_STRING hostName;\r
\r
- AL_ENTER( AL_DBG_DEV );\r
+ BUS_ENTER( BUS_DBG_DRV );\r
\r
/* Get the host name. */\r
RtlInitUnicodeString( &hostNamePath, L"ComputerName\\ComputerName" );\r
}\r
else\r
{\r
- AL_TRACE( AL_DBG_ERROR, ("Failed to get host name.\n") );\r
+ BUS_TRACE(BUS_DBG_ERROR , ("Failed to get host name.\n") );\r
/* Use the default name... */\r
RtlStringCbCopyNA( node_desc, sizeof(node_desc),\r
DEFAULT_NODE_DESC, sizeof(DEFAULT_NODE_DESC) );\r
}\r
\r
- AL_EXIT( AL_DBG_DEV );\r
+ BUS_ENTER( BUS_DBG_DRV );\r
}\r
\r
\r
{\r
NTSTATUS status;\r
/* Remember the terminating entry in the table below. */\r
- RTL_QUERY_REGISTRY_TABLE table[8];\r
+ RTL_QUERY_REGISTRY_TABLE table[9];\r
UNICODE_STRING param_path;\r
\r
BUS_ENTER( BUS_DBG_DRV );\r
table[1].DefaultLength = sizeof(ULONG);\r
\r
table[2].Flags = RTL_QUERY_REGISTRY_DIRECT;\r
- table[2].Name = L"IbalDebugFlags";\r
- table[2].EntryContext = &g_al_dbg_lvl;\r
+ table[2].Name = L"IbalDebugLevel";\r
+ table[2].EntryContext = &g_al_dbg_level;\r
table[2].DefaultType = REG_DWORD;\r
- table[2].DefaultData = &g_al_dbg_lvl;\r
+ table[2].DefaultData = &g_al_dbg_level;\r
table[2].DefaultLength = sizeof(ULONG);\r
\r
table[3].Flags = RTL_QUERY_REGISTRY_DIRECT;\r
- table[3].Name = L"SmiPollInterval";\r
- table[3].EntryContext = &g_smi_poll_interval;\r
+ table[3].Name = L"IbalDebugFlags";\r
+ table[3].EntryContext = &g_al_dbg_flags;\r
table[3].DefaultType = REG_DWORD;\r
- table[3].DefaultData = &g_smi_poll_interval;\r
+ table[3].DefaultData = &g_al_dbg_flags;\r
table[3].DefaultLength = sizeof(ULONG);\r
+ \r
\r
table[4].Flags = RTL_QUERY_REGISTRY_DIRECT;\r
- table[4].Name = L"IocQueryTimeout";\r
- table[4].EntryContext = &g_ioc_query_timeout;\r
+ table[4].Name = L"SmiPollInterval";\r
+ table[4].EntryContext = &g_smi_poll_interval;\r
table[4].DefaultType = REG_DWORD;\r
- table[4].DefaultData = &g_ioc_query_timeout;\r
+ table[4].DefaultData = &g_smi_poll_interval;\r
table[4].DefaultLength = sizeof(ULONG);\r
\r
table[5].Flags = RTL_QUERY_REGISTRY_DIRECT;\r
- table[5].Name = L"IocQueryRetries";\r
- table[5].EntryContext = &g_ioc_query_retries;\r
+ table[5].Name = L"IocQueryTimeout";\r
+ table[5].EntryContext = &g_ioc_query_timeout;\r
table[5].DefaultType = REG_DWORD;\r
- table[5].DefaultData = &g_ioc_query_retries;\r
+ table[5].DefaultData = &g_ioc_query_timeout;\r
table[5].DefaultLength = sizeof(ULONG);\r
\r
table[6].Flags = RTL_QUERY_REGISTRY_DIRECT;\r
- table[6].Name = L"IocPollInterval";\r
- table[6].EntryContext = &g_ioc_poll_interval;\r
+ table[6].Name = L"IocQueryRetries";\r
+ table[6].EntryContext = &g_ioc_query_retries;\r
table[6].DefaultType = REG_DWORD;\r
- table[6].DefaultData = &g_ioc_poll_interval;\r
+ table[6].DefaultData = &g_ioc_query_retries;\r
table[6].DefaultLength = sizeof(ULONG);\r
\r
+ table[7].Flags = RTL_QUERY_REGISTRY_DIRECT;\r
+ table[7].Name = L"IocPollInterval";\r
+ table[7].EntryContext = &g_ioc_poll_interval;\r
+ table[7].DefaultType = REG_DWORD;\r
+ table[7].DefaultData = &g_ioc_poll_interval;\r
+ table[7].DefaultLength = sizeof(ULONG);\r
+\r
/* Have at it! */\r
status = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE, \r
param_path.Buffer, table, NULL, NULL );\r
\r
CL_DEINIT;\r
\r
+#if defined(EVENT_TRACING)\r
+ WPP_CLEANUP(p_driver_obj);\r
+#endif\r
+\r
BUS_EXIT( BUS_DBG_DRV );\r
+ \r
}\r
\r
\r
\r
BUS_ENTER( BUS_DBG_DRV );\r
\r
+#if defined(EVENT_TRACING)\r
+ WPP_INIT_TRACING(p_driver_obj ,p_registry_path);\r
+#endif\r
+\r
status = CL_INIT;\r
if( !NT_SUCCESS(status) )\r
{\r
[Ibbus.ParamsReg]\r
HKR,"Parameters","DebugFlags",%REG_DWORD%,0x80000000\r
HKR,"Parameters","ReportPortNIC",%REG_DWORD%,1\r
+HKR,"Parameters","IbalDebugLevel",%REG_DWORD%,0x80000000\r
HKR,"Parameters","IbalDebugFlags",%REG_DWORD%,0x80000000\r
HKR,"Parameters","SmiPollInterval",%REG_DWORD_NO_CLOBBER%,20000\r
HKR,"Parameters","IocQueryTimeout",%REG_DWORD_NO_CLOBBER%,250\r
return(1);\r
else if( !strncmp(p_port_state_str, "INIT", 4) )\r
return(2);\r
- else if( !strncmp(p_port_state_str,"ARMED" , 5) )\r
+ else if( !strncmp(p_port_state_str,"ARMED", 5) )\r
return(3);\r
else if( !strncmp(p_port_state_str, "ACTIVE", 6) )\r
return(4);\r
projects / ~shefty / rdma-win.git / commitdiff