void cl_qcpool_destroy(IN cl_qcpool_t * const p_pool)
{
	/* CL_ASSERT that a non-NULL pointer was provided. */
	CL_ASSERT(p_pool);
	/* CL_ASSERT that we are in a valid state (not uninitialized memory). */
	CL_ASSERT(cl_is_state_valid(p_pool->state));

	if (p_pool->state == CL_INITIALIZED) {
		/*
		 * Assert if the user hasn't put everything back in the pool
		 * before destroying it
		 * if they haven't, then most likely they are still using memory
		 * that will be freed, and the destructor will not be called!
		 */
#ifdef _DEBUG_
		/* but we do not want "free" version to assert on this one */
		CL_ASSERT(cl_qcpool_count(p_pool) == p_pool->num_objects);
#endif
		/* call the user's destructor for each object in the pool */
		if (p_pool->pfn_dtor) {
			while (!cl_is_qlist_empty(&p_pool->free_list)) {
				p_pool->pfn_dtor((cl_pool_item_t *)
						 cl_qlist_remove_head(&p_pool->
								      free_list),
						 (void *)p_pool->context);
			}
		} else {
			cl_qlist_remove_all(&p_pool->free_list);
		}

		/* Free all allocated memory blocks. */
		while (!cl_is_qlist_empty(&p_pool->alloc_list))
			free(cl_qlist_remove_head(&p_pool->alloc_list));

		if (p_pool->component_sizes) {
			free(p_pool->component_sizes);
			p_pool->component_sizes = NULL;
		}
	}

	p_pool->state = CL_UNINITIALIZED;
}

void clPyGlueInit(char* appModule,void (*init_extensions[])(void),int argc, char**argv)
{
  char buf[1024];
  ClRcT rc;
    Py_Initialize();
    PySys_SetArgv(argc, argv);
    PyEval_InitThreads();
    
    if (init_extensions) 
      {
        int i = 0;
        for(i=0; init_extensions[i]!=NULL; i++) (*init_extensions[i])();
      }
    thrdState = PyThreadState_Get();

    rc = clOsalMutexInit(&pyMutex);
    CL_ASSERT(rc==CL_OK); 

    rc = clOsalCondInit(&event);
    CL_ASSERT(rc==CL_OK); 

    rc = clOsalMutexLock(&pyMutex);
    CL_ASSERT(rc==CL_OK); 

    PyThreadState_Swap(thrdState);

    PyRun_SimpleString("import os, os.path, sys\n");
    snprintf(buf,1024,"sys.path.append(os.path.realpath('%s'))\n",CL_APP_BINDIR);
    clprintf(CL_LOG_SEV_INFO, buf);
    PyRun_SimpleString(buf);
    //PyRun_SimpleString("sys.path.append(os.path.realpath('../../bin'))\n");
    snprintf(buf,1024,"from %s import *\n",appModule);
    clprintf(CL_LOG_SEV_INFO, buf);
    PyRun_SimpleString(buf);

    PyThreadState_Swap(NULL);
    PyEval_ReleaseLock();

    rc=clOsalMutexUnlock(&pyMutex);
    CL_ASSERT(rc==CL_OK); 

}

/**********************************************************************
 The plock must be held before calling this function.
**********************************************************************/
static void si_rcv_get_fwd_tbl(IN osm_sm_t * sm, IN osm_switch_t * p_sw)
{
	osm_madw_context_t context;
	osm_dr_path_t *p_dr_path;
	osm_physp_t *p_physp;
	osm_node_t *p_node;
	uint32_t block_id_ho;
	uint32_t max_block_id_ho;
	ib_api_status_t status = IB_SUCCESS;

	OSM_LOG_ENTER(sm->p_log);

	CL_ASSERT(p_sw);

	p_node = p_sw->p_node;

	CL_ASSERT(osm_node_get_type(p_node) == IB_NODE_TYPE_SWITCH);

	context.lft_context.node_guid = osm_node_get_node_guid(p_node);
	context.lft_context.set_method = FALSE;

	max_block_id_ho = osm_switch_get_max_block_id_in_use(p_sw);

	p_physp = osm_node_get_physp_ptr(p_node, 0);
	p_dr_path = osm_physp_get_dr_path_ptr(p_physp);

	for (block_id_ho = 0; block_id_ho <= max_block_id_ho; block_id_ho++) {
		OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
			"Retrieving FT block %u\n", block_id_ho);

		status = osm_req_get(sm, p_dr_path, IB_MAD_ATTR_LIN_FWD_TBL,
				     cl_hton32(block_id_ho),
				     CL_DISP_MSGID_NONE, &context);
		if (status != IB_SUCCESS)
			/* continue the loop despite the error */
			OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3603: "
				"Failure initiating PortInfo request (%s)\n",
				ib_get_err_str(status));
	}

	OSM_LOG_EXIT(sm->p_log);
}

