void
Cmvmi::execSTART_ORD(Signal* signal) {
StartOrd * const startOrd = (StartOrd *)&signal->theData[0];
jamEntry();
Uint32 tmp = startOrd->restartInfo;
if(StopReq::getPerformRestart(tmp)){
jam();
/**
*
*/
NdbRestartType type = NRT_Default;
if(StopReq::getNoStart(tmp) && StopReq::getInitialStart(tmp))
type = NRT_NoStart_InitialStart;
if(StopReq::getNoStart(tmp) && !StopReq::getInitialStart(tmp))
type = NRT_NoStart_Restart;
if(!StopReq::getNoStart(tmp) && StopReq::getInitialStart(tmp))
type = NRT_DoStart_InitialStart;
if(!StopReq::getNoStart(tmp)&&!StopReq::getInitialStart(tmp))
type = NRT_DoStart_Restart;
NdbShutdown(NST_Restart, type);
}
if(globalData.theRestartFlag == system_started){
jam()
/**
* START_ORD received when already started(ignored)
*/
//ndbout << "START_ORD received when already started(ignored)" << endl;
return;
}
void
ErrorReporter::handleAssert(const char* message, const char* file, int line, int ec)
{
char refMessage[100];
Uint32 jamBlockNumber;
#ifdef NO_EMULATED_JAM
BaseString::snprintf(refMessage, 100, "file: %s lineNo: %d",
file, line);
jam = NULL;
jamIndex = 0;
jamBlockNumber = 0;
#else
const EmulatedJamBuffer *jamBuffer =
(EmulatedJamBuffer *)NdbThread_GetTlsKey(NDB_THREAD_TLS_JAM);
jamBlockNumber = jamBuffer->theEmulatedJamBlockNumber;
const char *blockName = getBlockName(jamBlockNumber);
BaseString::snprintf(refMessage, 100, "%s line: %d (block: %s)",
file, line, blockName);
#endif
NdbShutdownType nst = s_errorHandlerShutdownType;
WriteMessage(ec, message, refMessage, nst);
NdbShutdown(ec, nst);
exit(1); // Deadcode
}
void
ErrorReporter::handleError(int messageID,
const char* problemData,
const char* objRef,
NdbShutdownType nst)
{
WriteMessage(messageID, problemData,
objRef, theEmulatedJamIndex, theEmulatedJam);
g_eventLogger.info(problemData);
g_eventLogger.info(objRef);
childReportError(messageID);
if(messageID == NDBD_EXIT_ERROR_INSERT){
NdbShutdown(NST_ErrorInsert);
} else {
if (nst == NST_ErrorHandler)
nst = s_errorHandlerShutdownType;
NdbShutdown(nst);
}
}
void
ErrorReporter::handleAssert(const char* message, const char* file, int line, int ec)
{
char refMessage[100];
#ifdef NO_EMULATED_JAM
BaseString::snprintf(refMessage, 100, "file: %s lineNo: %d",
file, line);
#else
const Uint32 blockNumber = theEmulatedJamBlockNumber;
const char *blockName = getBlockName(blockNumber);
BaseString::snprintf(refMessage, 100, "%s line: %d (block: %s)",
file, line, blockName);
#endif
WriteMessage(ec, message, refMessage,
theEmulatedJamIndex, theEmulatedJam);
childReportError(ec);
NdbShutdown(s_errorHandlerShutdownType);
exit(1); // Deadcode
}
void
ErrorReporter::handleError(int messageID,
const char* problemData,
const char* objRef,
NdbShutdownType nst)
{
if(messageID == NDBD_EXIT_ERROR_INSERT)
{
nst = NST_ErrorInsert;
}
else
{
if (nst == NST_ErrorHandler)
nst = s_errorHandlerShutdownType;
}
WriteMessage(messageID, problemData, objRef, nst);
g_eventLogger->info("%s", problemData);
g_eventLogger->info("%s", objRef);
NdbShutdown(messageID, nst);
exit(1); // kill warning
}
void
ndbd_run(bool foreground, int report_fd,
const char* connect_str, int force_nodeid, const char* bind_address,
bool no_start, bool initial, bool initialstart,
unsigned allocated_nodeid)
{
#ifdef _WIN32
{
char shutdown_event_name[32];
_snprintf(shutdown_event_name, sizeof(shutdown_event_name),
"ndbd_shutdown_%d", GetCurrentProcessId());
g_shutdown_event = CreateEvent(NULL, TRUE, FALSE, shutdown_event_name);
if (g_shutdown_event == NULL)
{
g_eventLogger->error("Failed to create shutdown event, error: %d",
GetLastError());
ndbd_exit(1);
}
HANDLE thread = CreateThread(NULL, 0, &shutdown_thread, NULL, 0, NULL);
if (thread == NULL)
{
g_eventLogger->error("couldn't start shutdown thread, error: %d",
GetLastError());
ndbd_exit(1);
}
}
#endif
if (foreground)
g_eventLogger->info("Ndb started in foreground");
if (report_fd)
{
g_eventLogger->debug("Opening report stream on fd: %d", report_fd);
// Open a stream for sending extra status to angel
if (!(angel_info_w = fdopen(report_fd, "w")))
{
g_eventLogger->error("Failed to open stream for reporting "
"to angel, error: %d (%s)", errno, strerror(errno));
ndbd_exit(-1);
}
}
else
{
// No reporting requested, open /dev/null
const char* dev_null = IF_WIN("nul", "/dev/null");
if (!(angel_info_w = fopen(dev_null, "w")))
{
g_eventLogger->error("Failed to open stream for reporting to "
"'%s', error: %d (%s)", dev_null, errno,
strerror(errno));
ndbd_exit(-1);
}
}
globalEmulatorData.create();
Configuration* theConfig = globalEmulatorData.theConfiguration;
if(!theConfig->init(no_start, initial, initialstart))
{
g_eventLogger->error("Failed to init Configuration");
ndbd_exit(-1);
}
theConfig->fetch_configuration(connect_str, force_nodeid, bind_address,
allocated_nodeid);
if (NdbDir::chdir(NdbConfig_get_path(NULL)) != 0)
{
g_eventLogger->warning("Cannot change directory to '%s', error: %d",
NdbConfig_get_path(NULL), errno);
// Ignore error
}
theConfig->setupConfiguration();
if (get_multithreaded_config(globalEmulatorData))
ndbd_exit(-1);
systemInfo(* theConfig, * theConfig->m_logLevel);
NdbThread* pWatchdog = globalEmulatorData.theWatchDog->doStart();
{
/*
* Memory allocation can take a long time for large memory.
*
* So we want the watchdog to monitor the process of initial allocation.
*/
Uint32 watchCounter;
watchCounter = 9; // Means "doing allocation"
globalEmulatorData.theWatchDog->registerWatchedThread(&watchCounter, 0);
if (init_global_memory_manager(globalEmulatorData, &watchCounter))
ndbd_exit(1);
globalEmulatorData.theWatchDog->unregisterWatchedThread(0);
}
globalEmulatorData.theThreadConfig->init();
#ifdef VM_TRACE
// Create a signal logger before block constructors
char *buf= NdbConfig_SignalLogFileName(globalData.ownId);
NdbAutoPtr<char> tmp_aptr(buf);
FILE * signalLog = fopen(buf, "a");
globalSignalLoggers.setOwnNodeId(globalData.ownId);
globalSignalLoggers.setOutputStream(signalLog);
#if 1 // to log startup
{ const char* p = NdbEnv_GetEnv("NDB_SIGNAL_LOG", (char*)0, 0);
if (p != 0) {
char buf[200];
BaseString::snprintf(buf, sizeof(buf), "BLOCK=%s", p);
for (char* q = buf; *q != 0; q++) *q = toupper(toascii(*q));
globalSignalLoggers.log(SignalLoggerManager::LogInOut, buf);
globalData.testOn = 1;
assert(signalLog != 0);
fprintf(signalLog, "START\n");
fflush(signalLog);
}
}
#endif
#endif
// Load blocks (both main and workers)
globalEmulatorData.theSimBlockList->load(globalEmulatorData);
// Set thread concurrency for Solaris' light weight processes
int status;
status = NdbThread_SetConcurrencyLevel(30);
assert(status == 0);
catchsigs(foreground);
/**
* Do startup
*/
switch(globalData.theRestartFlag){
case initial_state:
globalEmulatorData.theThreadConfig->doStart(NodeState::SL_CMVMI);
break;
case perform_start:
globalEmulatorData.theThreadConfig->doStart(NodeState::SL_CMVMI);
globalEmulatorData.theThreadConfig->doStart(NodeState::SL_STARTING);
break;
default:
assert("Illegal state globalData.theRestartFlag" == 0);
}
globalTransporterRegistry.startSending();
globalTransporterRegistry.startReceiving();
if (!globalTransporterRegistry.start_service(*globalEmulatorData.m_socket_server)){
ndbout_c("globalTransporterRegistry.start_service() failed");
ndbd_exit(-1);
}
// Re-use the mgm handle as a transporter
if(!globalTransporterRegistry.connect_client(
theConfig->get_config_retriever()->get_mgmHandlePtr()))
ERROR_SET(fatal, NDBD_EXIT_CONNECTION_SETUP_FAILED,
"Failed to convert mgm connection to a transporter",
__FILE__);
NdbThread* pTrp = globalTransporterRegistry.start_clients();
if (pTrp == 0)
{
ndbout_c("globalTransporterRegistry.start_clients() failed");
ndbd_exit(-1);
}
NdbThread* pSockServ = globalEmulatorData.m_socket_server->startServer();
globalEmulatorData.theConfiguration->addThread(pTrp, SocketClientThread);
globalEmulatorData.theConfiguration->addThread(pWatchdog, WatchDogThread);
globalEmulatorData.theConfiguration->addThread(pSockServ, SocketServerThread);
// theConfig->closeConfiguration();
{
NdbThread *pThis = NdbThread_CreateObject(0);
Uint32 inx = globalEmulatorData.theConfiguration->addThread(pThis,
MainThread);
globalEmulatorData.theThreadConfig->ipControlLoop(pThis, inx);
globalEmulatorData.theConfiguration->removeThreadId(inx);
}
NdbShutdown(0, NST_Normal);
ndbd_exit(0);
}
