C++ clHandleCheckin函数代码示例

ClRcT clMsgQueueAllocateResponseSend_4_0_0(ClIdlHandleT idlHdl,ClRcT retCode,CL_OUT  ClHandleT  pQueueHandle)
{
    ClIdlSyncInfoT    *pIdlSyncDeferInfo = NULL;
    ClRcT              rc                = CL_OK;
    ClBufferHandleT outMsgHdl     = 0;
    
    rc = clHandleCheckout(msgIdlidlDatabaseHdl,idlHdl,(void **)&pIdlSyncDeferInfo);
    if( rc != CL_OK)
    {
      goto Label0; 
    }
    outMsgHdl = pIdlSyncDeferInfo->idlRmdDeferMsg;
    
    rc = clXdrMarshallClHandleT(&(pQueueHandle), outMsgHdl, 1);
    if (CL_OK != rc)
    {
        goto L4;
    }

    rc = clIdlSyncResponseSend(pIdlSyncDeferInfo->idlRmdDeferHdl,outMsgHdl,
                                retCode);
    goto Label1; 
L4:  clXdrMarshallClHandleT(&(pQueueHandle), 0, 1);

    clHandleCheckin(msgIdlidlDatabaseHdl, idlHdl);
    clHandleDestroy(msgIdlidlDatabaseHdl, idlHdl);
    return rc;
Label1:
    clHandleCheckin(msgIdlidlDatabaseHdl, idlHdl);
    clHandleDestroy(msgIdlidlDatabaseHdl, idlHdl);
Label0:
    return rc;
}

ClRcT clMsgQueueStatusGetResponseSend_4_0_0(ClIdlHandleT idlHdl,ClRcT retCode,CL_OUT  SaMsgQueueStatusT_4_0_0  pQueueStatus)
{
    ClIdlSyncInfoT    *pIdlSyncDeferInfo = NULL;
    ClRcT              rc                = CL_OK;
    ClBufferHandleT outMsgHdl     = 0;
    
    rc = clHandleCheckout(msgCltSrvidlDatabaseHdl,idlHdl,(void **)&pIdlSyncDeferInfo);
    if( rc != CL_OK)
    {
      goto Label0; 
    }
    outMsgHdl = pIdlSyncDeferInfo->idlRmdDeferMsg;
    
    rc = clXdrMarshallSaMsgQueueStatusT_4_0_0(&(pQueueStatus), outMsgHdl, 1);
    if (CL_OK != rc)
    {
        goto L2;
    }

    rc = clIdlSyncResponseSend(pIdlSyncDeferInfo->idlRmdDeferHdl,outMsgHdl,
                                retCode);
    goto Label1; 
L2:  clXdrMarshallSaMsgQueueStatusT_4_0_0(&(pQueueStatus), 0, 1);

    clHandleCheckin(msgCltSrvidlDatabaseHdl, idlHdl);
    clHandleDestroy(msgCltSrvidlDatabaseHdl, idlHdl);
    return rc;
Label1:
    clHandleCheckin(msgCltSrvidlDatabaseHdl, idlHdl);
    clHandleDestroy(msgCltSrvidlDatabaseHdl, idlHdl);
Label0:
    return rc;
}

/*-----------------------------------------------------------------------------
 * Finalize API
 *---------------------------------------------------------------------------*/