void osm_ucast_mgr_destroy(IN osm_ucast_mgr_t * p_mgr)
{
	CL_ASSERT(p_mgr);

	OSM_LOG_ENTER(p_mgr->p_log);

	if (p_mgr->cache_valid)
		osm_ucast_cache_invalidate(p_mgr);

	OSM_LOG_EXIT(p_mgr->p_log);
}

/*----------------------------------------------------------------------------
 *  Cluster Track Callback Handler
 *---------------------------------------------------------------------------*/
ClRcT clGmsClusterTrackCallbackHandler(
    CL_IN   ClGmsClusterTrackCallbackDataT* const res)
{
    ClRcT rc = CL_OK;
    struct gms_instance *gms_instance_ptr = NULL;
    ClGmsHandleT gmsHandle = CL_GMS_INVALID_HANDLE;

    CL_ASSERT(res != NULL);
    clLog(INFO,NA,NA,"received cluster track callback");

    gmsHandle = res->gmsHandle;
    rc = clHandleCheckout(gmsHandleDb, gmsHandle, (void**)&gms_instance_ptr);
    if (rc != CL_OK)
    {
        goto error_free_res;
    }

    if (gms_instance_ptr == NULL)
    {
        rc = CL_GMS_RC(CL_ERR_NULL_POINTER);
        goto error_free_res;
    }

    if (gms_instance_ptr->callbacks.clGmsClusterTrackCallback == NULL)
    {
        rc = CL_GMS_RC(CL_ERR_NO_CALLBACK);
        goto error_checkin_free_res;
    }

    /*
     * Calling the user's callback function with the data.  The user cannot
     * free the data we provide.  If it needs to reatin it, it has to copy
     * it out from what we provide here.
     */
            (*gms_instance_ptr->callbacks.clGmsClusterTrackCallback)
            (gmsHandle, &res->buffer, res->numberOfMembers, res->rc);
  

error_checkin_free_res:
    if (clHandleCheckin(gmsHandleDb, gmsHandle) != CL_OK)
    {
        clLogError(CLM,NA,
                   "\nclHandleCheckin failed");
    }

error_free_res:
    /* Need to free data (res) if are not able to call the actual callback */
    if (res->buffer.notification != NULL)
    {
        clHeapFree((void*)res->buffer.notification);
    }
    clHeapFree((void*)res);
    return rc;
}

ClRcT clTransportNotifyRegister(ClTransportNotifyCallbackT callback, ClPtrT arg)
{
    ClTransportNotifyRegistrantT *registrant = NULL;
    if(!callback) return CL_ERR_INVALID_PARAMETER;
    registrant = clHeapCalloc(1, sizeof(*registrant));
    CL_ASSERT(registrant != NULL);
    registrant->callback = callback;
    registrant->arg = arg;
    clListAddTail(&registrant->list, &gClXportNotifyRegistrants);
    return CL_OK;
}

ClRcT clMemPartInitialize(ClMemPartHandleT *pMemPartHandle, ClUint32T memPartSize)
{
    ClCharT *pool = NULL;
    ClInt32T i;
    ClRcT rc = CL_OK;
    ClMemPartT *pMemPart = NULL;

    if(!pMemPartHandle)
        return CL_ERR_INVALID_PARAMETER;

    if(!memPartSize)
        memPartSize = CL_MEM_PART_SIZE;

    pMemPart = calloc(1, sizeof(*pMemPart));
    CL_ASSERT(pMemPart !=  NULL);

    rc= clOsalMutexInit(&pMemPart->mutex);
    CL_ASSERT(rc == CL_OK);

    for(i = 0; i < CL_MEM_PART_EXPANSION_SLOTS; ++i)
        pMemPart->partitions[i] = NULL;

    pMemPart->index = 0;
    pool = malloc(memPartSize);
    if(!pool)
    {
        CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("CALLOC failed for size [%d] while trying to create MEM partition\n", 
                                        memPartSize));
        return CL_ERR_NO_MEMORY;
    }
    pMemPart->partId = memPartCreate(pool, memPartSize);
    if(!pMemPart->partId)
    {
        free(pool);
        CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("memPartCreate for size [%d] failed\n", memPartSize));
        return CL_ERR_NO_MEMORY;
    }
    pMemPart->partitions[pMemPart->index++] = pool;
    *pMemPartHandle = (ClMemPartHandleT)pMemPart;
    return CL_OK;
}

