/*
* Lock succeeded (after delay) in ACC. If the lock is for current
* entry, set state to Locked. If the lock is for an entry we were
* moved away from, simply unlock it. Finally, if we are closing the
* scan, do nothing since we have already sent an abort request.
*/
void
Dbtup::execACCKEYCONF(Signal* signal)
{
jamEntry();
ScanOpPtr scanPtr;
scanPtr.i = signal->theData[0];
c_scanOpPool.getPtr(scanPtr);
ScanOp& scan = *scanPtr.p;
ndbrequire(scan.m_bits & ScanOp::SCAN_LOCK_WAIT && scan.m_accLockOp != RNIL);
scan.m_bits &= ~ ScanOp::SCAN_LOCK_WAIT;
if (scan.m_state == ScanOp::Blocked) {
// the lock wait was for current entry
jam();
scan.m_state = ScanOp::Locked;
// LQH has the ball
return;
}
if (scan.m_state != ScanOp::Aborting) {
// we were moved, release lock
jam();
AccLockReq* const lockReq = (AccLockReq*)signal->getDataPtrSend();
lockReq->returnCode = RNIL;
lockReq->requestInfo = AccLockReq::Abort;
lockReq->accOpPtr = scan.m_accLockOp;
EXECUTE_DIRECT(DBACC, GSN_ACC_LOCKREQ, signal, AccLockReq::UndoSignalLength);
jamEntry();
ndbrequire(lockReq->returnCode == AccLockReq::Success);
scan.m_accLockOp = RNIL;
// LQH has the ball
return;
}
// lose the lock
scan.m_accLockOp = RNIL;
// continue at ACC_ABORTCONF
}
void Dbtup::execTUP_WRITELOG_REQ(Signal* signal)
{
jamEntry();
OperationrecPtr loopOpPtr;
loopOpPtr.i= signal->theData[0];
Uint32 gci_hi = signal->theData[1];
Uint32 gci_lo = signal->theData[2];
c_operation_pool.getPtr(loopOpPtr);
while (loopOpPtr.p->prevActiveOp != RNIL) {
jam();
loopOpPtr.i= loopOpPtr.p->prevActiveOp;
c_operation_pool.getPtr(loopOpPtr);
}
do {
ndbrequire(get_trans_state(loopOpPtr.p) == TRANS_STARTED);
signal->theData[0] = loopOpPtr.p->userpointer;
signal->theData[1] = gci_hi;
signal->theData[2] = gci_lo;
if (loopOpPtr.p->nextActiveOp == RNIL) {
jam();
EXECUTE_DIRECT(DBLQH, GSN_LQH_WRITELOG_REQ, signal, 3);
return;
}
jam();
EXECUTE_DIRECT(DBLQH, GSN_LQH_WRITELOG_REQ, signal, 3);
jamEntry();
loopOpPtr.i= loopOpPtr.p->nextActiveOp;
c_operation_pool.getPtr(loopOpPtr);
} while (true);
}
int
Dbtup::addTuxEntries(Signal* signal,
Operationrec* regOperPtr,
Tablerec* regTabPtr)
{
if (ERROR_INSERTED(4022)) {
jam();
CLEAR_ERROR_INSERT_VALUE;
terrorCode = 9999;
return -1;
}
TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend();
const DLList<TupTriggerData>& triggerList = regTabPtr->tuxCustomTriggers;
TriggerPtr triggerPtr;
Uint32 failPtrI;
triggerList.first(triggerPtr);
while (triggerPtr.i != RNIL) {
jam();
req->indexId = triggerPtr.p->indexId;
req->errorCode = RNIL;
if (ERROR_INSERTED(4023) &&
! triggerList.hasNext(triggerPtr)) {
jam();
CLEAR_ERROR_INSERT_VALUE;
terrorCode = 9999;
failPtrI = triggerPtr.i;
goto fail;
}
EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
signal, TuxMaintReq::SignalLength);
jamEntry();
if (req->errorCode != 0) {
jam();
terrorCode = req->errorCode;
failPtrI = triggerPtr.i;
goto fail;
}
triggerList.next(triggerPtr);
}
return 0;
fail:
req->opInfo = TuxMaintReq::OpRemove;
triggerList.first(triggerPtr);
while (triggerPtr.i != failPtrI) {
jam();
req->indexId = triggerPtr.p->indexId;
req->errorCode = RNIL;
EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
signal, TuxMaintReq::SignalLength);
jamEntry();
ndbrequire(req->errorCode == 0);
triggerList.next(triggerPtr);
}
#ifdef VM_TRACE
ndbout << "aborted partial tux update: op " << hex << regOperPtr << endl;
#endif
return -1;
}
void
Dbtup::execACC_CHECK_SCAN(Signal* signal)
{
jamEntry();
const AccCheckScan reqCopy = *(const AccCheckScan*)signal->getDataPtr();
const AccCheckScan* const req = &reqCopy;
ScanOpPtr scanPtr;
c_scanOpPool.getPtr(scanPtr, req->accPtr);
ScanOp& scan = *scanPtr.p;
// fragment
FragrecordPtr fragPtr;
fragPtr.i = scan.m_fragPtrI;
ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
Fragrecord& frag = *fragPtr.p;
if (req->checkLcpStop == AccCheckScan::ZCHECK_LCP_STOP) {
jam();
signal->theData[0] = scan.m_userPtr;
signal->theData[1] = true;
EXECUTE_DIRECT(DBLQH, GSN_CHECK_LCP_STOP, signal, 2);
jamEntry();
return;
}
if (scan.m_bits & ScanOp::SCAN_LOCK_WAIT) {
jam();
// LQH asks if we are waiting for lock and we tell it to ask again
NextScanConf* const conf = (NextScanConf*)signal->getDataPtrSend();
conf->scanPtr = scan.m_userPtr;
conf->accOperationPtr = RNIL; // no tuple returned
conf->fragId = frag.fragmentId;
unsigned signalLength = 3;
// if TC has ordered scan close, it will be detected here
sendSignal(scan.m_userRef, GSN_NEXT_SCANCONF,
signal, signalLength, JBB);
return; // stop
}
if (scan.m_state == ScanOp::First) {
jam();
scanFirst(signal, scanPtr);
}
if (scan.m_state == ScanOp::Next) {
jam();
bool immediate = scanNext(signal, scanPtr);
if (! immediate) {
jam();
// time-slicing via TUP or PGMAN
return;
}
}
scanReply(signal, scanPtr);
}
void
Dbtup::execALTER_TAB_CONF(Signal* signal)
{
jamEntry();
AlterTabConf* conf = (AlterTabConf*)signal->getDataPtr();
BuildIndexPtr buildPtr;
buildPtr.i = conf->senderData;
c_buildIndexList.getPtr(buildPtr);
if (buildPtr.p->m_fragNo == 0)
{
jam();
buildIndexOffline_table_readonly(signal, conf->senderData);
return;
}
else
{
jam();
TablerecPtr tablePtr;
(void)tablePtr; // hide unused warning
ndbrequire(buildPtr.p->m_fragNo >= NDB_ARRAY_SIZE(tablePtr.p->fragid));
buildIndexReply(signal, buildPtr.p);
c_buildIndexList.release(buildPtr);
return;
}
}
void
DbtcProxy::execTCSEIZEREQ(Signal* signal)
{
jamEntry();
if (signal->getLength() >= 3 && signal->theData[2] != 0)
{
/**
* Specific instance requested...
*/
Uint32 instance = signal->theData[2];
if (instance == 0 || instance > c_workers)
{
jam();
Uint32 senderData = signal->theData[0];
Uint32 senderRef = signal->theData[1];
signal->theData[0] = senderData;
signal->theData[1] = 289;
sendSignal(senderRef, GSN_TCSEIZEREF, signal, 2, JBB);
return;
}
sendSignal(workerRef(instance - 1), GSN_TCSEIZEREQ, signal,
signal->getLength(), JBB);
return;
}
signal->theData[2] = 1 + m_tc_seize_req_instance;
sendSignal(workerRef(m_tc_seize_req_instance), GSN_TCSEIZEREQ, signal,
signal->getLength(), JBB);
m_tc_seize_req_instance = (m_tc_seize_req_instance + 1) % c_workers;
}
int
Dbtup::tuxAllocNode(Signal* signal,
Uint32 fragPtrI,
Uint32& pageId,
Uint32& pageOffset,
Uint32*& node)
{
jamEntry();
FragrecordPtr fragPtr;
fragPtr.i= fragPtrI;
ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
TablerecPtr tablePtr;
tablePtr.i= fragPtr.p->fragTableId;
ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
terrorCode= 0;
Local_key key;
Uint32* ptr, frag_page_id;
if ((ptr= alloc_fix_rec(fragPtr.p, tablePtr.p, &key, &frag_page_id)) == 0)
{
jam();
terrorCode = ZMEM_NOMEM_ERROR; // caller sets error
return terrorCode;
}
pageId= key.m_page_no;
pageOffset= key.m_page_idx;
Uint32 attrDescIndex= tablePtr.p->tabDescriptor + (0 << ZAD_LOG_SIZE);
Uint32 attrDataOffset= AttributeOffset::getOffset(
tableDescriptor[attrDescIndex + 1].tabDescr);
node= ptr + attrDataOffset;
return 0;
}
void
Ndbfs::execCONTINUEB(Signal* signal)
{
jamEntry();
if (signal->theData[0] == NdbfsContinueB::ZSCAN_MEMORYCHANNEL_10MS_DELAY) {
jam();
// Also send CONTINUEB to ourself in order to scan for
// incoming answers from AsyncFile on MemoryChannel theFromThreads
signal->theData[0] = NdbfsContinueB::ZSCAN_MEMORYCHANNEL_10MS_DELAY;
sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 10, 1);
if (scanningInProgress == true) {
jam();
return;
}
}
if (scanIPC(signal)) {
jam();
scanningInProgress = true;
signal->theData[0] = NdbfsContinueB::ZSCAN_MEMORYCHANNEL_NO_DELAY;
sendSignal(reference(), GSN_CONTINUEB, signal, 1, JBB);
} else {
jam();
scanningInProgress = false;
}
return;
}
void Dbinfo::execDUMP_STATE_ORD(Signal* signal)
{
jamEntry();
switch(signal->theData[0])
{
case DumpStateOrd::DbinfoListTables:
jam();
ndbout_c("--- BEGIN NDB$INFO.TABLES ---");
for(int i = 0; i < Ndbinfo::getNumTables(); i++)
{
const Ndbinfo::Table& tab = Ndbinfo::getTable(i);
ndbout_c("%d,%s", i, tab.m.name);
}
ndbout_c("--- END NDB$INFO.TABLES ---");
break;
case DumpStateOrd::DbinfoListColumns:
jam();
ndbout_c("--- BEGIN NDB$INFO.COLUMNS ---");
for(int i = 0; i < Ndbinfo::getNumTables(); i++)
{
const Ndbinfo::Table& tab = Ndbinfo::getTable(i);
for(int j = 0; j < tab.m.ncols; j++)
ndbout_c("%d,%d,%s,%d", i, j,
tab.col[j].name, tab.col[j].coltype);
}
ndbout_c("--- END NDB$INFO.COLUMNS ---");
break;
};
}
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
Restore::execFSREADCONF(Signal * signal)
{
jamEntry();
FilePtr file_ptr;
FsConf* conf= (FsConf*)signal->getDataPtr();
m_file_pool.getPtr(file_ptr, conf->userPointer);
file_ptr.p->m_bytes_left += conf->bytes_read;
ndbassert(file_ptr.p->m_outstanding_reads);
file_ptr.p->m_outstanding_reads--;
if(file_ptr.p->m_outstanding_reads == 0)
{
ndbassert(conf->bytes_read <= GLOBAL_PAGE_SIZE);
if(conf->bytes_read == GLOBAL_PAGE_SIZE)
{
read_file(signal, file_ptr);
}
else
{
file_ptr.p->m_status |= File::FILE_EOF;
file_ptr.p->m_status &= ~(Uint32)File::FILE_THREAD_RUNNING;
}
}
}
void
Restore::execRESTORE_LCP_REQ(Signal* signal){
jamEntry();
Uint32 err= 0;
RestoreLcpReq* req= (RestoreLcpReq*)signal->getDataPtr();
Uint32 senderRef= req->senderRef;
Uint32 senderData= req->senderData;
do
{
FilePtr file_ptr;
if (!m_file_list.seizeFirst(file_ptr))
{
err= RestoreLcpRef::NoFileRecord;
break;
}
if((err= init_file(req, file_ptr)))
{
break;
}
open_file(signal, file_ptr);
return;
} while(0);
RestoreLcpRef* ref= (RestoreLcpRef*)signal->getDataPtrSend();
ref->senderData= senderData;
ref->senderRef= reference();
ref->errorCode = err;
sendSignal(senderRef, GSN_RESTORE_LCP_REF, signal,
RestoreLcpRef::SignalLength, JBB);
}
void
Restore::execDUMP_STATE_ORD(Signal* signal){
jamEntry();
if (signal->theData[0] == DumpStateOrd::RestoreRates)
{
jam();
Uint64 rate = m_bytes_restored * 1000 /
(m_millis_spent == 0? 1: m_millis_spent);
g_eventLogger->info("LDM instance %u: Restored LCP : %u fragments,"
" %llu rows, "
"%llu bytes, %llu millis, %llu bytes/s",
instance(),
m_frags_restored,
m_rows_restored,
m_bytes_restored,
m_millis_spent,
rate);
infoEvent("LDM instance %u: Restored LCP : %u fragments, %llu rows, "
"%llu bytes, %llu millis, %llu bytes/s",
instance(),
m_frags_restored,
m_rows_restored,
m_bytes_restored,
m_millis_spent,
rate);
}
}
void
Trix::execREAD_CONFIG_REQ(Signal* signal)
{
jamEntry();
const ReadConfigReq * req = (ReadConfigReq*)signal->getDataPtr();
Uint32 ref = req->senderRef;
Uint32 senderData = req->senderData;
const ndb_mgm_configuration_iterator * p =
m_ctx.m_config.getOwnConfigIterator();
ndbrequire(p != 0);
// Allocate pool sizes
c_theAttrOrderBufferPool.setSize(100);
c_theSubscriptionRecPool.setSize(100);
DLList<SubscriptionRecord> subscriptions(c_theSubscriptionRecPool);
SubscriptionRecPtr subptr;
while(subscriptions.seize(subptr) == true) {
new (subptr.p) SubscriptionRecord(c_theAttrOrderBufferPool);
}
subscriptions.release();
ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend();
conf->senderRef = reference();
conf->senderData = senderData;
sendSignal(ref, GSN_READ_CONFIG_CONF, signal,
ReadConfigConf::SignalLength, JBB);
}
void
Trix::execSUB_REMOVE_CONF(Signal* signal){
jamEntry();
SubRemoveConf * const conf = (SubRemoveConf*)signal->getDataPtrSend();
SubscriptionRecPtr subRecPtr;
c_theSubscriptions.getPtr(subRecPtr, conf->senderData);
if(subRecPtr.p->prepareId != RNIL){
jam();
UtilReleaseReq * const req = (UtilReleaseReq*)signal->getDataPtrSend();
req->prepareId = subRecPtr.p->prepareId;
req->senderData = subRecPtr.i;
sendSignal(DBUTIL_REF, GSN_UTIL_RELEASE_REQ, signal,
UtilReleaseReq::SignalLength , JBB);
return;
}
{
UtilReleaseConf * const conf = (UtilReleaseConf*)signal->getDataPtrSend();
conf->senderData = subRecPtr.i;
execUTIL_RELEASE_CONF(signal);
}
}
void Trix::execNODE_FAILREP(Signal* signal)
{
jamEntry();
NodeFailRep * const nodeFail = (NodeFailRep *) signal->getDataPtr();
//Uint32 failureNr = nodeFail->failNo;
//Uint32 numberNodes = nodeFail->noOfNodes;
Uint32 masterNodeId = nodeFail->masterNodeId;
NodeRecPtr nodeRecPtr;
for(c_theNodes.first(nodeRecPtr);
nodeRecPtr.i != RNIL;
c_theNodes.next(nodeRecPtr)) {
if(NodeBitmask::get(nodeFail->theNodes, nodeRecPtr.i)) {
nodeRecPtr.p->alive = false;
c_noNodesFailed++;
c_noActiveNodes--;
}
}
if (c_masterNodeId != masterNodeId) {
c_masterNodeId = masterNodeId;
NodeRecord* nodeRec = c_theNodes.getPtr(masterNodeId);
c_masterTrixRef = nodeRec->trixRef;
}
}
void Trix::execNDB_STTOR(Signal* signal)
{
jamEntry();
BlockReference ndbcntrRef = signal->theData[0];
Uint16 startphase = signal->theData[2]; /* RESTART PHASE */
Uint16 mynode = signal->theData[1];
//Uint16 restarttype = signal->theData[3];
//UintR configInfo1 = signal->theData[6]; /* CONFIGRATION INFO PART 1 */
//UintR configInfo2 = signal->theData[7]; /* CONFIGRATION INFO PART 2 */
switch (startphase) {
case 3:
jam();
/* SYMBOLIC START PHASE 4 */
/* ABSOLUTE PHASE 5 */
/* REQUEST NODE IDENTITIES FROM DBDIH */
signal->theData[0] = calcTrixBlockRef(mynode);
sendSignal(ndbcntrRef, GSN_READ_NODESREQ, signal, 1, JBB);
return;
break;
case 6:
break;
default:
break;
}
}
void
Dbtup::tuxFreeNode(Uint32 fragPtrI,
Uint32 pageId,
Uint32 pageOffset,
Uint32* node)
{
jamEntry();
FragrecordPtr fragPtr;
fragPtr.i= fragPtrI;
ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
TablerecPtr tablePtr;
tablePtr.i= fragPtr.p->fragTableId;
ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
Local_key key;
key.m_page_no = pageId;
key.m_page_idx = pageOffset;
PagePtr pagePtr;
Tuple_header* ptr = (Tuple_header*)get_ptr(&pagePtr, &key, tablePtr.p);
Uint32 attrDescIndex= tablePtr.p->tabDescriptor + (0 << ZAD_LOG_SIZE);
Uint32 attrDataOffset= AttributeOffset::getOffset(tableDescriptor[attrDescIndex + 1].tabDescr);
ndbrequire(node == (Uint32*)ptr + attrDataOffset);
free_fix_rec(fragPtr.p, tablePtr.p, &key, (Fix_page*)pagePtr.p);
}
void Cmvmi::execSTTOR(Signal* signal)
{
Uint32 theStartPhase = signal->theData[1];
jamEntry();
if (theStartPhase == 1){
jam();
if(m_ctx.m_config.lockPagesInMainMemory() == 1)
{
int res = NdbMem_MemLockAll(0);
if(res != 0){
g_eventLogger.warning("Failed to memlock pages");
warningEvent("Failed to memlock pages");
}
}
sendSTTORRY(signal);
return;
} else if (theStartPhase == 3) {
jam();
globalData.activateSendPacked = 1;
sendSTTORRY(signal);
} else if (theStartPhase == 8){
/*---------------------------------------------------*/
/* Open com to API + REP nodes */
/*---------------------------------------------------*/
signal->theData[0] = 0; // no answer
signal->theData[1] = 0; // no id
signal->theData[2] = NodeInfo::API;
execOPEN_COMREQ(signal);
globalData.theStartLevel = NodeState::SL_STARTED;
sendSTTORRY(signal);
}
}
void
Restore::execFSCLOSEREF(Signal * signal)
{
jamEntry();
SimulatedBlock::execFSCLOSEREF(signal);
ndbrequire(false);
}
void
Dbtup::scanClose(Signal* signal, ScanOpPtr scanPtr)
{
ScanOp& scan = *scanPtr.p;
ndbrequire(! (scan.m_bits & ScanOp::SCAN_LOCK_WAIT) && scan.m_accLockOp == RNIL);
// unlock all not unlocked by LQH
LocalDLFifoList<ScanLock> list(c_scanLockPool, scan.m_accLockOps);
ScanLockPtr lockPtr;
while (list.first(lockPtr)) {
jam();
AccLockReq* const lockReq = (AccLockReq*)signal->getDataPtrSend();
lockReq->returnCode = RNIL;
lockReq->requestInfo = AccLockReq::Abort;
lockReq->accOpPtr = lockPtr.p->m_accLockOp;
EXECUTE_DIRECT(DBACC, GSN_ACC_LOCKREQ, signal, AccLockReq::UndoSignalLength);
jamEntry();
ndbrequire(lockReq->returnCode == AccLockReq::Success);
list.release(lockPtr);
}
// send conf
NextScanConf* const conf = (NextScanConf*)signal->getDataPtrSend();
conf->scanPtr = scanPtr.p->m_userPtr;
conf->accOperationPtr = RNIL;
conf->fragId = RNIL;
unsigned signalLength = 3;
sendSignal(scanPtr.p->m_userRef, GSN_NEXT_SCANCONF,
signal, signalLength, JBB);
releaseScanOp(scanPtr);
}
/*
* Allocate index node in TUP.
*/
int
Dbtux::allocNode(Signal* signal, NodeHandle& node)
{
if (ERROR_INSERTED(12007)) {
jam();
CLEAR_ERROR_INSERT_VALUE;
return TuxMaintReq::NoMemError;
}
Frag& frag = node.m_frag;
Uint32 pageId = NullTupLoc.getPageId();
Uint32 pageOffset = NullTupLoc.getPageOffset();
Uint32* node32 = 0;
int errorCode = c_tup->tuxAllocNode(signal, frag.m_tupIndexFragPtrI, pageId, pageOffset, node32);
jamEntry();
if (errorCode == 0) {
jam();
node.m_loc = TupLoc(pageId, pageOffset);
node.m_node = reinterpret_cast<TreeNode*>(node32);
ndbrequire(node.m_loc != NullTupLoc && node.m_node != 0);
} else {
switch (errorCode) {
case 827:
errorCode = TuxMaintReq::NoMemError;
break;
}
}
return errorCode;
}
void
Dbtup::execALTER_TAB_CONF(Signal* signal)
{
jamEntry();
AlterTabConf* conf = (AlterTabConf*)signal->getDataPtr();
BuildIndexPtr buildPtr;
buildPtr.i = conf->senderData;
c_buildIndexList.getPtr(buildPtr);
if (buildPtr.p->m_fragNo == 0)
{
jam();
buildIndexOffline_table_readonly(signal, conf->senderData);
return;
}
else
{
jam();
ndbrequire(buildPtr.p->m_fragNo >= MAX_FRAG_PER_NODE);
buildIndexReply(signal, buildPtr.p);
c_buildIndexList.release(buildPtr);
return;
}
}
/* Received a restart signal.
* Answer it like any other block
* PR0 : StartCase
* DR0 : StartPhase
* DR1 : ?
* DR2 : ?
* DR3 : ?
* DR4 : ?
* DR5 : SignalKey
*/
void
Ndbfs::execSTTOR(Signal* signal)
{
jamEntry();
if(signal->theData[1] == 0){ // StartPhase 0
jam();
{
#ifdef NDB_WIN32
CreateDirectory(theFileSystemPath.c_str(), 0);
#else
mkdir(theFileSystemPath.c_str(),
S_IRUSR | S_IWUSR | S_IXUSR | S_IXGRP | S_IRGRP);
#endif
}
cownref = NDBFS_REF;
// close all open files
ndbrequire(theOpenFiles.size() == 0);
scanningInProgress = false;
signal->theData[0] = NdbfsContinueB::ZSCAN_MEMORYCHANNEL_10MS_DELAY;
sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 10, 1);
signal->theData[3] = 255;
sendSignal(NDBCNTR_REF, GSN_STTORRY, signal,4, JBB);
return;
}
ndbrequire(0);
}
/* ---------------------------------------------------------------- */
void Dbtup::execSTORED_PROCREQ(Signal* signal)
{
OperationrecPtr regOperPtr;
TablerecPtr regTabPtr;
jamEntry();
regOperPtr.i = signal->theData[0];
c_operation_pool.getPtr(regOperPtr);
regTabPtr.i = signal->theData[1];
ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);
Uint32 requestInfo = signal->theData[3];
TransState trans_state= get_trans_state(regOperPtr.p);
ndbrequire(trans_state == TRANS_IDLE ||
((trans_state == TRANS_ERROR_WAIT_STORED_PROCREQ) &&
(requestInfo == ZSTORED_PROCEDURE_DELETE)));
ndbrequire(regTabPtr.p->tableStatus == DEFINED);
switch (requestInfo) {
case ZSCAN_PROCEDURE:
jam();
scanProcedure(signal,
regOperPtr.p,
signal->theData[4]);
break;
case ZCOPY_PROCEDURE:
jam();
copyProcedure(signal, regTabPtr, regOperPtr.p);
break;
case ZSTORED_PROCEDURE_DELETE:
jam();
deleteScanProcedure(signal, regOperPtr.p);
break;
default:
ndbrequire(false);
}//switch
}//Dbtup::execSTORED_PROCREQ()
void Dbtup::execSEND_PACKED(Signal* signal)
{
Uint16 hostId;
Uint32 i;
Uint32 TpackedListIndex= cpackedListIndex;
jamEntry();
for (i= 0; i < TpackedListIndex; i++) {
jam();
hostId= cpackedList[i];
ndbrequire((hostId - 1) < (MAX_NODES - 1)); // Also check not zero
Uint32 TpacketTA= hostBuffer[hostId].noOfPacketsTA;
if (TpacketTA != 0) {
jam();
BlockReference TBref= numberToRef(API_PACKED, hostId);
Uint32 TpacketLen= hostBuffer[hostId].packetLenTA;
MEMCOPY_NO_WORDS(&signal->theData[0],
&hostBuffer[hostId].packetBufferTA[0],
TpacketLen);
sendSignal(TBref, GSN_TRANSID_AI, signal, TpacketLen, JBB);
hostBuffer[hostId].noOfPacketsTA= 0;
hostBuffer[hostId].packetLenTA= 0;
}
hostBuffer[hostId].inPackedList= false;
}//for
cpackedListIndex= 0;
}
/*
* PR0: File Pointer DR0: User reference DR1: User Pointer
*/
void
Ndbfs::execFSSYNCREQ(Signal * signal)
{
jamEntry();
Uint16 filePointer = (Uint16)signal->theData[0];
BlockReference userRef = signal->theData[1];
const UintR userPointer = signal->theData[2];
AsyncFile* openFile = theOpenFiles.find(filePointer);
if (openFile == NULL) {
jam(); //file not open
FsRef * const fsRef = (FsRef *)&signal->theData[0];
fsRef->userPointer = userPointer;
fsRef->setErrorCode(fsRef->errorCode, FsRef::fsErrFileDoesNotExist);
fsRef->osErrorCode = ~0; // Indicate local error
sendSignal(userRef, GSN_FSSYNCREF, signal, 3, JBB);
return;
}
Request *request = theRequestPool->get();
request->error = 0;
request->action = Request::sync;
request->set(userRef, userPointer, filePointer);
request->file = openFile;
request->theTrace = signal->getTrace();
ndbrequire(forward(openFile,request));
}
void
DblqhProxy::execLQH_TRANSREQ(Signal* signal)
{
jamEntry();
if (!checkNodeFailSequence(signal))
{
jam();
return;
}
const LqhTransReq* req = (const LqhTransReq*)signal->getDataPtr();
Ss_LQH_TRANSREQ& ss = ssSeize<Ss_LQH_TRANSREQ>();
ss.m_req = *req;
ndbrequire(signal->getLength() == LqhTransReq::SignalLength);
sendREQ(signal, ss);
/**
* See if this is a "resend" (i.e multi TC failure)
* and if so, mark "old" record as invalid
*/
Uint32 nodeId = ss.m_req.failedNodeId;
for (Uint32 i = 0; i<NDB_ARRAY_SIZE(c_ss_LQH_TRANSREQ.m_pool); i++)
{
if (c_ss_LQH_TRANSREQ.m_pool[i].m_ssId != 0 &&
c_ss_LQH_TRANSREQ.m_pool[i].m_ssId != ss.m_ssId &&
c_ss_LQH_TRANSREQ.m_pool[i].m_req.failedNodeId == nodeId)
{
jam();
c_ss_LQH_TRANSREQ.m_pool[i].m_valid = false;
}
}
}
void
Dbtux::execCONTINUEB(Signal* signal)
{
jamEntry();
const Uint32* data = signal->getDataPtr();
switch (data[0]) {
case TuxContinueB::DropIndex: // currently unused
{
IndexPtr indexPtr;
c_indexPool.getPtr(indexPtr, data[1]);
dropIndex(signal, indexPtr, data[2], data[3]);
}
break;
case TuxContinueB::StatMon:
{
Uint32 id = data[1];
ndbrequire(id == c_statMon.m_loopIndexId);
statMonExecContinueB(signal);
}
break;
default:
ndbrequire(false);
break;
}
}
void
DblqhProxy::execEND_LCP_CONF(Signal* signal)
{
jamEntry();
ndbrequire(c_lcpRecord.m_state == LcpRecord::L_COMPLETING_1 ||
c_lcpRecord.m_state == LcpRecord::L_COMPLETING_2 ||
c_lcpRecord.m_state == LcpRecord::L_COMPLETING_3);
ndbrequire(c_lcpRecord.m_complete_outstanding);
c_lcpRecord.m_complete_outstanding--;
if (c_lcpRecord.m_complete_outstanding == 0)
{
jam();
if (c_lcpRecord.m_state == LcpRecord::L_COMPLETING_1)
{
jam();
completeLCP_2(signal);
return;
}
else if (c_lcpRecord.m_state == LcpRecord::L_COMPLETING_2)
{
jam();
completeLCP_3(signal);
return;
}
else
{
jam();
sendLCP_COMPLETE_REP(signal);
return;
}
}
}