ClRcT clGmsFinalize(
    CL_IN const ClGmsHandleT gmsHandle)
{
	struct gms_instance *gms_instance_ptr = NULL;
	ClRcT rc= CL_OK;

	rc = clHandleCheckout(gmsHandleDb, gmsHandle, (void **)&gms_instance_ptr);
    if (rc != CL_OK)
    {
        return CL_GMS_RC(CL_ERR_INVALID_HANDLE);
    }

    if (gms_instance_ptr == NULL)
    {
        return CL_GMS_RC(CL_ERR_NULL_POINTER);
    }

    rc = clGmsMutexLock(gms_instance_ptr->response_mutex);
    if(rc != CL_OK)
    {
        return rc;
    }

	/*
	 * Another thread has already started finalizing
	 */
	if (gms_instance_ptr->finalize) {
		clGmsMutexUnlock(gms_instance_ptr->response_mutex);
		if ((clHandleCheckin(gmsHandleDb, gmsHandle)) != CL_OK)
        {
            clLogError(GEN,DB,
                       "\nclHandleCheckin Error");
        }
		return CL_GMS_RC(CL_ERR_INVALID_HANDLE);
	}

	gms_instance_ptr->finalize = 1;

	clGmsMutexUnlock(gms_instance_ptr->response_mutex);
	clGmsMutexDelete(gms_instance_ptr->response_mutex);
    
	if ((clHandleDestroy(gmsHandleDb, gmsHandle)) != CL_OK)
    {
        clLogError(GEN,NA,
                   "\nclHandleDestroy Error");
    }
    
	if ((clHandleCheckin(gmsHandleDb, gmsHandle)) != CL_OK)
    {
        clLogError(GEN,NA,
                   "\nclHandleCheckin Error");
    }

	return CL_GMS_RC(rc);
}

ClRcT clCkptRemSvrWelcomeResponseSend_5_1_0(ClIdlHandleT idlHdl,ClRcT retCode,CL_INOUT  ClVersionT  pVersion)
{
    ClIdlSyncInfoT    *pIdlSyncDeferInfo = NULL;
    ClRcT              rc                = CL_OK;
    ClBufferHandleT outMsgHdl     = 0;
    
    rc = clHandleCheckout(ckptEoidlDatabaseHdl,idlHdl,(void **)&pIdlSyncDeferInfo);
    if( rc != CL_OK)
    {
      goto Label0; 
    }
    outMsgHdl = pIdlSyncDeferInfo->idlRmdDeferMsg;
    
    rc = clXdrMarshallClVersionT(&(pVersion), outMsgHdl, 1);
    if (CL_OK != rc)
    {
        goto L3;
    }

    rc = clIdlSyncResponseSend(pIdlSyncDeferInfo->idlRmdDeferHdl,outMsgHdl,
                                retCode);
    
L3:  clXdrMarshallClVersionT(&(pVersion), 0, 1);

    

    clHandleCheckin(ckptEoidlDatabaseHdl, idlHdl);
    clHandleDestroy(ckptEoidlDatabaseHdl, idlHdl);
Label0:
    return rc;
}

ClRcT clLogMasterCompIdChkNGetResponseSend_4_0_0(ClIdlHandleT idlHdl,ClRcT retCode,CL_INOUT  ClUint32T  pClientId)
{
    ClIdlSyncInfoT    *pIdlSyncDeferInfo = NULL;
    ClRcT              rc                = CL_OK;
    ClBufferHandleT outMsgHdl     = 0;
    
    rc = clHandleCheckout(LogidlDatabaseHdl,idlHdl,(void **)&pIdlSyncDeferInfo);
    if( rc != CL_OK)
    {
      goto Label0; 
    }
    outMsgHdl = pIdlSyncDeferInfo->idlRmdDeferMsg;
    
    rc = clXdrMarshallClUint32T(&(pClientId), outMsgHdl, 1);
    if (CL_OK != rc)
    {
        goto L2;
    }

    rc = clIdlSyncResponseSend(pIdlSyncDeferInfo->idlRmdDeferHdl,outMsgHdl,
                                retCode);
    
L2:  clXdrMarshallClUint32T(&(pClientId), 0, 1);

    

    clHandleCheckin(LogidlDatabaseHdl, idlHdl);
    clHandleDestroy(LogidlDatabaseHdl, idlHdl);
Label0:
    return rc;
}