static int cycle_exists(cdg_vertex_t * start, cdg_vertex_t * current,
			cdg_vertex_t * prev, int visit_num)
{
	int i, new_visit_num;
	int cycle_found = 0;

	if (current != NULL && current->visiting_number > 0) {
		if (visit_num > current->visiting_number && current->seen == 0) {
			cycle_found = 1;
		}
	} else {
		if (current == NULL) {
			current = start;
			CL_ASSERT(prev == NULL);
		}

		current->visiting_number = visit_num;

		if (prev != NULL) {
			prev->next = current;
			CL_ASSERT(prev->to == current->from);
			CL_ASSERT(prev->visiting_number > 0);
		}

		new_visit_num = visit_num + 1;

		for (i = 0; i < current->num_deps; i++) {
			cycle_found =
			    cycle_exists(start, current->deps[i].v, current,
					 new_visit_num);
			if (cycle_found == 1)
				i = current->num_deps;
		}

		current->seen = 1;
		if (prev != NULL)
			prev->next = NULL;
	}

	return cycle_found;
}

/**
 *  ReStarts the extended state machine instance.
 *
 *  Please refer to the FSM Restart API.
 *
 *  @param smThis State Machine Object
 *
 *  @returns 
 *    CL_OK on CL_OK (successful start) <br/>
 *    CL_SM_RC(CL_ERR_NULL_POINTER) on invalid/null instance handle <br/>
 *
 *  @see #clSmInstanceStart
 */
ClRcT
clEsmInstanceRestart(ClExSmInstancePtrT smThis
                  )
{
    CL_ASSERT(smThis);
    if(smThis)
      {
        return clSmInstanceRestart(smThis->fsm);
      }
    
    return CL_SM_RC(CL_ERR_NULL_POINTER);
}

void clEoQueueStatsStop(ClUint32T queueSize, ClEoJobT *pJob, ClEoQueueStatsT *pStats)
{
    ClUint8T proto = pJob->msgParam.protoType;
    ClUint8T priority = CL_EO_RECV_QUEUE_PRI(pJob->msgParam);
    ClUint64T timeDiff=0;
    gettimeofday(&pStats->end, NULL);
    CL_ASSERT(pStats->priority == priority);
    CL_ASSERT(pStats->proto == proto);
    pStats->end.tv_sec -= pStats->start.tv_sec;
    pStats->end.tv_usec -= pStats->start.tv_usec;
    if(pStats->end.tv_sec < 0)
        pStats->end.tv_sec = 0, pStats->end.tv_usec = 0;
    else if(pStats->end.tv_usec < 0)
    {
        --pStats->end.tv_sec;
        pStats->end.tv_usec += 1000000L;
    }
    timeDiff = (ClUint64T)pStats->end.tv_sec*1000000L + pStats->end.tv_usec;
    pStats->totalTime = timeDiff;
    clEoQueueStatsUpdate(pStats);
}

/*
  Since a race can accure on requests. Meaning - a response is received before
  the send_callback is called - we will save both the madw_p and the fact
  whether or not it is a response. A race can occure only on requests that did
  not fail, and then the madw_p will be put back in the pool before the
  callback.
*/
uint64_t __osm_set_wrid_by_p_madw(IN osm_madw_t * p_madw)
{
	uint64_t wrid = 0;

	CL_ASSERT(p_madw->p_mad);

	memcpy(&wrid, &p_madw, sizeof(osm_madw_t *));
	wrid = (wrid << 1) |
	    ib_mad_is_response(p_madw->p_mad) |
	    (p_madw->p_mad->method == IB_MAD_METHOD_TRAP_REPRESS);
	return wrid;
}

