mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-18 04:53:01 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge joreland@bk-internal.mysql.com:/home/bk/mysql-4.1-ndb

Browse source 
into mysql.com:/home/jonas/src/mysql-4.1-ndb


ndb/src/mgmsrv/MgmtSrvr.cpp:
  Auto merged
This commit is contained in:
unknown 2004-10-25 18:02:42 +02:00
commit 2d8ce69ed0
10 changed files with 74 additions and 71 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
ndb/include/portlib/NdbMutex.h
View file

@ -31,13 +31,11 @@ extern "C" {
#if defined NDB_OSE || defined NDB_SOFTOSE
#include <ose.h>
typedef SEMAPHORE NdbMutex;
#define NDB_MUTEX_INITIALIZER { 1, 0, 0 }
#elif defined NDB_WIN32
typedef CRITICAL_SECTION NdbMutex;
#else
#include <pthread.h>
typedef pthread_mutex_t NdbMutex;
#define NDB_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
#endif
/**

30
ndb/src/common/portlib/NdbTCP.cpp
View file

@ -16,29 +16,27 @@
#include <ndb_global.h>
#include <NdbMutex.h>
#include <my_net.h>
#include <NdbTCP.h>
#if defined NDB_WIN32 || defined SCO
static NdbMutex & LOCK_gethostbyname = * NdbMutex_Create();
#else
static NdbMutex LOCK_gethostbyname = NDB_MUTEX_INITIALIZER;
#endif
extern "C"
int
Ndb_getInAddr(struct in_addr * dst, const char *address) {
DBUG_ENTER("Ndb_getInAddr");
struct hostent * hostPtr;
NdbMutex_Lock(&LOCK_gethostbyname);
hostPtr = gethostbyname(address);
if (hostPtr != NULL) {
dst->s_addr = ((struct in_addr *) *hostPtr->h_addr_list)->s_addr;
NdbMutex_Unlock(&LOCK_gethostbyname);
DBUG_RETURN(0);
{
int tmp_errno;
struct hostent tmp_hostent, *hp;
char buff[GETHOSTBYNAME_BUFF_SIZE];
hp = my_gethostbyname_r(address,&tmp_hostent,buff,sizeof(buff),
&tmp_errno);
if (hp)
{
memcpy(dst, hp->h_addr, min(sizeof(*dst), (size_t) hp->h_length));
my_gethostbyname_r_free();
DBUG_RETURN(0);
}
my_gethostbyname_r_free();
}
NdbMutex_Unlock(&LOCK_gethostbyname);
/* Try it as aaa.bbb.ccc.ddd. */
dst->s_addr = inet_addr(address);
if (dst->s_addr !=

20
ndb/src/mgmsrv/MgmtSrvr.cpp
View file

@ -534,6 +534,12 @@ MgmtSrvr::MgmtSrvr(NodeId nodeId,
m_statisticsListner.m_logLevel = se.m_logLevel;
}
if ((m_node_id_mutex = NdbMutex_Create()) == 0)
{
ndbout << "mutex creation failed line = " << __LINE__ << endl;
exit(-1);
}
DBUG_VOID_RETURN;
}
@ -627,7 +633,9 @@ MgmtSrvr::~MgmtSrvr()
stopEventLog();
NdbCondition_Destroy(theMgmtWaitForResponseCondPtr); NdbMutex_Destroy(m_configMutex);
NdbMutex_Destroy(m_node_id_mutex);
NdbCondition_Destroy(theMgmtWaitForResponseCondPtr);
NdbMutex_Destroy(m_configMutex);
if(m_newConfig != NULL)
free(m_newConfig);
@ -2087,12 +2095,6 @@ MgmtSrvr::getNodeType(NodeId nodeId) const
return nodeTypes[nodeId];
}
#ifdef NDB_WIN32
static NdbMutex & f_node_id_mutex = * NdbMutex_Create();
#else
static NdbMutex f_node_id_mutex = NDB_MUTEX_INITIALIZER;
#endif
bool
MgmtSrvr::alloc_node_id(NodeId * nodeId,
enum ndb_mgm_node_type type,
@ -2111,7 +2113,7 @@ MgmtSrvr::alloc_node_id(NodeId * nodeId,
}
DBUG_RETURN(true);
}
Guard g(&f_node_id_mutex);
Guard g(m_node_id_mutex);
int no_mgm= 0;
NodeBitmask connected_nodes(m_reserved_nodes);
for(Uint32 i = 0; i < MAX_NODES; i++)
@ -2528,7 +2530,7 @@ MgmtSrvr::Allocated_resources::Allocated_resources(MgmtSrvr &m)
MgmtSrvr::Allocated_resources::~Allocated_resources()
{
Guard g(&f_node_id_mutex);
Guard g(m_mgmsrv.m_node_id_mutex);
if (!m_reserved_nodes.isclear()) {
// node has been reserved, force update signal to ndb nodes
global_flag_send_heartbeat_now= 1;

1
ndb/src/mgmsrv/MgmtSrvr.hpp
View file

@ -101,6 +101,7 @@ public:
MgmtSrvr &m_mgmsrv;
NodeBitmask m_reserved_nodes;
};
NdbMutex *m_node_id_mutex;
/**
* Start/initate the event log.

7
ndb/src/ndbapi/Ndb.cpp
View file

@ -1365,7 +1365,8 @@ Ndb::pollEvents(int aMillisecondNumber)
#ifdef VM_TRACE
#include <NdbMutex.h>
static NdbMutex print_state_mutex = NDB_MUTEX_INITIALIZER;
extern NdbMutex *ndb_print_state_mutex;
static bool
checkdups(NdbConnection** list, unsigned no)
{
@ -1383,7 +1384,7 @@ Ndb::printState(const char* fmt, ...)
va_start(ap, fmt);
vsprintf(buf, fmt, ap);
va_end(ap);
NdbMutex_Lock(&print_state_mutex);
NdbMutex_Lock(ndb_print_state_mutex);
bool dups = false;
ndbout << buf << " ndb=" << hex << this << dec;
#ifndef NDB_WIN32
@ -1421,7 +1422,7 @@ Ndb::printState(const char* fmt, ...)
}
for (unsigned i = 0; i < theNoOfCompletedTransactions; i++)
theCompletedTransactionsArray[i]->printState();
NdbMutex_Unlock(&print_state_mutex);
NdbMutex_Unlock(ndb_print_state_mutex);
}
#endif

23
ndb/src/ndbapi/NdbEventOperationImpl.cpp
View file

@ -573,12 +573,8 @@ int NdbEventOperationImpl::wait(void *p, int aMillisecondNumber)
*
*/
extern NdbMutex * ndb_global_event_buffer_mutex;
static NdbGlobalEventBuffer *ndbGlobalEventBuffer=NULL;
#ifdef NDB_WIN32
static NdbMutex & ndbGlobalEventBufferMutex = * NdbMutex_Create();
#else
static NdbMutex ndbGlobalEventBufferMutex = NDB_MUTEX_INITIALIZER;
#endif
/*
* Class NdbGlobalEventBufferHandle
@ -607,18 +603,18 @@ NdbGlobalEventBufferHandle::NdbGlobalEventBufferHandle
exit(-1);
}
NdbMutex_Lock(&ndbGlobalEventBufferMutex);
NdbMutex_Lock(ndb_global_event_buffer_mutex);
if (ndbGlobalEventBuffer == NULL) {
if (ndbGlobalEventBuffer == NULL) {
ndbGlobalEventBuffer = new NdbGlobalEventBuffer();
if (!ndbGlobalEventBuffer) {
NdbMutex_Unlock(&ndbGlobalEventBufferMutex);
NdbMutex_Unlock(ndb_global_event_buffer_mutex);
ndbout_c("NdbGlobalEventBufferHandle:: failed to allocate ndbGlobalEventBuffer");
exit(-1);
}
}
}
NdbMutex_Unlock(&ndbGlobalEventBufferMutex);
NdbMutex_Unlock(ndb_global_event_buffer_mutex);
GUARD(real_init(this,MAX_NUMBER_ACTIVE_EVENTS));
}
@ -631,12 +627,12 @@ NdbGlobalEventBufferHandle::~NdbGlobalEventBufferHandle()
ndbGlobalEventBuffer->real_remove(this);
ndbGlobalEventBuffer->unlock();
NdbMutex_Lock(&ndbGlobalEventBufferMutex);
NdbMutex_Lock(ndb_global_event_buffer_mutex);
if (ndbGlobalEventBuffer->m_handlers.size() == 0) {
delete ndbGlobalEventBuffer;
ndbGlobalEventBuffer = NULL;
}
NdbMutex_Unlock(&ndbGlobalEventBufferMutex);
NdbMutex_Unlock(ndb_global_event_buffer_mutex);
}
void
@ -770,13 +766,13 @@ void
NdbGlobalEventBuffer::lock()
{
if (!m_group_lock_flag)
NdbMutex_Lock(&ndbGlobalEventBufferMutex);
NdbMutex_Lock(ndb_global_event_buffer_mutex);
}
void
NdbGlobalEventBuffer::unlock()
{
if (!m_group_lock_flag)
NdbMutex_Unlock(&ndbGlobalEventBufferMutex);
NdbMutex_Unlock(ndb_global_event_buffer_mutex);
}
void
NdbGlobalEventBuffer::add_drop_lock()
@ -1232,7 +1228,8 @@ NdbGlobalEventBuffer::real_wait(NdbGlobalEventBufferHandle *h,
n += hasData(h->m_bufferIds[i]);
if (n) return n;
int r = NdbCondition_WaitTimeout(h->p_cond, &ndbGlobalEventBufferMutex, aMillisecondNumber);
int r = NdbCondition_WaitTimeout(h->p_cond, ndb_global_event_buffer_mutex,
aMillisecondNumber);
if (r > 0)
return -1;

15
ndb/src/ndbapi/Ndbinit.cpp
View file

@ -42,11 +42,6 @@ void NdbGlobalEventBuffer_drop(NdbGlobalEventBufferHandle *);
static char *ndbConnectString = 0;
static int theNoOfNdbObjects = 0;
static Ndb_cluster_connection *global_ndb_cluster_connection= 0;
#if defined NDB_WIN32 || defined SCO
static NdbMutex & createNdbMutex = * NdbMutex_Create();
#else
static NdbMutex createNdbMutex = NDB_MUTEX_INITIALIZER;
#endif
/***************************************************************************
@ -58,7 +53,6 @@ Remark: Connect to the database.
Ndb::Ndb( const char* aDataBase , const char* aSchema) {
DBUG_ENTER("Ndb::Ndb()");
DBUG_PRINT("enter",("(old)Ndb::Ndb this=0x%x", this));
NdbMutex_Lock(&createNdbMutex);
if (theNoOfNdbObjects < 0)
abort(); // old and new Ndb constructor used mixed
theNoOfNdbObjects++;
@ -66,7 +60,6 @@ Ndb::Ndb( const char* aDataBase , const char* aSchema) {
global_ndb_cluster_connection= new Ndb_cluster_connection(ndbConnectString);
global_ndb_cluster_connection->connect();
}
NdbMutex_Unlock(&createNdbMutex);
setup(global_ndb_cluster_connection, aDataBase, aSchema);
DBUG_VOID_RETURN;
}
@ -171,8 +164,6 @@ void Ndb::setup(Ndb_cluster_connection *ndb_cluster_connection,
prefixEnd = prefixName + (len < (int) sizeof(prefixName) ? len :
sizeof(prefixName) - 1);
NdbMutex_Lock(&createNdbMutex);
theWaiter.m_mutex = TransporterFacade::instance()->theMutexPtr;
// Signal that the constructor has finished OK
@ -191,8 +182,6 @@ void Ndb::setup(Ndb_cluster_connection *ndb_cluster_connection,
theGlobalEventBufferHandle = h;
}
NdbMutex_Unlock(&createNdbMutex);
theDictionary = new NdbDictionaryImpl(*this);
if (theDictionary == NULL) {
ndbout_c("Ndb cailed to allocate dictionary");
@ -232,8 +221,6 @@ Ndb::~Ndb()
TransporterFacade::instance()->close(theNdbBlockNumber, theFirstTransId);
}
NdbMutex_Lock(&createNdbMutex);
if (global_ndb_cluster_connection != 0) {
theNoOfNdbObjects--;
if(theNoOfNdbObjects == 0){
@ -242,8 +229,6 @@ Ndb::~Ndb()
}
}//if
NdbMutex_Unlock(&createNdbMutex);
// if (theSchemaConToNdbList != NULL)
// closeSchemaTransaction(theSchemaConToNdbList);
while ( theConIdleList != NULL )

31
ndb/src/ndbapi/ndb_cluster_connection.cpp
View file

@ -29,6 +29,12 @@
static int g_run_connect_thread= 0;
#include <NdbMutex.h>
NdbMutex *ndb_global_event_buffer_mutex= NULL;
#ifdef VM_TRACE
NdbMutex *ndb_print_state_mutex= NULL;
#endif
Ndb_cluster_connection::Ndb_cluster_connection(const char *connect_string)
{
DBUG_ENTER("Ndb_cluster_connection");
@ -42,6 +48,17 @@ Ndb_cluster_connection::Ndb_cluster_connection(const char *connect_string)
m_local_config= 0;
m_connect_thread= 0;
m_connect_callback= 0;
if (ndb_global_event_buffer_mutex == NULL)
{
ndb_global_event_buffer_mutex= NdbMutex_Create();
}
#ifdef VM_TRACE
if (ndb_print_state_mutex == NULL)
{
ndb_print_state_mutex= NdbMutex_Create();
}
#endif
DBUG_VOID_RETURN;
}
@ -85,11 +102,10 @@ int Ndb_cluster_connection::start_connect_thread(int (*connect_callback)(void))
if ((r = connect(1)) == 1)
{
DBUG_PRINT("info",("starting thread"));
m_connect_thread= NdbThread_Create(run_ndb_cluster_connection_connect_thread,
(void**)this,
32768,
"ndb_cluster_connection",
NDB_THREAD_PRIO_LOW);
m_connect_thread=
NdbThread_Create(run_ndb_cluster_connection_connect_thread,
(void**)this, 32768, "ndb_cluster_connection",
NDB_THREAD_PRIO_LOW);
}
else if (r < 0)
{
@ -112,13 +128,14 @@ int Ndb_cluster_connection::connect(int reconnect)
if (m_local_config == 0) {
m_local_config= new LocalConfig();
if (!m_local_config->init(m_connect_string,0)) {
ndbout << "Configuration error: Unable to retrieve local config" << endl;
ndbout_c("Configuration error: Unable to retrieve local config");
m_local_config->printError();
m_local_config->printUsage();
DBUG_RETURN(-1);
}
}
m_config_retriever= new ConfigRetriever(*m_local_config, NDB_VERSION, NODE_TYPE_API);
m_config_retriever=
new ConfigRetriever(*m_local_config, NDB_VERSION, NODE_TYPE_API);
}
else
if (reconnect == 0)

8
ndb/test/ndbapi/testDeadlock.cpp
View file

@ -48,14 +48,14 @@ printusage()
static Opt g_opt;
static NdbMutex ndbout_mutex = NDB_MUTEX_INITIALIZER;
static NdbMutex *ndbout_mutex= NULL;
#define DBG(x) \
do { \
if (! g_opt.m_dbg) break; \
NdbMutex_Lock(&ndbout_mutex); \
NdbMutex_Lock(ndbout_mutex); \
ndbout << "line " << __LINE__ << " " << x << endl; \
NdbMutex_Unlock(&ndbout_mutex); \
NdbMutex_Unlock(ndbout_mutex); \
} while (0)
#define CHK(x) \
@ -492,6 +492,8 @@ wl1822_main(char scantx)
NDB_COMMAND(testOdbcDriver, "testDeadlock", "testDeadlock", "testDeadlock", 65535)
{
ndb_init();
if (ndbout_mutex == NULL)
ndbout_mutex= NdbMutex_Create();
while (++argv, --argc > 0) {
const char* arg = argv[0];
if (strcmp(arg, "-scan") == 0) {

8
ndb/test/ndbapi/testOIBasic.cpp
View file

@ -137,7 +137,7 @@ static const bool g_compare_null = true;
// log and error macros
static NdbMutex ndbout_mutex = NDB_MUTEX_INITIALIZER;
static NdbMutex *ndbout_mutex= NULL;
static unsigned getthrno();
@ -160,9 +160,9 @@ getthrstr()
#define LLN(n, s) \
do { \
if ((n) > g_opt.m_v) break; \
if (g_opt.m_msglock) NdbMutex_Lock(&ndbout_mutex); \
if (g_opt.m_msglock) NdbMutex_Lock(ndbout_mutex); \
ndbout << getthrstr() << s << endl; \
if (g_opt.m_msglock) NdbMutex_Unlock(&ndbout_mutex); \
if (g_opt.m_msglock) NdbMutex_Unlock(ndbout_mutex); \
} while(0)
#define LL0(s) LLN(0, s)
@ -3349,6 +3349,8 @@ runtest(Par par)
NDB_COMMAND(testOIBasic, "testOIBasic", "testOIBasic", "testOIBasic", 65535)
{
ndb_init();
if (ndbout_mutex == NULL)
ndbout_mutex= NdbMutex_Create();
while (++argv, --argc > 0) {
const char* arg = argv[0];
if (*arg != '-') {