int
NdbCondition_WaitTimeout(struct NdbCondition* p_cond,
NdbMutex* p_mutex,
int msecs)
{
int result;
int bLastWaiter;
if (!p_cond || !p_mutex)
return 1;
NdbMutex_Lock(p_cond->pNdbMutexWaitersLock);
p_cond->nWaiters++;
NdbMutex_Unlock(p_cond->pNdbMutexWaitersLock);
if(msecs<0)
msecs = 0;
if(NdbMutex_Unlock(p_mutex))
return -1;
result = WaitForSingleObject(p_cond->hSemaphore, msecs);
NdbMutex_Lock(p_cond->pNdbMutexWaitersLock);
p_cond->nWaiters--;
bLastWaiter = (p_cond->bWasBroadcast && p_cond->nWaiters==0);
NdbMutex_Unlock(p_cond->pNdbMutexWaitersLock);
if(result!=WAIT_OBJECT_0)
result = -1;
if(bLastWaiter)
SetEvent(p_cond->hEventWaitersDone);
NdbMutex_Lock(p_mutex);
return result;
}
int
NdbCondition_Wait(struct NdbCondition* p_cond,
NdbMutex* p_mutex)
{
int result;
int bLastWaiter;
if(!p_cond || !p_mutex)
return 1;
NdbMutex_Lock(p_cond->pNdbMutexWaitersLock);
p_cond->nWaiters++;
NdbMutex_Unlock(p_cond->pNdbMutexWaitersLock);
if(NdbMutex_Unlock(p_mutex))
return -1;
result = WaitForSingleObject (p_cond->hSemaphore, INFINITE);
NdbMutex_Lock(p_cond->pNdbMutexWaitersLock);
p_cond->nWaiters--;
bLastWaiter = (p_cond->bWasBroadcast && p_cond->nWaiters==0);
NdbMutex_Unlock(p_cond->pNdbMutexWaitersLock);
if(result==WAIT_OBJECT_0 && bLastWaiter)
SetEvent(p_cond->hEventWaitersDone);
NdbMutex_Lock(p_mutex);
return result;
}
void MultiNdbWakeupHandler::registerNdb(Ndb *obj, Uint32 pos)
{
NdbMutex_Lock(obj->theImpl->m_mutex);
obj->theImpl->wakeHandler = this;
/* It may already have some completed transactions */
if (obj->theNoOfCompletedTransactions)
{
NdbMutex_Lock(localWakeupMutexPtr);
numNdbsWithCompletedTrans++;
NdbMutex_Unlock(localWakeupMutexPtr);
}
NdbMutex_Unlock(obj->theImpl->m_mutex);
}
void NDBT_Context::setProperty(const char* _name, const char* _val){
NdbMutex_Lock(propertyMutexPtr);
const bool b = props.put(_name, _val, true);
require(b == true);
NdbCondition_Broadcast(propertyCondPtr);
NdbMutex_Unlock(propertyMutexPtr);
}
void
ArbitMgr::threadMain()
{
ArbitSignal aSignal;
aSignal = theInputBuffer;
threadStart(aSignal);
bool stop = false;
while (! stop) {
NdbMutex_Lock(theInputMutex);
while (! theInputFull) {
NdbCondition_WaitTimeout(theInputCond, theInputMutex, theInputTimeout);
threadTimeout();
}
aSignal = theInputBuffer;
theInputFull = false;
NdbCondition_Signal(theInputCond);
NdbMutex_Unlock(theInputMutex);
switch (aSignal.gsn) {
case GSN_ARBIT_CHOOSEREQ:
threadChoose(aSignal);
break;
case GSN_ARBIT_STOPORD:
stop = true;
break;
}
}
threadStop(aSignal);
}
void
AsyncFile::doStart()
{
// Stacksize for filesystem threads
#if !defined(DBUG_OFF) && defined (__hpux)
// Empirical evidence indicates at least 32k
const NDB_THREAD_STACKSIZE stackSize = 32768;
#else
// Otherwise an 8k stack should be enough
const NDB_THREAD_STACKSIZE stackSize = 8192;
#endif
char buf[16];
numAsyncFiles++;
BaseString::snprintf(buf, sizeof(buf), "AsyncFile%d", numAsyncFiles);
theStartMutexPtr = NdbMutex_Create();
theStartConditionPtr = NdbCondition_Create();
NdbMutex_Lock(theStartMutexPtr);
theStartFlag = false;
theThreadPtr = NdbThread_Create(runAsyncFile,
(void**)this,
stackSize,
(char*)&buf,
NDB_THREAD_PRIO_MEAN);
if (theThreadPtr == 0)
ERROR_SET(fatal, NDBD_EXIT_MEMALLOC, "","Could not allocate file system thread");
NdbCondition_Wait(theStartConditionPtr,
theStartMutexPtr);
NdbMutex_Unlock(theStartMutexPtr);
NdbMutex_Destroy(theStartMutexPtr);
NdbCondition_Destroy(theStartConditionPtr);
}
void
AsyncFile::doStart(Uint32 nodeId,
const char * filesystemPath,
const char * backup_path) {
theFileName.init(nodeId, filesystemPath, backup_path);
// Stacksize for filesystem threads
// An 8k stack should be enough
const NDB_THREAD_STACKSIZE stackSize = 8192;
char buf[16];
numAsyncFiles++;
BaseString::snprintf(buf, sizeof(buf), "AsyncFile%d", numAsyncFiles);
theStartMutexPtr = NdbMutex_Create();
theStartConditionPtr = NdbCondition_Create();
NdbMutex_Lock(theStartMutexPtr);
theStartFlag = false;
theThreadPtr = NdbThread_Create(runAsyncFile,
(void**)this,
stackSize,
(char*)&buf,
NDB_THREAD_PRIO_MEAN);
NdbCondition_Wait(theStartConditionPtr,
theStartMutexPtr);
NdbMutex_Unlock(theStartMutexPtr);
NdbMutex_Destroy(theStartMutexPtr);
NdbCondition_Destroy(theStartConditionPtr);
}
void
NdbPool::return_ndb_object(Ndb* returned_ndb, Uint32 id)
{
NdbMutex_Lock(pool_mutex);
assert(id <= m_max_ndb_objects);
assert(id != 0);
assert(returned_ndb == m_pool_reference[id].ndb_reference);
bool wait_cond = m_waiting;
if (wait_cond) {
NdbCondition* pool_cond;
if (m_signal_count > 0) {
pool_cond = output_pool_cond;
m_signal_count--;
} else {
pool_cond = input_pool_cond;
}
add_wait_list(id);
NdbMutex_Unlock(pool_mutex);
NdbCondition_Signal(pool_cond);
} else {
add_free_list(id);
add_db_hash(id);
NdbMutex_Unlock(pool_mutex);
}
}
NdbPool*
NdbPool::create_instance(Ndb_cluster_connection* cc,
Uint32 max_ndb_obj,
Uint32 no_conn_obj,
Uint32 init_no_ndb_objects)
{
if (!initPoolMutex()) {
return NULL;
}
NdbMutex_Lock(pool_mutex);
NdbPool* a_pool;
if (the_pool != NULL) {
a_pool = NULL;
} else {
the_pool = new NdbPool(cc, max_ndb_obj, no_conn_obj);
if (!the_pool->init(init_no_ndb_objects)) {
delete the_pool;
the_pool = NULL;
}
a_pool = the_pool;
}
NdbMutex* temp = pool_mutex;
if (a_pool == NULL) {
pool_mutex = NULL;
}
NdbMutex_Unlock(pool_mutex);
if (a_pool == NULL) {
NdbMutex_Destroy(temp);
}
return a_pool;
}
bool
WatchDog::registerWatchedThread(Uint32 *counter, Uint32 threadId)
{
bool ret;
NdbMutex_Lock(m_mutex);
if (m_watchedCount >= MAX_WATCHED_THREADS)
{
ret = false;
}
else
{
m_watchedList[m_watchedCount].m_watchCounter = counter;
m_watchedList[m_watchedCount].m_threadId = threadId;
m_watchedList[m_watchedCount].m_startTicks = NdbTick_getCurrentTicks();
m_watchedList[m_watchedCount].m_slowWarnDelay = theInterval;
m_watchedList[m_watchedCount].m_lastCounterValue = 0;
++m_watchedCount;
ret = true;
}
NdbMutex_Unlock(m_mutex);
return ret;
}
void
MgmApiSession::get_session(SocketServer::Session *_s, void *data)
{
struct get_session_param *p= (struct get_session_param*)data;
MgmApiSession *s= (MgmApiSession *)_s;
if(s!=p->l)
NdbMutex_Lock(s->m_mutex);
if(p->id != s->m_session_id)
{
if(s!=p->l)
NdbMutex_Unlock(s->m_mutex);
return;
}
p->found= true;
p->l->m_output->println("id: %llu",s->m_session_id);
p->l->m_output->println("m_stopSelf: %d",s->m_stopSelf);
p->l->m_output->println("m_stop: %d",s->m_stop);
p->l->m_output->println("nodeid: %d",s->m_allocated_resources->get_nodeid());
if(s->m_ctx)
{
int l= strlen(s->m_ctx->m_tokenBuffer);
p->l->m_output->println("parser_buffer_len: %u",l);
p->l->m_output->println("parser_status: %d",s->m_ctx->m_status);
}
if(s!=p->l)
NdbMutex_Unlock(s->m_mutex);
}
int NdbCondition_Broadcast(struct NdbCondition* p_cond)
{
int bHaveWaiters;
int result = 0;
if(!p_cond)
return 1;
NdbMutex_Lock(p_cond->pNdbMutexWaitersLock);
bHaveWaiters = 0;
if(p_cond->nWaiters > 0)
{
p_cond->bWasBroadcast = !0;
bHaveWaiters = 1;
}
NdbMutex_Unlock(p_cond->pNdbMutexWaitersLock);
if(bHaveWaiters)
{
if(!ReleaseSemaphore(p_cond->hSemaphore, p_cond->nWaiters, 0))
result = -1;
else if(WaitForSingleObject (p_cond->hEventWaitersDone, INFINITE) != WAIT_OBJECT_0)
result = -1;
p_cond->bWasBroadcast = 0;
}
return result;
}
void NDBT_Context::stopTest(){
NdbMutex_Lock(propertyMutexPtr);
g_info << "|- stopTest called" << endl;
stopped = true;
NdbCondition_Broadcast(propertyCondPtr);
NdbMutex_Unlock(propertyMutexPtr);
}
int NdbObjectIdMap::expand(Uint32 incSize)
{
NdbMutex_Lock(m_mutex);
Uint32 newSize = m_size + incSize;
MapEntry * tmp = (MapEntry*)realloc(m_map, newSize * sizeof(MapEntry));
if (likely(tmp != 0))
{
m_map = tmp;
for(Uint32 i = m_size; i < newSize; i++){
m_map[i].m_next = i + 1;
}
m_firstFree = m_size;
m_map[newSize-1].m_next = InvalidId;
m_size = newSize;
}
else
{
NdbMutex_Unlock(m_mutex);
g_eventLogger.error("NdbObjectIdMap::expand: realloc(%u*%u) failed",
newSize, sizeof(MapEntry));
return -1;
}
NdbMutex_Unlock(m_mutex);
return 0;
}
void NDBT_Context::wait_timeout(int msec){
NdbMutex_Lock(propertyMutexPtr);
NdbCondition_WaitTimeout(propertyCondPtr,
propertyMutexPtr,
msec);
NdbMutex_Unlock(propertyMutexPtr);
}
bool MultiNdbWakeupHandler::isReadyToWake() const
{
NdbMutex_Lock(localWakeupMutexPtr);
bool ret = ((numNdbsWithCompletedTrans >= minNdbsToWake) || woken);
NdbMutex_Unlock(localWakeupMutexPtr);
return ret;
}
void NDBT_TestCaseImpl1::waitSteps(){
NdbMutex_Lock(waitThreadsMutexPtr);
while(numStepsCompleted != steps.size())
NdbCondition_Wait(waitThreadsCondPtr,
waitThreadsMutexPtr);
unsigned completedSteps = 0;
unsigned i;
for(i=0; i<steps.size(); i++){
if (results[i] != NORESULT){
completedSteps++;
if (results[i] == NDBT_OK)
numStepsOk++;
else
numStepsFail++;
}
}
require(completedSteps == steps.size());
require(completedSteps == numStepsCompleted);
NdbMutex_Unlock(waitThreadsMutexPtr);
void *status;
for(i=0; i<steps.size();i++){
NdbThread_WaitFor(threads[i], &status);
NdbThread_Destroy(&threads[i]);
}
threads.clear();
}
void VerifyBegin(void)
{
if(!g_pNdbMutexVerify)
{
g_pNdbMutexVerify = NdbMutex_Create();
}
NdbMutex_Lock(g_pNdbMutexVerify);
}
inline
void
trp_client::lock()
{
NdbMutex_Lock(m_mutex);
assert(m_poll.m_locked == false);
m_poll.m_locked = true;
}
inline
void
trp_client::lock()
{
NdbMutex_Lock(m_facade->theMutexPtr);
assert(m_poll.m_locked == false);
m_poll.m_locked = true;
}
Uint32 NDBT_Context::getProperty(const char* _name, Uint32 _default){
Uint32 val;
NdbMutex_Lock(propertyMutexPtr);
if(!props.get(_name, &val))
val = _default;
NdbMutex_Unlock(propertyMutexPtr);
return val;
}
void TraceBegin(void)
{
if(!g_pNdbMutexTrace)
{
g_pNdbMutexTrace = NdbMutex_Create();
}
NdbMutex_Lock(g_pNdbMutexTrace);
g_nParamTrace = 0;
}
void
NDBT_Context::incProperty(const char * name){
NdbMutex_Lock(propertyMutexPtr);
Uint32 val = 0;
props.get(name, &val);
props.put(name, (val + 1), true);
NdbCondition_Broadcast(propertyCondPtr);
NdbMutex_Unlock(propertyMutexPtr);
}
void
MgmApiSession::runSession()
{
DBUG_ENTER("MgmApiSession::runSession");
Parser_t::Context ctx;
ctx.m_mutex= m_mutex;
m_ctx= &ctx;
bool stop= false;
while(!stop) {
NdbMutex_Lock(m_mutex);
m_input->reset_timeout();
m_output->reset_timeout();
m_parser->run(ctx, *this);
if(ctx.m_currentToken == 0)
{
NdbMutex_Unlock(m_mutex);
break;
}
switch(ctx.m_status) {
case Parser_t::UnknownCommand:
break;
default:
break;
}
stop= m_stop;
NdbMutex_Unlock(m_mutex);
};
NdbMutex_Lock(m_mutex);
m_ctx= NULL;
if(m_socket != NDB_INVALID_SOCKET)
{
NDB_CLOSE_SOCKET(m_socket);
m_socket= NDB_INVALID_SOCKET;
}
NdbMutex_Unlock(m_mutex);
DBUG_VOID_RETURN;
}
void
ndb_mutex_destoyed(NdbMutex* p)
{
unsigned no = p->m_mutex_state->m_no;
/**
* In order to be able to reuse mutex_no,
* we need to clear this no from all mutexes that has it in before map...
* this is all mutexes in after map
*/
for (unsigned i = 0; i<p->m_mutex_state->m_locked_after_list.m_used; i++)
{
NdbMutex * m = get_element(&p->m_mutex_state->m_locked_after_list, i);
assert(check_bit(&p->m_mutex_state->m_locked_after_mask, m->m_mutex_state->m_no));
/**
* And we need to lock it while doing this
*/
NdbMutex_Lock(m);
assert(check_bit(&m->m_mutex_state->m_locked_before_mask, no));
clear_bit(&m->m_mutex_state->m_locked_before_mask, no);
remove_mutex_from_array(&m->m_mutex_state->m_locked_before_list, p);
NdbMutex_Unlock(m);
}
/**
* And we need to remove ourselfs from after list of mutexes in out before list
*/
for (unsigned i = 0; i<p->m_mutex_state->m_locked_before_list.m_used; i++)
{
NdbMutex * m = get_element(&p->m_mutex_state->m_locked_before_list, i);
NdbMutex_Lock(m);
assert(check_bit(&m->m_mutex_state->m_locked_after_mask, no));
clear_bit(&m->m_mutex_state->m_locked_after_mask, no);
remove_mutex_from_array(&m->m_mutex_state->m_locked_after_list, p);
NdbMutex_Unlock(m);
}
release(&p->m_mutex_state->m_locked_before_mask);
release(&p->m_mutex_state->m_locked_before_list);
release(&p->m_mutex_state->m_locked_after_mask);
release(&p->m_mutex_state->m_locked_after_list);
release_mutex_no(no);
}
const char* NDBT_Context::getPropertyWait(const char* _name, const char* _waitVal){
const char* val;
NdbMutex_Lock(propertyMutexPtr);
while(!props.get(_name, &val) && (strcmp(val, _waitVal)==0))
NdbCondition_Wait(propertyCondPtr,
propertyMutexPtr);
NdbMutex_Unlock(propertyMutexPtr);
return val;
}
void
NDBT_Context::decProperty(const char * name){
NdbMutex_Lock(propertyMutexPtr);
Uint32 val = 0;
if(props.get(name, &val)){
require(val > 0);
props.put(name, (val - 1), true);
}
NdbCondition_Broadcast(propertyCondPtr);
NdbMutex_Unlock(propertyMutexPtr);
}
void
ClusterMgr::startThread() {
NdbMutex_Lock(clusterMgrThreadMutex);
theStop = 0;
theClusterMgrThread = NdbThread_Create(runClusterMgr_C,
(void**)this,
32768,
"ndb_clustermgr",
NDB_THREAD_PRIO_LOW);
NdbMutex_Unlock(clusterMgrThreadMutex);
}
bool NDBT_Context::getPropertyWait(const char* _name, Uint32 _waitVal){
bool result;
NdbMutex_Lock(propertyMutexPtr);
Uint32 val =! _waitVal;
while((!props.get(_name, &val) || (props.get(_name, &val) && val != _waitVal)) &&
!stopped)
NdbCondition_Wait(propertyCondPtr,
propertyMutexPtr);
result = (val == _waitVal);
NdbMutex_Unlock(propertyMutexPtr);
return stopped;
}
void NDBT_TestCaseImpl1::reportStepResult(const NDBT_Step* pStep, int result){
NdbMutex_Lock(waitThreadsMutexPtr);
require(pStep != NULL);
for (unsigned i = 0; i < steps.size(); i++){
if(steps[i] != NULL && steps[i] == pStep){
results[i] = result;
numStepsCompleted++;
}
}
if(numStepsCompleted == steps.size()){
NdbCondition_Signal(waitThreadsCondPtr);
}
NdbMutex_Unlock(waitThreadsMutexPtr);
}