void osm_nd_rcv_process(IN void *context, IN void *data)
{
	osm_sm_t *sm = context;
	osm_madw_t *p_madw = data;
	ib_node_desc_t *p_nd;
	ib_smp_t *p_smp;
	osm_node_t *p_node;
	ib_net64_t node_guid;

	CL_ASSERT(sm);

	OSM_LOG_ENTER(sm->p_log);

	CL_ASSERT(p_madw);

	p_smp = osm_madw_get_smp_ptr(p_madw);
	if (ib_smp_get_status(p_smp)) {
		OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
			"MAD status 0x%x received\n",
			cl_ntoh16(ib_smp_get_status(p_smp)));
		goto Exit;
	}

	p_nd = ib_smp_get_payload_ptr(p_smp);

	/* Acquire the node object and add the node description. */
	node_guid = osm_madw_get_nd_context_ptr(p_madw)->node_guid;
	CL_PLOCK_EXCL_ACQUIRE(sm->p_lock);
	p_node = osm_get_node_by_guid(sm->p_subn, node_guid);
	if (!p_node)
		OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0B01: "
			"NodeDescription received for nonexistent node "
			"0x%" PRIx64 "\n", cl_ntoh64(node_guid));
	else
		nd_rcv_process_nd(sm, p_node, p_nd);

	CL_PLOCK_RELEASE(sm->p_lock);
Exit:
	OSM_LOG_EXIT(sm->p_log);
}

osm_madw_t *osm_mad_pool_get(IN osm_mad_pool_t * const p_pool,
                             IN osm_bind_handle_t h_bind,
                             IN const uint32_t total_size,
                             IN const osm_mad_addr_t * const p_mad_addr)
{
    osm_madw_t *p_madw;
    ib_mad_t *p_mad;

    CL_ASSERT(h_bind != OSM_BIND_INVALID_HANDLE);
    CL_ASSERT(total_size);

    /*
       First, acquire a mad wrapper from the mad wrapper pool.
     */
    p_madw = malloc(sizeof(*p_madw));
    if (p_madw == NULL)
        goto Exit;

    osm_madw_init(p_madw, h_bind, total_size, p_mad_addr);

    /*
       Next, acquire a wire mad of the specified size.
     */
    p_mad = osm_vendor_get(h_bind, total_size, &p_madw->vend_wrap);
    if (p_mad == NULL) {
        /* Don't leak wrappers! */
        free(p_madw);
        p_madw = NULL;
        goto Exit;
    }

    cl_atomic_inc(&p_pool->mads_out);
    /*
       Finally, attach the wire MAD to this wrapper.
     */
    osm_madw_set_mad(p_madw, p_mad);

Exit:
    return p_madw;
}

ib_api_status_t
__osmv_txnmgr_lookup(IN osmv_txn_mgr_t * p_tx_mgr,
		     IN uint64_t key, OUT osmv_txn_ctx_t ** pp_txn)
{
	ib_api_status_t status = IB_SUCCESS;
	cl_map_item_t *p_item;
	cl_map_obj_t *p_obj;

	uint64_t tmp_key;

	OSM_LOG_ENTER(p_tx_mgr->p_log);

	CL_ASSERT(p_tx_mgr);
	CL_ASSERT(pp_txn);

	osm_log(p_tx_mgr->p_log, OSM_LOG_DEBUG,
		"__osmv_txnmgr_lookup: "
		"Looking for key: 0x%llX in map ptr:%p\n", key,
		p_tx_mgr->p_txn_map);

	p_item = cl_qmap_head(p_tx_mgr->p_txn_map);
	while (p_item != cl_qmap_end(p_tx_mgr->p_txn_map)) {
		tmp_key = cl_qmap_key(p_item);
		osm_log(p_tx_mgr->p_log, OSM_LOG_DEBUG,
			"__osmv_txnmgr_lookup: "
			"Found key 0x%llX \n", tmp_key);
		p_item = cl_qmap_next(p_item);
	}

	p_item = cl_qmap_get(p_tx_mgr->p_txn_map, key);
	if (cl_qmap_end(p_tx_mgr->p_txn_map) == p_item) {
		status = IB_NOT_FOUND;
	} else {
		p_obj = PARENT_STRUCT(p_item, cl_map_obj_t, item);
		*pp_txn = cl_qmap_obj(p_obj);
	}

	OSM_LOG_EXIT(p_tx_mgr->p_log);
	return status;
}

