ClRcT __cosPosixMutexUnlock (ClOsalMutexIdT mutexId, ClBoolT verbose) { ClRcT rc = CL_OK; ClUint32T retCode = 0; ClOsalMutexT* pMutex = (ClOsalMutexT*) mutexId; ClInt32T err = 0; CL_FUNC_ENTER(); if (NULL == pMutex) { retCode = CL_OSAL_RC(CL_ERR_NULL_POINTER); if(verbose) { clLogError(CL_LOG_AREA_UNSPECIFIED, CL_LOG_CONTEXT_UNSPECIFIED,"Mutex Unlock : FAILED, mutex is NULL (used after delete?)"); clDbgPause(); } CL_FUNC_EXIT(); return(retCode); } retry: err = sem_post(&pMutex->shared_lock.sem.posSem); if(err < 0) { if(errno == EINTR) { goto retry; } rc = CL_OSAL_RC(CL_ERR_LIBRARY); if(verbose) { clDbgCodeError(rc,("sem_post unlock returned [%s]\n",strerror(errno))); } } CL_FUNC_EXIT(); return (rc); }
ClRcT clHandleMove( ClHandleDatabaseHandleT databaseHandle, ClHandleT oldHandle, ClHandleT newHandle) { void *instance = NULL; ClRcT rc = CL_OK; ClHdlDatabaseT *hdbp = (ClHdlDatabaseT*) databaseHandle; ClRcT ec = CL_OK; hdlDbValidityChk(hdbp); /* We allow handles to be created that are pointing to some other handle DB and node hdlValidityChk(handle,hdbp); */ oldHandle = CL_HDL_IDX(oldHandle); /* once we've verified it, we only care about the index */ newHandle = CL_HDL_IDX(newHandle); if (CL_HANDLE_INVALID_VALUE == oldHandle || CL_HANDLE_INVALID_VALUE == newHandle) { clLogError("HDL", "MOVE", "Passed [%s] handle is invalid", oldHandle ? "new" : "old"); clDbgPause(); return CL_HANDLE_RC(CL_ERR_INVALID_HANDLE); /* 0 no longer allowed */ } /* * Decrementing handle to ensure the non-zero handle interface. */ --oldHandle; --newHandle; ec = pthread_mutex_lock (&hdbp->mutex); if (ec != 0) { return CL_HANDLE_RC(CL_ERR_MUTEX_ERROR); } if(oldHandle >= hdbp->n_handles) { pthread_mutex_unlock(&hdbp->mutex); clLogError("HDL", "MOVE", "Old handle [%#llx] passed is invalid", oldHandle); return CL_HANDLE_RC(CL_ERR_INVALID_HANDLE); } if(hdbp->handles[oldHandle].ref_count != 1) { pthread_mutex_unlock(&hdbp->mutex); clLogError("HDL", "MOVE", "Old handle [%#llx] is %s", oldHandle, hdbp->handles[oldHandle].ref_count < 1 ? "invalid" : "in use"); return CL_HANDLE_RC(CL_ERR_INVALID_STATE); } if(newHandle < hdbp->n_handles && hdbp->handles[newHandle].ref_count > 0) { pthread_mutex_unlock(&hdbp->mutex); clLogError("HDL", "MOVE", "New handle [%#llx] is in use", newHandle); return CL_HANDLE_RC(CL_ERR_ALREADY_EXIST); } instance = hdbp->handles[oldHandle].instance; if(!instance) { pthread_mutex_unlock(&hdbp->mutex); clLogError("HDL", "MOVE", "Old handle [%#llx] instance is NULL", oldHandle); return CL_HANDLE_RC(CL_ERR_INVALID_STATE); } if(newHandle >= hdbp->n_handles) { /* * Allocating space in Excess of to accomodate the value specified by the user. * NOTE: User should ensure that a sane value is supplied for handle. */ ClHandleT excess_handles = newHandle - hdbp->n_handles + 1; ClHdlEntryT *new_handles = (ClHdlEntryT *)realloc (hdbp->handles, sizeof (ClHdlEntryT) * (hdbp->n_handles+excess_handles)); if (new_handles == NULL) { ec = pthread_mutex_unlock (&hdbp->mutex); if (ec != 0) { return CL_HANDLE_RC(CL_ERR_MUTEX_ERROR); /* This can be very bad */ } return CL_HANDLE_RC(CL_ERR_NO_MEMORY); } /* * Initialize the excess space. HANDLE_STATE_EMPTY will remain 0 * is assumed else need to set the excess entries explicitly in a * loop. */ memset(&new_handles[hdbp->n_handles], 0, sizeof (ClHdlEntryT) * excess_handles); /* Update the values if success */ hdbp->n_handles += excess_handles; hdbp->handles = new_handles; } /* * Reset the old handle */ memset(&hdbp->handles[oldHandle], 0, sizeof(hdbp->handles[oldHandle])); hdbp->handles[newHandle].state = HANDLE_STATE_USED; hdbp->handles[newHandle].instance = instance; hdbp->handles[newHandle].ref_count = 1; hdbp->handles[newHandle].handle = CL_HDL_MAKE_ADDR(ASP_NODEADDR, gEOIocPort, hdbp->id, newHandle + 1);; clDbgResourceNotify(clDbgHandleResource, clDbgAllocate, hdbp, newHandle+1, ("Specific handle [%p:%#llx] allocated", (ClPtrT) hdbp, newHandle+1)); ec = pthread_mutex_unlock (&hdbp->mutex); if (ec != 0) { return CL_HANDLE_RC(CL_ERR_MUTEX_ERROR); /* This can be devastating */ } return rc; }
ClRcT clHandleCreateSpecifiedHandle ( ClHandleDatabaseHandleT databaseHandle, ClInt32T instance_size, ClHandleT handle) { void *instance = NULL; ClRcT rc = CL_OK; ClHdlDatabaseT *hdbp = (ClHdlDatabaseT*) databaseHandle; ClRcT ec = CL_OK; ClHandleT orgHandle = handle; hdlDbValidityChk(hdbp); /* We allow handles to be created that are pointing to some other handle DB and node hdlValidityChk(handle,hdbp); */ handle = CL_HDL_IDX(handle); /* once we've verified it, we only care about the index */ if (CL_HANDLE_INVALID_VALUE == handle) { clLogError("HDL", CL_LOG_CONTEXT_UNSPECIFIED, "Passed handle [%p:%#llX] is an invalid handle", (ClPtrT) hdbp, handle); clDbgPause(); return CL_HANDLE_RC(CL_ERR_INVALID_HANDLE); /* 0 no longer allowed */ } /* * Decrementing handle to ensure the non-zero handle interface. */ handle--; ec = pthread_mutex_lock (&hdbp->mutex); if (ec != 0) { return CL_HANDLE_RC(CL_ERR_MUTEX_ERROR); } if(handle >= hdbp->n_handles) { /* * Allocating space in Excess of to accomodate the value specified by the user. * NOTE: User should ensure that a sane value is supplied for handle. */ ClHandleT excess_handles = handle - hdbp->n_handles + 1; ClHdlEntryT *new_handles = (ClHdlEntryT *)realloc (hdbp->handles, sizeof (ClHdlEntryT) * (hdbp->n_handles+excess_handles)); if (new_handles == 0) { ec = pthread_mutex_unlock (&hdbp->mutex); if (ec != 0) { return CL_HANDLE_RC(CL_ERR_MUTEX_ERROR); /* This can be very bad */ } return CL_HANDLE_RC(CL_ERR_NO_MEMORY); } /* * Initialize the excess space. HANDLE_STATE_EMPTY will remain 0 * is assumed else need to set the excess entries explicitly in a * loop. */ memset(&new_handles[hdbp->n_handles], 0, sizeof (ClHdlEntryT) * excess_handles); /* Update the values if success */ hdbp->n_handles += excess_handles; hdbp->handles = new_handles; } if (hdbp->handles[handle].state != HANDLE_STATE_EMPTY) { /* * The specified handle already in use so return the specific error. */ rc = CL_HANDLE_RC(CL_ERR_ALREADY_EXIST); goto error_exit; } instance = clHeapCalloc (1, instance_size); if (instance == 0) { rc = CL_HANDLE_RC(CL_ERR_NO_MEMORY); goto error_exit; } memset (instance, 0, instance_size); hdbp->handles[handle].state = HANDLE_STATE_USED; hdbp->handles[handle].instance = instance; hdbp->handles[handle].ref_count = 1; hdbp->handles[handle].handle = orgHandle; clDbgResourceNotify(clDbgHandleResource, clDbgAllocate, hdbp, handle+1, ("Specific handle [%p:%#llX] allocated", (ClPtrT) hdbp, handle+1)); hdbp->n_handles_used++; error_exit: ec = pthread_mutex_unlock (&hdbp->mutex); if (ec != 0) { return CL_HANDLE_RC(CL_ERR_MUTEX_ERROR); /* This can be devastating */ } return rc; }