ClRcT clMsgMessageCancel(SaMsgQueueHandleT qHandle)
{
    ClRcT rc;
    ClRcT retCode;
    ClMsgQueueInfoT *pQInfo;

    CL_OSAL_MUTEX_LOCK(&gClLocalQsLock);
    rc = clHandleCheckout(gClMsgQDatabase, qHandle, (void**)&pQInfo);
    if(rc != CL_OK)
    {
        CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock);
        clLogError("MSG", "CANL", "Failed to checkout the passed handle. error code [0x%x].", rc);
        goto error_out;
    }

    CL_OSAL_MUTEX_LOCK(&pQInfo->qLock);
    CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock);

    rc = clMsgUnblockThreadsOfQueue(pQInfo);

    CL_OSAL_MUTEX_UNLOCK(&pQInfo->qLock);

    retCode = clHandleCheckin(gClMsgQDatabase, qHandle);
    if(retCode != CL_OK)
        clLogError("QUE", "CANL", "Failed to checkin queue handle. error code [0x%x].", retCode);

error_out:
    return rc;
}

ClRcT clMsgQueueFreeByHandle(SaMsgQueueHandleT qHandle)
{
    ClRcT rc;
    ClMsgQueueInfoT *pQInfo;

    CL_OSAL_MUTEX_LOCK(&gClLocalQsLock);

    rc = clHandleCheckout(gClMsgQDatabase, qHandle, (ClPtrT *)&pQInfo);
    if(rc != CL_OK)
    {
        CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock);
        clLogError("QUE", "FREE", "Failed at checkout the passed queue handle. error code [0x%x].", rc);
        goto error_out;
    }

    clMsgQueueFree(pQInfo);
    clLogDebug("QUE", "FREE", "Queue is freed through its handle."); 

    CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock);

    rc = clHandleCheckin(gClMsgQDatabase, qHandle);
    if(rc != CL_OK)
        clLogError("QUE", "FREE", "Failed to checkin a queue handle. error code [0x%x].", rc);

    rc = clHandleDestroy(gClMsgQDatabase, qHandle);
    if(rc != CL_OK)
        clLogError("QUE", "FREE", "Failed to destroy a queue handle. error code [0x%x].", rc);

error_out:
    return rc;

}

SaAisErrorT
saClmSelectionObjectGet (
        const SaClmHandleT clmHandle,
        SaSelectionObjectT*const selectionObject
        )
{
    ClRcT rc;
    ClHandleT   localHandle = CL_HANDLE_INVALID_VALUE;
    SaClmInstanceT      *clmInstance = NULL;

    SA_GMS_CHECK_INIT_COUNT();

    /* Check the validity of the handle */
    localHandle = (ClHandleT)clmHandle;
    rc = clHandleCheckout(databaseHandle, localHandle, (void**)&clmInstance);
    if (rc != CL_OK)
    {
        return _aspErrToAisErr(rc);
    }
    CL_ASSERT(clmInstance != NULL);

    
    rc = clDispatchSelectionObjectGet(
                        clmInstance->dispatchHandle,
                        selectionObject);

    if ((clHandleCheckin(databaseHandle, localHandle)) != CL_OK)
    {
        clLogError(GMS_LOG_AREA_CLM,CL_LOG_CONTEXT_UNSPECIFIED,
                   "clHandleCheckin failed");
    }

    return _aspErrToAisErr(rc);
}

SaAisErrorT
saClmClusterNodeGetAsync (
        const SaClmHandleT clmHandle,
        const SaInvocationT invocation,
        const SaClmNodeIdT nodeId)
{
    ClRcT rc;
    ClHandleT   localHandle = CL_HANDLE_INVALID_VALUE;
    SaClmInstanceT      *clmInstance = NULL;

    SA_GMS_CHECK_INIT_COUNT();

    /* Check the validity of the handle */
    localHandle = (ClHandleT)clmHandle;
    rc = clHandleCheckout(databaseHandle, localHandle, (void**)&clmInstance);
    if (rc != CL_OK)
    {
        return _aspErrToAisErr(rc);
    }
    CL_ASSERT(clmInstance != NULL);

    rc = clGmsClusterMemberGetAsync(localHandle,
                invocation,
                (ClGmsMemberIdT)nodeId); 

    if ((clHandleCheckin(databaseHandle, localHandle)) != CL_OK)
    {
        clLogError(GMS_LOG_AREA_CLM,CL_LOG_CONTEXT_UNSPECIFIED,
                   "clHandleCheckin failed");
    }

    return _aspErrToAisErr(rc);
}