/* 
 * clDispatchSelectionObject returns the selection object [readFd] associated
 * with this particular initialization of the dispatch library 
 */
ClRcT   clDispatchSelectionObjectGet(
        CL_IN   ClHandleT           dispatchHandle,
        CL_OUT  ClSelectionObjectT* pSelectionObject)
{
    ClRcT   rc = CL_OK;
    ClDispatchDbEntryT* thisDbEntry = NULL;

    if (pSelectionObject == NULL)
    {
        return CL_ERR_NULL_POINTER;
    }

    CHECK_LIB_INIT;

    rc = clHandleCheckout(databaseHandle, dispatchHandle, (void *)&thisDbEntry);
    if (rc != CL_OK)
    {
        return CL_ERR_INVALID_HANDLE;
    }
    CL_ASSERT(thisDbEntry != NULL);

    rc = clOsalMutexLock(thisDbEntry->dispatchMutex);
    if (rc != CL_OK)
    {
        goto error_return;
    }

    if (thisDbEntry->shouldDelete == CL_TRUE)
    {
        rc = CL_ERR_INVALID_HANDLE;
        goto error_unlock_return;
    }
    
    *pSelectionObject = (ClSelectionObjectT)thisDbEntry->readFd;

error_unlock_return:
    rc = clOsalMutexUnlock(thisDbEntry->dispatchMutex);
    if (rc != CL_OK)
    {
        CL_DEBUG_PRINT(CL_DEBUG_ERROR,
                ("Mutex Unlock failed with rc = 0x%x\n",rc));
    }

error_return:
    if ((clHandleCheckin(databaseHandle, dispatchHandle)) != CL_OK)
    {
        CL_DEBUG_PRINT(CL_DEBUG_ERROR,
                ("clHandleCheckin failed"));
    }

    return rc;
}

void clPyGlueStart(int block)
{
    ClRcT rc;
    clRunPython("eoApp.Start()");

    if (block)
      {
      ClTimerTimeOutT forever={0};
      rc = clOsalMutexLock(&pyMutex);
      CL_ASSERT(rc==CL_OK); 
      clOsalCondWait (&event,&pyMutex,forever);
      }
}

static void clAmsMgmtOIExtendedCacheAdd(ClAmsMgmtOIExtendedClassTypeT type,
                                        ClCorInstanceIdT instance, 
                                        ClAmsMgmtOIExtendedEntityConfigT *pConfig,
                                        ClUint32T configSize)
{
    struct hashStruct **table = NULL;
    ClAmsMgmtOIExtendedCacheT *cacheEntry = NULL;
    if(type >= CL_AMS_MGMT_OI_EXTENDED_CLASS_MAX || !pConfig || !configSize)
        return;
    clOsalMutexLock(&gClAmsMgmtOICacheMutex);
    table = gClAmsMgmtOIExtendedCacheTable[type];
    if( (cacheEntry = clAmsMgmtOIExtendedCacheFind(table, instance) ) )
    {
        CL_ASSERT(cacheEntry->pConfig != NULL);
        if(cacheEntry->configSize != configSize)
        {
            clHeapFree(cacheEntry->pConfig);
            cacheEntry->pConfig = clHeapCalloc(1, configSize);
            CL_ASSERT(cacheEntry->pConfig != NULL);
            cacheEntry->configSize = configSize;
        }
        memcpy(cacheEntry->pConfig, pConfig, configSize);
    }
    else
    {
        ClAmsMgmtOIExtendedEntityConfigT *pExtendedConfig = NULL;
        cacheEntry = clHeapCalloc(1, sizeof(*cacheEntry));
        CL_ASSERT(cacheEntry != NULL);
        pExtendedConfig = clHeapCalloc(1, configSize);
        CL_ASSERT(pExtendedConfig != NULL);
        cacheEntry->pConfig = pExtendedConfig;
        cacheEntry->instance = instance;
        memcpy(cacheEntry->pConfig, pConfig, configSize);
        hashAdd(table, entityCacheHashKey(instance), &cacheEntry->hash);
        clLogNotice("AMF", "MGMT", "Added entity [%s], instance [%d] to the extended class [%s]",
                    pConfig->entity.name.value, instance, gClAmsMgmtOIExtendedCacheStrTable[type]);
    }
    clOsalMutexUnlock(&gClAmsMgmtOICacheMutex);
}

