/****************************************************************************
void handleReceivedSignal(NdbApiSignal* aSignal);
Parameters: aSignal: The signal object.
Remark: Send all operations belonging to this connection.
*****************************************************************************/
void
Ndb::handleReceivedSignal(const NdbApiSignal* aSignal,
const LinearSectionPtr ptr[3])
{
NdbOperation* tOp;
NdbIndexOperation* tIndexOp;
NdbTransaction* tCon;
int tReturnCode = -1;
const Uint32* tDataPtr = aSignal->getDataPtr();
const Uint32 tWaitState = theImpl->theWaiter.get_state();
const Uint32 tSignalNumber = aSignal->readSignalNumber();
const Uint32 tFirstData = *tDataPtr;
const Uint32 tLen = aSignal->getLength();
Uint32 tNewState = tWaitState;
void * tFirstDataPtr;
NdbWaiter *t_waiter = &theImpl->theWaiter;
/* Update cached Min Db node version */
theCachedMinDbNodeVersion = theImpl->m_transporter_facade->getMinDbNodeVersion();
if (likely(NdbImpl::recordGSN(tSignalNumber)))
{
Uint32 secs = aSignal->m_noOfSections;
theImpl->incClientStat(BytesRecvdCount,
((aSignal->getLength() << 2) +
((secs > 2)? ptr[2].sz << 2: 0) +
((secs > 1)? ptr[1].sz << 2: 0) +
((secs > 0)? ptr[0].sz << 2: 0)));
}
/*
In order to support 64 bit processes in the application we need to use
id's rather than a direct pointer to the object used. It is also a good
idea that one cannot corrupt the application code by sending a corrupt
memory pointer.
All signals received by the API requires the first data word to be such
an id to the receiving object.
*/
switch (tSignalNumber){
case GSN_TCKEYCONF:
case GSN_TCINDXCONF:
{
const TcKeyConf * const keyConf = (TcKeyConf *)tDataPtr;
if (tFirstData != RNIL)
{
tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
tCon = void2con(tFirstDataPtr);
}
else
{
tCon = lookupTransactionFromOperation(keyConf);
if (tCon == NULL) goto InvalidSignal;
}
const BlockReference aTCRef = aSignal->theSendersBlockRef;
if ((tCon->checkMagicNumber() == 0) &&
(tCon->theSendStatus == NdbTransaction::sendTC_OP)) {
tReturnCode = tCon->receiveTCKEYCONF(keyConf, tLen);
if (tReturnCode != -1) {
completedTransaction(tCon);
}//if
if(TcKeyConf::getMarkerFlag(keyConf->confInfo)){
NdbTransaction::sendTC_COMMIT_ACK(theImpl,
theCommitAckSignal,
keyConf->transId1,
keyConf->transId2,
aTCRef);
}
return;
}//if
goto InvalidSignal;
return;
}
case GSN_TRANSID_AI:{
tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr){
NdbReceiver* const tRec = void2rec(tFirstDataPtr);
if(!tRec->checkMagicNumber()){
return;
}
tCon = tRec->getTransaction();
if((tCon!=NULL) &&
tCon->checkState_TransId(((const TransIdAI*)tDataPtr)->transId)){
Uint32 com;
if(aSignal->m_noOfSections > 0){
if(tRec->getType()==NdbReceiver::NDB_QUERY_OPERATION){
com = ((NdbQueryOperationImpl*)(tRec->m_owner))
->execTRANSID_AI(ptr[0].p, ptr[0].sz);
}else{
com = tRec->execTRANSID_AI(ptr[0].p, ptr[0].sz);
}
} else {
assert(tRec->getType()!=NdbReceiver::NDB_QUERY_OPERATION);
com = tRec->execTRANSID_AI(tDataPtr + TransIdAI::HeaderLength,
tLen - TransIdAI::HeaderLength);
}
{
tCon->theNdb->theImpl->incClientStat(Ndb::ReadRowCount, 1);
if (refToNode(aSignal->theSendersBlockRef) == tCon->theDBnode)
tCon->theNdb->theImpl->incClientStat(Ndb::TransLocalReadRowCount,1);
}
if(com == 0)
return;
switch(tRec->getType()){
case NdbReceiver::NDB_OPERATION:
case NdbReceiver::NDB_INDEX_OPERATION:
if(tCon->OpCompleteSuccess() != -1){ //More completions pending?
completedTransaction(tCon);
}
return;
case NdbReceiver::NDB_SCANRECEIVER:
tCon->theScanningOp->receiver_delivered(tRec);
tNewState = (((WaitSignalType) tWaitState) == WAIT_SCAN ?
(Uint32) NO_WAIT : tWaitState);
break;
case NdbReceiver::NDB_QUERY_OPERATION:
{
// Handled differently whether it is a scan or lookup
NdbQueryOperationImpl* tmp = (NdbQueryOperationImpl*)(tRec->m_owner);
if (tmp->getQueryDef().isScanQuery()) {
tNewState = (((WaitSignalType) tWaitState) == WAIT_SCAN ?
(Uint32) NO_WAIT : tWaitState);
break;
} else {
if (tCon->OpCompleteSuccess() != -1) { //More completions pending?
completedTransaction(tCon);
}
return;
}
}
default:
goto InvalidSignal;
}
break;
} else {
/**
* This is ok as transaction can have been aborted before TRANSID_AI
* arrives (if TUP on other node than TC)
*/
return;
}
} else{ // if((tFirstDataPtr)
return;
}
}
case GSN_TCKEY_FAILCONF:
{
tFirstDataPtr = int2void(tFirstData);
const TcKeyFailConf * failConf = (TcKeyFailConf *)tDataPtr;
const BlockReference aTCRef = aSignal->theSendersBlockRef;
if (tFirstDataPtr != 0){
tOp = void2rec_op(tFirstDataPtr);
if (tOp->checkMagicNumber(false) == 0) {
tCon = tOp->theNdbCon;
if (tCon != NULL) {
if ((tCon->theSendStatus == NdbTransaction::sendTC_OP) ||
(tCon->theSendStatus == NdbTransaction::sendTC_COMMIT)) {
tReturnCode = tCon->receiveTCKEY_FAILCONF(failConf);
if (tReturnCode != -1) {
completedTransaction(tCon);
}//if
}//if
}
}
} else {
#ifdef VM_TRACE
ndbout_c("Recevied TCKEY_FAILCONF wo/ operation");
#endif
}
if(tFirstData & 1){
NdbTransaction::sendTC_COMMIT_ACK(theImpl,
theCommitAckSignal,
failConf->transId1,
failConf->transId2,
aTCRef);
}
return;
}
case GSN_TCKEY_FAILREF:
{
tFirstDataPtr = int2void(tFirstData);
if(tFirstDataPtr != 0){
tOp = void2rec_op(tFirstDataPtr);
if (tOp->checkMagicNumber(false) == 0) {
tCon = tOp->theNdbCon;
if (tCon != NULL) {
if ((tCon->theSendStatus == NdbTransaction::sendTC_OP) ||
(tCon->theSendStatus == NdbTransaction::sendTC_ROLLBACK)) {
tReturnCode = tCon->receiveTCKEY_FAILREF(aSignal);
if (tReturnCode != -1) {
completedTransaction(tCon);
return;
}//if
}//if
}//if
}//if
}
#ifdef VM_TRACE
ndbout_c("Recevied TCKEY_FAILREF wo/ operation");
#endif
return;
return;
}
case GSN_TCKEYREF:
{
tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
const NdbReceiver* const receiver = void2rec(tFirstDataPtr);
if(!receiver->checkMagicNumber()){
goto InvalidSignal;
}
tCon = receiver->getTransaction();
if (tCon != NULL) {
if (tCon->theSendStatus == NdbTransaction::sendTC_OP) {
if (receiver->getType()==NdbReceiver::NDB_QUERY_OPERATION) {
NdbQueryOperationImpl* tmp =
(NdbQueryOperationImpl*)(receiver->m_owner);
if (tmp->execTCKEYREF(aSignal) &&
tCon->OpCompleteFailure() != -1) {
completedTransaction(tCon);
return;
}
} else {
tOp = void2rec_op(tFirstDataPtr);
/* NB! NdbOperation::checkMagicNumber() returns 0 if it *is*
* an NdbOperation.*/
assert(tOp->checkMagicNumber()==0);
tReturnCode = tOp->receiveTCKEYREF(aSignal);
if (tReturnCode != -1) {
completedTransaction(tCon);
return;
}//if
}//if
break;
}//if
}//if (tCon != NULL)
goto InvalidSignal;
return;
}
case GSN_TC_COMMITCONF:
{
tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
const TcCommitConf * const commitConf = (TcCommitConf *)tDataPtr;
const BlockReference aTCRef = aSignal->theSendersBlockRef;
tCon = void2con(tFirstDataPtr);
if ((tCon->checkMagicNumber() == 0) &&
(tCon->theSendStatus == NdbTransaction::sendTC_COMMIT)) {
tReturnCode = tCon->receiveTC_COMMITCONF(commitConf, tLen);
if (tReturnCode != -1) {
completedTransaction(tCon);
}//if
if(tFirstData & 1){
NdbTransaction::sendTC_COMMIT_ACK(theImpl,
theCommitAckSignal,
commitConf->transId1,
commitConf->transId2,
aTCRef);
}
return;
}
goto InvalidSignal;
return;
}
case GSN_TC_COMMITREF:
{
tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
tCon = void2con(tFirstDataPtr);
if ((tCon->checkMagicNumber() == 0) &&
(tCon->theSendStatus == NdbTransaction::sendTC_COMMIT)) {
tReturnCode = tCon->receiveTC_COMMITREF(aSignal);
if (tReturnCode != -1) {
completedTransaction(tCon);
}//if
}//if
return;
}
case GSN_TCROLLBACKCONF:
{
tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
tCon = void2con(tFirstDataPtr);
if ((tCon->checkMagicNumber() == 0) &&
(tCon->theSendStatus == NdbTransaction::sendTC_ROLLBACK)) {
tReturnCode = tCon->receiveTCROLLBACKCONF(aSignal);
if (tReturnCode != -1) {
completedTransaction(tCon);
}//if
}//if
return;
}
case GSN_TCROLLBACKREF:
{
tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
tCon = void2con(tFirstDataPtr);
if ((tCon->checkMagicNumber() == 0) &&
(tCon->theSendStatus == NdbTransaction::sendTC_ROLLBACK)) {
tReturnCode = tCon->receiveTCROLLBACKREF(aSignal);
if (tReturnCode != -1) {
completedTransaction(tCon);
}//if
}//if
return;
}
case GSN_TCROLLBACKREP:
{
tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
tCon = void2con(tFirstDataPtr);
if (tCon->checkMagicNumber() == 0) {
tReturnCode = tCon->receiveTCROLLBACKREP(aSignal);
if (tReturnCode != -1) {
completedTransaction(tCon);
}//if
}//if
return;
}
case GSN_TCSEIZECONF:
{
tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
if (tWaitState != WAIT_TC_SEIZE) {
goto InvalidSignal;
}//if
tCon = void2con(tFirstDataPtr);
if (tCon->checkMagicNumber() != 0) {
goto InvalidSignal;
}//if
tReturnCode = tCon->receiveTCSEIZECONF(aSignal);
if (tReturnCode != -1) {
tNewState = NO_WAIT;
} else {
goto InvalidSignal;
}//if
break;
}
case GSN_TCSEIZEREF:
{
tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
if (tWaitState != WAIT_TC_SEIZE) {
return;
}//if
tCon = void2con(tFirstDataPtr);
if (tCon->checkMagicNumber() != 0) {
return;
}//if
tReturnCode = tCon->receiveTCSEIZEREF(aSignal);
if (tReturnCode != -1) {
tNewState = NO_WAIT;
} else {
return;
}//if
break;
}
case GSN_TCRELEASECONF:
{
tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
if (tWaitState != WAIT_TC_RELEASE) {
goto InvalidSignal;
}//if
tCon = void2con(tFirstDataPtr);
if (tCon->checkMagicNumber() != 0) {
goto InvalidSignal;
}//if
tReturnCode = tCon->receiveTCRELEASECONF(aSignal);
if (tReturnCode != -1) {
tNewState = NO_WAIT;
}//if
break;
}
case GSN_TCRELEASEREF:
{
tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
if (tWaitState != WAIT_TC_RELEASE) {
goto InvalidSignal;
}//if
tCon = void2con(tFirstDataPtr);
if (tCon->checkMagicNumber() != 0) {
goto InvalidSignal;
}//if
tReturnCode = tCon->receiveTCRELEASEREF(aSignal);
if (tReturnCode != -1) {
tNewState = NO_WAIT;
}//if
break;
}
case GSN_GET_TABINFOREF:
case GSN_GET_TABINFO_CONF:
case GSN_CREATE_TABLE_REF:
case GSN_CREATE_TABLE_CONF:
case GSN_DROP_TABLE_CONF:
case GSN_DROP_TABLE_REF:
case GSN_ALTER_TABLE_CONF:
case GSN_ALTER_TABLE_REF:
case GSN_CREATE_INDX_CONF:
case GSN_CREATE_INDX_REF:
case GSN_DROP_INDX_CONF:
case GSN_DROP_INDX_REF:
case GSN_INDEX_STAT_CONF:
case GSN_INDEX_STAT_REF:
case GSN_CREATE_EVNT_CONF:
case GSN_CREATE_EVNT_REF:
case GSN_DROP_EVNT_CONF:
case GSN_DROP_EVNT_REF:
case GSN_LIST_TABLES_CONF:
case GSN_CREATE_FILE_REF:
case GSN_CREATE_FILE_CONF:
case GSN_CREATE_FILEGROUP_REF:
case GSN_CREATE_FILEGROUP_CONF:
case GSN_DROP_FILE_REF:
case GSN_DROP_FILE_CONF:
case GSN_DROP_FILEGROUP_REF:
case GSN_DROP_FILEGROUP_CONF:
case GSN_SCHEMA_TRANS_BEGIN_CONF:
case GSN_SCHEMA_TRANS_BEGIN_REF:
case GSN_SCHEMA_TRANS_END_CONF:
case GSN_SCHEMA_TRANS_END_REF:
case GSN_SCHEMA_TRANS_END_REP:
case GSN_WAIT_GCP_CONF:
case GSN_WAIT_GCP_REF:
case GSN_CREATE_HASH_MAP_REF:
case GSN_CREATE_HASH_MAP_CONF:
NdbDictInterface::execSignal(&theDictionary->m_receiver,
aSignal, ptr);
return;
case GSN_SUB_REMOVE_CONF:
case GSN_SUB_REMOVE_REF:
return; // ignore these signals
case GSN_SUB_START_CONF:
case GSN_SUB_START_REF:
case GSN_SUB_STOP_CONF:
case GSN_SUB_STOP_REF:
NdbDictInterface::execSignal(&theDictionary->m_receiver,
aSignal, ptr);
return;
case GSN_SUB_GCP_COMPLETE_REP:
{
const SubGcpCompleteRep * const rep=
CAST_CONSTPTR(SubGcpCompleteRep, aSignal->getDataPtr());
theEventBuffer->execSUB_GCP_COMPLETE_REP(rep, tLen);
return;
}
case GSN_SUB_TABLE_DATA:
{
const SubTableData * const sdata=
CAST_CONSTPTR(SubTableData, aSignal->getDataPtr());
const Uint32 oid = sdata->senderData;
NdbEventOperationImpl *op= (NdbEventOperationImpl*)int2void(oid);
if (unlikely(op == 0 || op->m_magic_number != NDB_EVENT_OP_MAGIC_NUMBER))
{
g_eventLogger->error("dropped GSN_SUB_TABLE_DATA due to wrong magic "
"number");
return ;
}
// Accumulate DIC_TAB_INFO for TE_ALTER events
if (SubTableData::getOperation(sdata->requestInfo) ==
NdbDictionary::Event::_TE_ALTER &&
!op->execSUB_TABLE_DATA(aSignal, ptr))
return;
LinearSectionPtr copy[3];
for (int i = 0; i<aSignal->m_noOfSections; i++)
{
copy[i] = ptr[i];
}
for (int i = aSignal->m_noOfSections; i < 3; i++)
{
copy[i].p = NULL;
copy[i].sz = 0;
}
DBUG_PRINT("info",("oid=senderData: %d, gci{hi/lo}: %d/%d, operation: %d, "
"tableId: %d",
sdata->senderData, sdata->gci_hi, sdata->gci_lo,
SubTableData::getOperation(sdata->requestInfo),
sdata->tableId));
theEventBuffer->insertDataL(op, sdata, tLen, copy);
return;
}
case GSN_SCAN_TABCONF:
{
tFirstDataPtr = int2void(tFirstData);
assert(tFirstDataPtr);
assert(void2con(tFirstDataPtr));
assert(void2con(tFirstDataPtr)->checkMagicNumber() == 0);
if(tFirstDataPtr &&
(tCon = void2con(tFirstDataPtr)) && (tCon->checkMagicNumber() == 0)){
if(aSignal->m_noOfSections > 0){
tReturnCode = tCon->receiveSCAN_TABCONF(aSignal,
ptr[0].p, ptr[0].sz);
} else {
tReturnCode =
tCon->receiveSCAN_TABCONF(aSignal,
tDataPtr + ScanTabConf::SignalLength,
tLen - ScanTabConf::SignalLength);
}
if (tReturnCode != -1 && tWaitState == WAIT_SCAN)
tNewState = NO_WAIT;
break;
} else {
goto InvalidSignal;
}
}
case GSN_SCAN_TABREF:
{
tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
tCon = void2con(tFirstDataPtr);
assert(tFirstDataPtr != 0 &&
void2con(tFirstDataPtr)->checkMagicNumber() == 0);
if (tCon->checkMagicNumber() == 0){
tReturnCode = tCon->receiveSCAN_TABREF(aSignal);
if (tReturnCode != -1 && tWaitState == WAIT_SCAN){
tNewState = NO_WAIT;
}
break;
}
goto InvalidSignal;
}
case GSN_KEYINFO20: {
tFirstDataPtr = int2void(tFirstData);
NdbReceiver* tRec;
if (tFirstDataPtr && (tRec = void2rec(tFirstDataPtr)) &&
tRec->checkMagicNumber() && (tCon = tRec->getTransaction()) &&
tCon->checkState_TransId(&((const KeyInfo20*)tDataPtr)->transId1)){
Uint32 len = ((const KeyInfo20*)tDataPtr)->keyLen;
Uint32 info = ((const KeyInfo20*)tDataPtr)->scanInfo_Node;
int com = -1;
if(aSignal->m_noOfSections > 0 && len == ptr[0].sz){
com = tRec->execKEYINFO20(info, ptr[0].p, len);
} else if(len == tLen - KeyInfo20::HeaderLength){
com = tRec->execKEYINFO20(info, tDataPtr+KeyInfo20::HeaderLength, len);
}
switch(com){
case 1:
tCon->theScanningOp->receiver_delivered(tRec);
tNewState = (((WaitSignalType) tWaitState) == WAIT_SCAN ?
(Uint32) NO_WAIT : tWaitState);
break;
case 0:
break;
case -1:
goto InvalidSignal;
}
break;
} else {
/**
* This is ok as transaction can have been aborted before KEYINFO20
* arrives (if TUP on other node than TC)
*/
return;
}
}
case GSN_TCINDXREF:{
tFirstDataPtr = int2void(tFirstData);
if (tFirstDataPtr == 0) goto InvalidSignal;
tIndexOp = void2rec_iop(tFirstDataPtr);
if (tIndexOp->checkMagicNumber() == 0) {
tCon = tIndexOp->theNdbCon;
if (tCon != NULL) {
if (tCon->theSendStatus == NdbTransaction::sendTC_OP) {
tReturnCode = tIndexOp->receiveTCINDXREF(aSignal);
if (tReturnCode != -1) {
completedTransaction(tCon);
}//if
return;
}//if
}//if
}//if
goto InvalidSignal;
return;
}
case GSN_API_REGCONF:
case GSN_CONNECT_REP:
return; // Ignore
case GSN_NODE_FAILREP:
{
const NodeFailRep *rep = CAST_CONSTPTR(NodeFailRep,
aSignal->getDataPtr());
for (Uint32 i = NdbNodeBitmask::find_first(rep->theNodes);
i != NdbNodeBitmask::NotFound;
i = NdbNodeBitmask::find_next(rep->theNodes, i + 1))
{
report_node_failure(i);
}
NdbDictInterface::execSignal(&theDictionary->m_receiver, aSignal, ptr);
break;
}
case GSN_NF_COMPLETEREP:
{
const NFCompleteRep *rep = CAST_CONSTPTR(NFCompleteRep,
aSignal->getDataPtr());
report_node_failure_completed(rep->failedNodeId);
break;
}
case GSN_TAKE_OVERTCCONF:
abortTransactionsAfterNodeFailure(tFirstData); // theData[0]
break;
case GSN_ALLOC_NODEID_CONF:
{
const AllocNodeIdConf *rep = CAST_CONSTPTR(AllocNodeIdConf,
aSignal->getDataPtr());
Uint32 nodeId = rep->nodeId;
connected(numberToRef(theNdbBlockNumber, nodeId));
break;
}
default:
tFirstDataPtr = NULL;
goto InvalidSignal;
}//swich
if (tNewState != tWaitState)
{
/*
If our waiter object is the owner of the "poll rights", then we
can simply return, we will return from this routine to the
place where external_poll was called. From there it will move
the "poll ownership" to a new thread if available.
If our waiter object doesn't own the "poll rights", then we must
signal the thread from where this waiter object called
its conditional wait. This will wake up this thread so that it
can continue its work.
*/
t_waiter->signal(tNewState);
}
return;
InvalidSignal:
#ifdef VM_TRACE
ndbout_c("Ndbif: Error Ndb::handleReceivedSignal "
"(tFirstDataPtr=%p, GSN=%d, theImpl->theWaiter.m_state=%d)"
" sender = (Block: %d Node: %d)",
tFirstDataPtr,
tSignalNumber,
tWaitState,
refToBlock(aSignal->theSendersBlockRef),
refToNode(aSignal->theSendersBlockRef));
#endif
#ifdef NDB_NO_DROPPED_SIGNAL
abort();
#endif
return;
}//Ndb::handleReceivedSignal()