ClRcT clLogMasterCompListGetResponseSend_4_0_0(ClIdlHandleT idlHdl,ClRcT retCode,CL_OUT  ClUint32T  pNumStreams,CL_OUT  ClUint32T  pBuffLen,ClUint8T*  pBuffer)
{
    ClIdlSyncInfoT    *pIdlSyncDeferInfo = NULL;
    ClRcT              rc                = CL_OK;
    ClBufferHandleT outMsgHdl     = 0;
    
    rc = clHandleCheckout(LogidlDatabaseHdl,idlHdl,(void **)&pIdlSyncDeferInfo);
    if( rc != CL_OK)
    {
      goto Label0; 
    }
    outMsgHdl = pIdlSyncDeferInfo->idlRmdDeferMsg;
    
    rc = clXdrMarshallClUint32T(&(pNumStreams), outMsgHdl, 1);
    if (CL_OK != rc)
    {
        goto L1;
    }

    rc = clXdrMarshallClUint32T(&(pBuffLen), outMsgHdl, 1);
    if (CL_OK != rc)
    {
        goto L2;
    }

    rc = clXdrMarshallPtrClUint8T(pBuffer, pBuffLen, outMsgHdl, 1);
    if (CL_OK != rc)
    {
        goto L3;
    }

    rc = clIdlSyncResponseSend(pIdlSyncDeferInfo->idlRmdDeferHdl,outMsgHdl,
                                retCode);
    goto Label1; 
L1:  clXdrMarshallClUint32T(&(pNumStreams), 0, 1);
L2:  clXdrMarshallClUint32T(&(pBuffLen), 0, 1);
L3:  clXdrMarshallPtrClUint8T(pBuffer, pBuffLen, 0, 1);

    clHandleCheckin(LogidlDatabaseHdl, idlHdl);
    clHandleDestroy(LogidlDatabaseHdl, idlHdl);
    return rc;
Label1:
    clHandleCheckin(LogidlDatabaseHdl, idlHdl);
    clHandleDestroy(LogidlDatabaseHdl, idlHdl);
Label0:
    return rc;
}

/*-----------------------------------------------------------------------------
 * Cluster Leader Elect API
 *---------------------------------------------------------------------------*/
ClRcT clGmsClusterLeaderElect(
    CL_IN const ClGmsHandleT                      gmsHandle,
    CL_IN const ClGmsNodeIdT                      preferredLeader,
    CL_INOUT    ClGmsNodeIdT                     *leader,
    CL_INOUT    ClGmsNodeIdT                     *deputy,
    CL_INOUT    ClBoolT                          *leadershipChanged)
{
    ClRcT                                rc = CL_OK;
    struct gms_instance                 *gms_instance_ptr = NULL;
    ClGmsClusterLeaderElectRequestT      req = {0};
    ClGmsClusterLeaderElectResponseT    *res = NULL;
    
    if ((leader == NULL) || (deputy == NULL) || (leadershipChanged == NULL))
    {
        return CL_GMS_RC(CL_ERR_NULL_POINTER);
    }

    CL_GMS_SET_CLIENT_VERSION( req );
    rc = clHandleCheckout(gmsHandleDb, gmsHandle, (void**)&gms_instance_ptr);
    if (rc != CL_OK)
    {
        return rc;
    }

    if (gms_instance_ptr == NULL)
    {
        return CL_GMS_RC(CL_ERR_NULL_POINTER);
    }

    
    clGmsMutexLock( gms_instance_ptr->response_mutex);
    req.gmsHandle = gmsHandle;
    req.preferredLeaderNode = preferredLeader;
    
    rc = cl_gms_cluster_leader_elect_rmd(&req, 0 /* use def. timeout */, &res);
    if ((rc != CL_OK) || (res == NULL)) /* If there was an error, res isn't allocated */
    {
        goto error_unlock_checkin;
    }
    
    rc = res->rc;
    *leader = res->leader;
    *deputy = res->deputy;
    *leadershipChanged = res->leadershipChanged;
    
    clHeapFree((void*)res);
    
error_unlock_checkin:
    clGmsMutexUnlock(gms_instance_ptr->response_mutex);
    
    if (clHandleCheckin(gmsHandleDb, gmsHandle) != CL_OK)
    {
        clLogError(LEA,NA,
                   "\nclHandleCheckin failed");
    }

    
    return rc;
}