osm_bind_handle_t
osm_vendor_bind(IN osm_vendor_t * const p_vend,
		IN osm_bind_info_t * const p_bind_info,
		IN osm_mad_pool_t * const p_mad_pool,
		IN osm_vend_mad_recv_callback_t mad_recv_callback,
		IN void *context)
{
	osm_bind_handle_t h_bind;

	OSM_LOG_ENTER(p_vend->p_log);

	CL_ASSERT(p_vend);
	CL_ASSERT(p_bind_info);
	CL_ASSERT(p_mad_pool);
	CL_ASSERT(mad_recv_callback);
	CL_ASSERT(context);

	UNUSED_PARAM(p_vend);
	UNUSED_PARAM(p_mad_pool);
	UNUSED_PARAM(mad_recv_callback);
	UNUSED_PARAM(context);

	h_bind = (osm_bind_handle_t) malloc(sizeof(*h_bind));
	if (h_bind != NULL) {
		memset(h_bind, 0, sizeof(*h_bind));
		h_bind->p_vend = p_vend;
		h_bind->port_guid = p_bind_info->port_guid;
		h_bind->mad_class = p_bind_info->mad_class;
		h_bind->class_version = p_bind_info->class_version;
		h_bind->is_responder = p_bind_info->is_responder;
		h_bind->is_trap_processor = p_bind_info->is_trap_processor;
		h_bind->is_report_processor = p_bind_info->is_report_processor;
		h_bind->send_q_size = p_bind_info->send_q_size;
		h_bind->recv_q_size = p_bind_info->recv_q_size;
	}

	OSM_LOG_EXIT(p_vend->p_log);
	return (h_bind);
}

/*******************************************************************************
Feature API: alarmClockCkptInitialize

*******************************************************************************/
SaAisErrorT
alarmClockCkptInitialize (void)
{
    SaAisErrorT  ret_code = SA_AIS_OK;

    if (ckpt_svc_hdl == 0)
    {
        ret_code = saCkptInitialize(&ckpt_svc_hdl, NULL, &ckpt_version);    
        if (ret_code != SA_AIS_OK)
        {
            alarmClockLogWrite(CL_LOG_SEV_ERROR,
                    "alarmClockCkptInitialize(pid=%d): Failed %x\n", 
                    getpid(), ret_code);
        }
    }    
    sessionInit();
    ClRcT rc = clOsalMutexInit(&alarmClockCkptMutex);
    CL_ASSERT(rc == CL_OK);
    ioVecs = clHeapCalloc(MAX_NUM_IOVECS, sizeof(*ioVecs));
    CL_ASSERT(ioVecs != NULL);
    return ret_code;
}

/*----------------------------------------------------------------------------
 *  Cluster Member Eject Callback Handler
 *---------------------------------------------------------------------------*/
ClRcT clGmsClusterMemberEjectCallbackHandler(
    CL_IN   ClGmsClusterMemberEjectCallbackDataT* const res)
{
    ClRcT rc = CL_OK;
    struct gms_instance *gms_instance_ptr = NULL;
    ClGmsHandleT gmsHandle = CL_GMS_INVALID_HANDLE;
    
    CL_ASSERT(res != NULL);
    
    gmsHandle = res->gmsHandle;
    rc = clHandleCheckout(gmsHandleDb, gmsHandle, (void**)&gms_instance_ptr);
    if (rc != CL_OK)
    {
        goto error_free_res;
    }

    if (gms_instance_ptr == NULL)
    {
        rc = CL_GMS_RC(CL_ERR_NULL_POINTER);
        goto error_free_res;
    }

    
    if (gms_instance_ptr->
                cluster_manage_callbacks.clGmsMemberEjectCallback == NULL)
    {
        rc = CL_GMS_RC(CL_ERR_NO_CALLBACK);
        goto error_checkin_free_res;
    }
    
    /*
     * Calling the user's callback function with the data.  The user cannot
     * free the data we provide.  If it needs to reatin it, it has to copy
     * it out from what we provide here.
     */
    (*gms_instance_ptr->cluster_manage_callbacks.clGmsMemberEjectCallback)
                               (res->reason);
     
error_checkin_free_res:
    if (clHandleCheckin(gmsHandleDb, gmsHandle))
    {
        clLogError(CLM,NA,
                   "\nclHandleCheckin failed");
    }


error_free_res:
    clHeapFree((void*)res);
    
    return rc;
}