/*-----------------------------------------------------------------------------
 * Cluster Member Get Async API
 *---------------------------------------------------------------------------*/
ClRcT clGmsClusterMemberGetAsync(
    CL_IN const ClGmsHandleT   gmsHandle,
    CL_IN const ClInvocationT  invocation,
    CL_IN const ClGmsNodeIdT   nodeId)
{
    ClRcT                                rc = CL_OK;
    struct gms_instance                 *gms_instance_ptr = NULL;
    ClGmsClusterMemberGetAsyncRequestT   req = {0};
    ClGmsClusterMemberGetAsyncResponseT *res = NULL;
        
    CL_GMS_SET_CLIENT_VERSION( req );
    rc = clHandleCheckout(gmsHandleDb, gmsHandle, (void**)&gms_instance_ptr);
    if (rc != CL_OK)
    {
        return rc;
    }
    if (gms_instance_ptr == NULL)
    {
        return CL_GMS_RC(CL_ERR_NULL_POINTER);
    }

    if (gms_instance_ptr->callbacks.clGmsClusterMemberGetCallback == NULL)
    {
        rc = CL_GMS_RC(CL_ERR_NO_CALLBACK);
        goto error_checkin;
    }
    
    req.gmsHandle  = gmsHandle;
    req.nodeId     = nodeId;
    req.invocation = invocation;
    req.address.iocPhyAddress.nodeAddress = clIocLocalAddressGet();
    rc = clEoMyEoIocPortGet(&(req.address.iocPhyAddress.portId));
    if (rc != CL_OK)
    {
        goto error_checkin;
    }
    
    clGmsMutexLock(gms_instance_ptr->response_mutex);
    
    rc = cl_gms_cluster_member_get_async_rmd(&req, 0 /* use def. timeout */,
                                             &res);
    if (rc != CL_OK) /* If there was an error, res isn't allocated */
    {
        goto error_unlock_checkin;
    }

error_unlock_checkin:
    clGmsMutexUnlock(gms_instance_ptr->response_mutex);
    
error_checkin:
    if (clHandleCheckin(gmsHandleDb, gmsHandle) != CL_OK)
    {
        clLogError(CLM,NA,
                    "\nclHandleCheckin failed");
    }
    
    return rc;
}

/*
 * Frees up the handle database specified by databaseHandle.  If the handle
 * database is empty, it frees up the database immediately.  Otherwise,
 * it will mark the database for deletion and free it when the last entry
 * is deleted.
 */
ClRcT
clHandleDatabaseDestroy(ClHandleDatabaseHandleT databaseHandle)
{
    ClHdlDatabaseT *hdbp   = (ClHdlDatabaseT*)databaseHandle;
    ClRcT          ec      = CL_OK;
    ClHandleT      handle  = 0;
    
    hdlDbValidityChk(hdbp);
    
    ec = pthread_mutex_lock(&hdbp->mutex);
    if (ec != 0)
    {
        return CL_HANDLE_RC(CL_ERR_MUTEX_ERROR);
    }
    clDbgResourceNotify(clDbgHandleGroupResource, clDbgRelease, 0, hdbp, ("Handle database %p released", (ClPtrT) hdbp));
    /*
     * Go thru the list of handles and delete everything, if they have not
     * been cleaned up properly, through warning message and destroy the
     * database
     */
    if (hdbp->n_handles_used > 0) /* database is not empty */
    {
       for( handle = 0; handle < hdbp->n_handles; handle++)
       {
           if( hdbp->handles[handle].state != HANDLE_STATE_EMPTY )
           {
               /* explicitly making '0' for smooth removal of handles */
               hdbp->handles[handle].ref_count = 1;
               hdbp->handles[handle].state     = HANDLE_STATE_PENDINGREMOVAL;
               ec = pthread_mutex_unlock(&hdbp->mutex);
               if( ec != 0 )
               {
                   /* Who cares about the error code, during shut down */
                   goto free_exit;          
               }
               clLogWarning(CL_HDL_AREA, CL_HDL_CTX_DBDESTROY, 
                            "Handle [%p:%#llX] has not been cleaned, destroying...",
                            (ClPtrT) hdbp, (handle + 1));
               clHandleCheckin(databaseHandle, handle + 1);
               ec = pthread_mutex_lock(&hdbp->mutex);
               if( ec != 0 )
               {
                   goto free_exit;
               }
           }
       }
    }
    /* Explicitly not checking the error code */    
    pthread_mutex_unlock(&hdbp->mutex);
free_exit:    
    if( NULL != hdbp->handles )
    {
        free(hdbp->handles); 
    }
    hdbp->pValidDb = (void *) CL_HDL_INVALID_COOKIE; 
    clHeapFree(hdbp);
    return CL_OK;
}

ClRcT
clLogInitHandleBitmapFileRemove(ClLogHandleT      hLog, 
                                ClLogFileHandleT  hFileHdlr)
{
    ClRcT                  rc            = CL_OK;
    ClLogInitHandleDataT  *pData         = NULL;
    ClLogClntEoDataT      *pClntEoEntry  = NULL;

    CL_LOG_DEBUG_TRACE(("Enter"));
        
    rc = clLogClntEoEntryGet(&pClntEoEntry);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clLogClntEoEntryGet(): rc[0x %x]", rc));
        return rc;
    }

    rc = clHandleCheckout(pClntEoEntry->hClntHandleDB, hLog,
                          (void **) (&pData)); 
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clHandleCheckout(): rc[0x %x]\n", rc));
        return rc;
    }

    rc = clBitmapBitClear(pData->hStreamBitmap, hFileHdlr);
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clBitmapBitSet(): rc[0x %x]", rc));
        CL_LOG_CLEANUP(clHandleCheckin(pClntEoEntry->hClntHandleDB, hLog),
                       CL_OK);
        return rc;
    }

    rc = clHandleCheckin(pClntEoEntry->hClntHandleDB, hLog); 
    if( CL_OK != rc )
    {
        CL_LOG_DEBUG_ERROR(("clHandleCheckin(): rc[0x %x]", rc));
        return rc;
    }

    CL_LOG_DEBUG_TRACE(("Exit"));
    return rc;
} 

ClRcT
clDebugContexDetailsPack(ClHandleDatabaseHandleT  hHandleDB,
                         ClHandleT                handle,
                         ClPtrT                   pData)
{
    ClRcT              rc          = CL_OK;
    ClBufferHandleT    outMsgHdl   = (ClBufferHandleT) pData;
    ClDebugFuncGroupT  *pFuncGroup = NULL;
    ClUint32T          i           = 0;

    rc = clHandleCheckout(hHandleDB, handle, (void *) &pFuncGroup); 
    if( CL_OK != rc )
    {
        CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clHandleCheckout(): rc[0x %x]", rc));
        return rc;
    }

    for (i = 0; i < pFuncGroup->numFunc; i++)
    {
        rc = clXdrMarshallArrayClCharT(pFuncGroup->pFuncDescList[i].funcName,
                                       CL_DEBUG_FUNC_NAME_LEN,
                                       outMsgHdl,0);
        if (CL_OK != rc)
        {
            clHandleCheckin(hHandleDB, handle);
            return rc;
        }

        rc = clXdrMarshallArrayClCharT(pFuncGroup->pFuncDescList[i].funcHelp,
                                       CL_DEBUG_FUNC_HELP_LEN,
                                       outMsgHdl,0);
        
        if (CL_OK != rc)
        {
            clHandleCheckin(hHandleDB, handle);
            return rc;
        }
    }

    clHandleCheckin(hHandleDB, handle);

    return rc;
}