The world's most popular open source database

MySQL 5.1: SimulatedBlock Class Reference

SimulatedBlock Class Reference

#include <SimulatedBlock.hpp>

Inheritance diagram for SimulatedBlock:

[legend]Collaboration diagram for SimulatedBlock:

[legend]List of all members.


Public Types
typedef void(SimulatedBlock::*)	CallbackFunction (class Signal *, Uint32 callbackData, Uint32 returnCode)
Public Member Functions
virtual	~SimulatedBlock ()
void	executeFunction (GlobalSignalNumber gsn, Signal *signal)
virtual const char *	get_filename (Uint32 fd) const
void	ignoreMutexUnlockCallback (Signal *signal, Uint32 ptrI, Uint32 retVal)
Public Attributes
MutexManager	c_mutexMgr
SafeCounterManager	c_counterMgr
Protected Types
typedef void(SimulatedBlock::*)	ExecFunction (Signal *signal)
Protected Member Functions
	SimulatedBlock (BlockNumber blockNumber, struct Block_context &ctx)
void	addRecSignalImpl (GlobalSignalNumber g, ExecFunction fun, bool f=false)
void	installSimulatedBlockFunctions ()
void	execute (Signal *signal, Callback &c, Uint32 returnCode)
void	sendSignal (BlockReference ref, GlobalSignalNumber gsn, Signal *signal, Uint32 length, JobBufferLevel jbuf) const
void	sendSignal (NodeReceiverGroup rg, GlobalSignalNumber gsn, Signal *signal, Uint32 length, JobBufferLevel jbuf) const
void	sendSignal (BlockReference ref, GlobalSignalNumber gsn, Signal *signal, Uint32 length, JobBufferLevel jbuf, LinearSectionPtr ptr[3], Uint32 noOfSections) const
void	sendSignal (NodeReceiverGroup rg, GlobalSignalNumber gsn, Signal *signal, Uint32 length, JobBufferLevel jbuf, LinearSectionPtr ptr[3], Uint32 noOfSections) const
void	sendSignalWithDelay (BlockReference ref, GlobalSignalNumber gsn, Signal *signal, Uint32 delayInMilliSeconds, Uint32 length) const
void	EXECUTE_DIRECT (Uint32 block, Uint32 gsn, Signal *signal, Uint32 len)
SectionSegmentPool &	getSectionSegmentPool ()
void	releaseSections (Signal *signal)
bool	assembleFragments (Signal *signal)
void	sendFragmentedSignal (BlockReference ref, GlobalSignalNumber gsn, Signal *signal, Uint32 length, JobBufferLevel jbuf, Callback &=TheEmptyCallback, Uint32 messageSize=240)
void	sendFragmentedSignal (NodeReceiverGroup rg, GlobalSignalNumber gsn, Signal *signal, Uint32 length, JobBufferLevel jbuf, Callback &=TheEmptyCallback, Uint32 messageSize=240)
void	sendFragmentedSignal (BlockReference ref, GlobalSignalNumber gsn, Signal *signal, Uint32 length, JobBufferLevel jbuf, LinearSectionPtr ptr[3], Uint32 noOfSections, Callback &, Uint32 messageSize=240)
void	sendFragmentedSignal (NodeReceiverGroup rg, GlobalSignalNumber gsn, Signal *signal, Uint32 length, JobBufferLevel jbuf, LinearSectionPtr ptr[3], Uint32 noOfSections, Callback &, Uint32 messageSize=240)
bool	sendFirstFragment (FragmentSendInfo &info, NodeReceiverGroup rg, GlobalSignalNumber gsn, Signal *signal, Uint32 length, JobBufferLevel jbuf, LinearSectionPtr ptr[3], Uint32 noOfSections, Uint32 messageSize=240)
bool	sendFirstFragment (FragmentSendInfo &info, NodeReceiverGroup rg, GlobalSignalNumber gsn, Signal *signal, Uint32 length, JobBufferLevel jbuf, Uint32 messageSize=240)
void	sendNextSegmentedFragment (Signal *signal, FragmentSendInfo &info)
void	sendNextLinearFragment (Signal *signal, FragmentSendInfo &info)
BlockNumber	number () const
BlockReference	reference () const
NodeId	getOwnNodeId () const
void	refresh_watch_dog ()
void	progError (int line, int err_code, const char *extradata=NULL) const
NewVARIABLE *	allocateBat (int batSize)
void	freeBat ()
void *	allocRecord (const char *type, size_t s, size_t n, bool clear=true)
void	deallocRecord (void *, const char type, size_t s, size_t n)
void	infoEvent (const char *msg,...) const
void	warningEvent (const char *msg,...) const
const NodeState &	getNodeState () const
const NodeInfo &	getNodeInfo (NodeId nodeId) const
NodeInfo &	setNodeInfo (NodeId)
Uint32	xfrm_key (Uint32 tab, const Uint32 src, Uint32 dst, Uint32 dstSize, Uint32 keyPartLen[MAX_ATTRIBUTES_IN_INDEX]) const
Uint32	xfrm_attr (Uint32 attrDesc, CHARSET_INFO cs, const Uint32 src, Uint32 &srcPos, Uint32 *dst, Uint32 &dstPos, Uint32 dstSize) const
Uint32	create_distr_key (Uint32 tableId, Uint32 *data, const Uint32 keyPaLen[MAX_ATTRIBUTES_IN_INDEX]) const
void	execUPGRADE (Signal *signal)
void	fsRefError (Signal signal, Uint32 line, const char msg)
void	execFSWRITEREF (Signal *signal)
void	execFSREADREF (Signal *signal)
void	execFSOPENREF (Signal *signal)
void	execFSCLOSEREF (Signal *signal)
void	execFSREMOVEREF (Signal *signal)
void	execFSSYNCREF (Signal *signal)
void	execFSAPPENDREF (Signal *signal)
Static Protected Member Functions
static const NewVARIABLE *	getBat (BlockNumber blockNo)
static Uint16	getBatSize (BlockNumber blockNo)
static BlockReference	calcTcBlockRef (NodeId aNode)
static BlockReference	calcLqhBlockRef (NodeId aNode)
static BlockReference	calcAccBlockRef (NodeId aNode)
static BlockReference	calcTupBlockRef (NodeId aNode)
static BlockReference	calcTuxBlockRef (NodeId aNode)
static BlockReference	calcDihBlockRef (NodeId aNode)
static BlockReference	calcQmgrBlockRef (NodeId aNode)
static BlockReference	calcDictBlockRef (NodeId aNode)
static BlockReference	calcNdbCntrBlockRef (NodeId aNode)
static BlockReference	calcTrixBlockRef (NodeId aNode)
static BlockReference	calcBackupBlockRef (NodeId aNode)
static BlockReference	calcSumaBlockRef (NodeId aNode)
static BlockReference	calcApiClusterMgrBlockRef (NodeId aNode)
Protected Attributes
ExecFunction	theExecArray [MAX_GSN+1]
Block_context	m_ctx
ArrayPool< GlobalPage > &	m_global_page_pool
ArrayPool< GlobalPage > &	m_shared_page_pool
	ERROR_INSERT_VARIABLE
Static Protected Attributes
static Callback	TheEmptyCallback = {0, 0}
Private Member Functions
void	signal_error (Uint32, Uint32, Uint32, const char *, int) const
void	execNDB_TAMPER (Signal *signal)
void	execNODE_STATE_REP (Signal *signal)
void	execCHANGE_NODE_STATE_REQ (Signal *signal)
void	execSIGNAL_DROPPED_REP (Signal *signal)
void	execCONTINUE_FRAGMENTED (Signal *signal)
void	execAPI_START_REP (Signal *signal)
void	execNODE_START_REP (Signal *signal)
virtual void	exec_node_start_rep (Signal *signal)
void	execUTIL_CREATE_LOCK_REF (Signal *signal)
void	execUTIL_CREATE_LOCK_CONF (Signal *signal)
void	execUTIL_DESTORY_LOCK_REF (Signal *signal)
void	execUTIL_DESTORY_LOCK_CONF (Signal *signal)
void	execUTIL_LOCK_REF (Signal *signal)
void	execUTIL_LOCK_CONF (Signal *signal)
void	execUTIL_UNLOCK_REF (Signal *signal)
void	execUTIL_UNLOCK_CONF (Signal *signal)
Private Attributes
const NodeId	theNodeId
const BlockNumber	theNumber
const BlockReference	theReference
NewVARIABLE *	NewVarRef
Uint16	theBATSize
NodeState	theNodeState
Uint32	c_fragmentIdCounter
ArrayPool< FragmentInfo >	c_fragmentInfoPool
DLHashTable< FragmentInfo >	c_fragmentInfoHash
bool	c_fragSenderRunning
ArrayPool< FragmentSendInfo >	c_fragmentSendPool
DLList< FragmentSendInfo >	c_linearFragmentSendList
DLList< FragmentSendInfo >	c_segmentedFragmentSendList
Friends
class	TraceLCP
class	SafeCounter
class	SafeCounterManager
struct	UpgradeStartup
class	AsyncFile
class	Pgman
class	Page_cache_client
class	Lgman
class	Logfile_client
struct	Pool_context
class	BlockComponent
class	MutexManager
Classes
struct	Callback
struct	FragmentInfo
struct	FragmentSendInfo
class	MutexManager

Detailed Description

Definition at line 89 of file SimulatedBlock.hpp.

Member Typedef Documentation

typedef void(SimulatedBlock::* ) SimulatedBlock::CallbackFunction(class Signal *, Uint32 callbackData, Uint32 returnCode)

Definition at line 124 of file SimulatedBlock.hpp.

typedef void(SimulatedBlock::* ) SimulatedBlock::ExecFunction(Signal *signal) [protected]

Definition at line 114 of file SimulatedBlock.hpp.

Constructor & Destructor Documentation

SimulatedBlock::~SimulatedBlock ( ) [virtual]

Definition at line 119 of file SimulatedBlock.cpp.

References freeBat().

00120 {
00121   freeBat();
00122 #ifdef VM_TRACE_TIME
00123   printTimes(stdout);
00124 #endif
00125 
00126 #ifdef VM_TRACE
00127   delete [] m_global_variables;
00128 #endif
00129 }

Here is the call graph for this function:

SimulatedBlock::SimulatedBlock	(	BlockNumber	blockNumber,
		struct Block_context &	ctx
	)			`[protected]`

Constructor

Definition at line 48 of file SimulatedBlock.cpp.

References buf, c_counterMgr, c_fragmentIdCounter, c_fragmentInfoHash, c_fragmentInfoPool, c_fragmentSendPool, c_fragSenderRunning, c_mutexMgr, CLEAR_ERROR_INSERT_VALUE, count, getBlockName(), globalData, UpgradeStartup::installEXEC(), installSimulatedBlockFunctions(), MAX_GSN, ndbrequire, NewVarRef, p, GlobalData::setBlock(), SafeCounterManager::setSize(), SimulatedBlock::MutexManager::setSize(), BaseString::snprintf(), and theExecArray.

00050   : theNodeId(globalData.ownId),
00051     theNumber(blockNumber),
00052     theReference(numberToRef(blockNumber, globalData.ownId)),
00053     m_ctx(ctx),
00054     m_global_page_pool(globalData.m_global_page_pool),
00055     m_shared_page_pool(globalData.m_shared_page_pool),
00056     c_fragmentInfoHash(c_fragmentInfoPool),
00057     c_linearFragmentSendList(c_fragmentSendPool),
00058     c_segmentedFragmentSendList(c_fragmentSendPool),
00059     c_mutexMgr(* this),
00060     c_counterMgr(* this)
00061 {
00062   NewVarRef = 0;
00063   
00064   globalData.setBlock(blockNumber, this);
00065   c_fragmentIdCounter = 1;
00066   c_fragSenderRunning = false;
00067   
00068   Properties tmp;
00069   const Properties * p = &tmp;
00070   ndbrequire(p != 0);
00071 
00072   Uint32 count = 10;
00073   char buf[255];
00074 
00075   count = 10;
00076   BaseString::snprintf(buf, 255, "%s.FragmentSendPool", getBlockName(blockNumber));
00077   if(!p->get(buf, &count))
00078     p->get("FragmentSendPool", &count);
00079   c_fragmentSendPool.setSize(count);
00080 
00081   count = 10;
00082   BaseString::snprintf(buf, 255, "%s.FragmentInfoPool", getBlockName(blockNumber));
00083   if(!p->get(buf, &count))
00084     p->get("FragmentInfoPool", &count);
00085   c_fragmentInfoPool.setSize(count);
00086 
00087   count = 10;
00088   BaseString::snprintf(buf, 255, "%s.FragmentInfoHash", getBlockName(blockNumber));
00089   if(!p->get(buf, &count))
00090     p->get("FragmentInfoHash", &count);
00091   c_fragmentInfoHash.setSize(count);
00092 
00093   count = 5;
00094   BaseString::snprintf(buf, 255, "%s.ActiveMutexes", getBlockName(blockNumber));
00095   if(!p->get(buf, &count))
00096     p->get("ActiveMutexes", &count);
00097   c_mutexMgr.setSize(count);
00098   
00099   c_counterMgr.setSize(5);
00100   
00101 #ifdef VM_TRACE_TIME
00102   clearTimes();
00103 #endif
00104 
00105   for(GlobalSignalNumber i = 0; i<=MAX_GSN; i++)
00106     theExecArray[i] = 0;
00107 
00108   installSimulatedBlockFunctions();
00109   UpgradeStartup::installEXEC(this);
00110 
00111   CLEAR_ERROR_INSERT_VALUE;
00112 
00113 #ifdef VM_TRACE
00114   m_global_variables = new Ptr<void> * [1];
00115   m_global_variables[0] = 0;
00116 #endif
00117 }

Here is the call graph for this function:

Member Function Documentation

void SimulatedBlock::addRecSignalImpl	(	GlobalSignalNumber	g,
		ExecFunction	fun,
		bool	f = `false`
	)			`[protected]`

Definition at line 159 of file SimulatedBlock.cpp.

References ERROR_SET, yaSSL::fatal, MAX_GSN, NDBD_EXIT_ILLEGAL_SIGNAL, BaseString::snprintf(), and theExecArray.

00160                                                             {
00161   if(gsn > MAX_GSN || (!force &&  theExecArray[gsn] != 0)){
00162     char errorMsg[255];
00163     BaseString::snprintf(errorMsg, 255, 
00164              "GSN %d(%d))", gsn, MAX_GSN); 
00165     ERROR_SET(fatal, NDBD_EXIT_ILLEGAL_SIGNAL, errorMsg, errorMsg);
00166   }
00167   theExecArray[gsn] = f;
00168 }

Here is the call graph for this function:

NewVARIABLE * SimulatedBlock::allocateBat ( int batSize ) [protected]

Definition at line 627 of file SimulatedBlock.cpp.

References NewVarRef, realloc, and theBATSize.

Referenced by Restore::execREAD_CONFIG_REQ(), Dbdict::execREAD_CONFIG_REQ(), Dblqh::initRecords(), and Dbdih::initRecords().

00627                                       {
00628   NewVARIABLE* bat = NewVarRef;
00629   bat = (NewVARIABLE*)realloc(bat, batSize * sizeof(NewVARIABLE));
00630   NewVarRef = bat;
00631   theBATSize = batSize;
00632   return bat;
00633 }

Here is the caller graph for this function:

void * SimulatedBlock::allocRecord	(	const char *	type,
		size_t	s,
		size_t	n,
		bool	clear = `true`
	)			`[protected]`

allocRecord Allocates memory for the datastructures where ndb keeps the data

Definition at line 660 of file SimulatedBlock.cpp.

References ERROR_SET, yaSSL::fatal, getBlockName(), memset, NDBD_EXIT_MEMALLOC, ndbd_malloc(), ndbout_c(), NULL, number(), p, refresh_watch_dog(), ArrayPool< SectionSegment >::size, and BaseString::snprintf().

Referenced by Dbtux::execREAD_CONFIG_REQ(), Dbtc::initData(), Dbdih::initData(), Dbtup::initRecords(), Dbtc::initRecords(), Dblqh::initRecords(), Dbdih::initRecords(), and Dbacc::initRecords().

00661 {
00662 
00663   void * p = NULL;
00664   size_t size = n*s;
00665   refresh_watch_dog(); 
00666   if (size > 0){
00667 #ifdef VM_TRACE_MEM
00668     ndbout_c("%s::allocRecord(%s, %u, %u) = %u bytes", 
00669              getBlockName(number()), 
00670              type,
00671              s,
00672              n,
00673              size);
00674 #endif
00675     p = ndbd_malloc(size);
00676     if (p == NULL){
00677       char buf1[255];
00678       char buf2[255];
00679       BaseString::snprintf(buf1, sizeof(buf1), "%s could not allocate memory for %s", 
00680                getBlockName(number()), type);
00681       BaseString::snprintf(buf2, sizeof(buf2), "Requested: %ux%u = %u bytes", 
00682                (Uint32)s, (Uint32)n, (Uint32)size);
00683       ERROR_SET(fatal, NDBD_EXIT_MEMALLOC, buf1, buf2);
00684     }
00685 
00686     if(clear){
00687       char * ptr = (char*)p;
00688       const Uint32 chunk = 128 * 1024;
00689       while(size > chunk){
00690         refresh_watch_dog(); 
00691         memset(ptr, 0, chunk);
00692         ptr += chunk;
00693         size -= chunk;
00694       }
00695       refresh_watch_dog(); 
00696       memset(ptr, 0, size);
00697     }
00698   }
00699   return p;
00700 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool SimulatedBlock::assembleFragments ( Signal * signal ) [protected]

Assemble fragments

Returns:: true if all fragments has arrived false otherwise

First in train

Don't release allocated segments

FragInfo == 2 or 3

fragInfo = 2

fragInfo = 3

Unable to find fragment

Definition at line 997 of file SimulatedBlock.cpp.

References c_fragmentInfoHash, getSections(), Signal::getSendersBlockRef(), Signal::header, SegmentedSectionPtr::i, key, Signal::length(), linkSegments(), SignalHeader::m_fragmentInfo, SignalHeader::m_noOfSections, Signal::m_sectionPtr, SimulatedBlock::FragmentInfo::m_sectionPtrI, ndbassert, ndbrequire, Ptr< T >::p, RNIL, Signal::setLength(), and Signal::theData.

00997                                                 {
00998   Uint32 sigLen = signal->length() - 1;
00999   Uint32 fragId = signal->theData[sigLen];
01000   Uint32 fragInfo = signal->header.m_fragmentInfo;
01001   Uint32 senderRef = signal->getSendersBlockRef();
01002   
01003   if(fragInfo == 0){
01004     return true;
01005   }
01006   
01007   const Uint32 secs = signal->header.m_noOfSections;
01008   const Uint32 * const secNos = &signal->theData[sigLen - secs];
01009   
01010   if(fragInfo == 1){
01014     Ptr<FragmentInfo> fragPtr;
01015     if(!c_fragmentInfoHash.seize(fragPtr)){
01016       ndbrequire(false);
01017       return false;
01018     }
01019     
01020     new (fragPtr.p)FragmentInfo(fragId, senderRef);
01021     c_fragmentInfoHash.add(fragPtr);
01022     
01023     for(Uint32 i = 0; i<secs; i++){
01024       Uint32 sectionNo = secNos[i];
01025       ndbassert(sectionNo < 3);
01026       fragPtr.p->m_sectionPtrI[sectionNo] = signal->m_sectionPtr[i].i;
01027     }
01028     
01032     signal->header.m_noOfSections = 0;
01033     return false;
01034   }
01035   
01036   FragmentInfo key(fragId, senderRef);
01037   Ptr<FragmentInfo> fragPtr;
01038   if(c_fragmentInfoHash.find(fragPtr, key)){
01039     
01043     Uint32 i;
01044     for(i = 0; i<secs; i++){
01045       Uint32 sectionNo = secNos[i];
01046       ndbassert(sectionNo < 3);
01047       Uint32 sectionPtrI = signal->m_sectionPtr[i].i;
01048       if(fragPtr.p->m_sectionPtrI[sectionNo] != RNIL){
01049         linkSegments(fragPtr.p->m_sectionPtrI[sectionNo], sectionPtrI);
01050       } else {
01051         fragPtr.p->m_sectionPtrI[sectionNo] = sectionPtrI;
01052       }
01053     }
01054     
01058     if(fragInfo == 2){
01059       signal->header.m_noOfSections = 0;
01060       return false;
01061     }
01062     
01066     for(i = 0; i<3; i++){
01067       Uint32 ptrI = fragPtr.p->m_sectionPtrI[i];
01068       if(ptrI != RNIL){
01069         signal->m_sectionPtr[i].i = ptrI;
01070       } else {
01071         break;
01072       }
01073     }
01074     signal->setLength(sigLen - i);
01075     signal->header.m_noOfSections = i;
01076     signal->header.m_fragmentInfo = 0;
01077     getSections(i, signal->m_sectionPtr);
01078     
01079     c_fragmentInfoHash.release(fragPtr);
01080     return true;
01081   }
01082   
01086   ndbrequire(false);
01087   return false;
01088 }

Here is the call graph for this function:

Here is the caller graph for this function:

BlockReference SimulatedBlock::calcAccBlockRef ( NodeId aNode ) [inline, static, protected]

Definition at line 636 of file SimulatedBlock.hpp.

References DBACC, and numberToRef().

Referenced by Dblqh::startphase1Lab().

00636                                                {
00637   return numberToRef(DBACC, aNodeId);
00638 }

Here is the call graph for this function:

Here is the caller graph for this function:

BlockReference SimulatedBlock::calcApiClusterMgrBlockRef ( NodeId aNode ) [inline, static, protected]

Definition at line 696 of file SimulatedBlock.hpp.

References API_CLUSTERMGR, and numberToRef().

Referenced by Qmgr::stateArbitChoose(), and Qmgr::stateArbitStart().

00696                                                         {
00697   return numberToRef(API_CLUSTERMGR, aNodeId);
00698 }

Here is the call graph for this function:

Here is the caller graph for this function:

BlockReference SimulatedBlock::calcBackupBlockRef ( NodeId aNode ) [inline, static, protected]

Definition at line 684 of file SimulatedBlock.hpp.

References BACKUP, and numberToRef().

Referenced by Backup::execABORT_BACKUP_ORD().

00684                                                  {
00685   return numberToRef(BACKUP, aNodeId);
00686 }

Here is the call graph for this function:

Here is the caller graph for this function:

BlockReference SimulatedBlock::calcDictBlockRef ( NodeId aNode ) [inline, static, protected]

Definition at line 660 of file SimulatedBlock.hpp.

References DBDICT, and numberToRef().

Referenced by Dbdih::dihCopyCompletedLab(), Dbdict::execALTER_TRIG_REQ(), Dbdict::execDICTSTARTREQ(), Dbdict::execDROP_TRIG_REQ(), Dbdih::execNDB_STTOR(), Dbtc::intstartphase1x010Lab(), Dbdict::restart_writeSchemaConf(), Dbdict::restartCreateObj(), Dbdict::restartCreateTab(), Dbdih::sendDictLockReq(), and Dbdih::sendDictUnlockOrd().

00660                                                {
00661   return numberToRef(DBDICT, aNodeId);
00662 }

Here is the call graph for this function:

Here is the caller graph for this function:

BlockReference SimulatedBlock::calcDihBlockRef ( NodeId aNode ) [inline, static, protected]

Definition at line 654 of file SimulatedBlock.hpp.

References DBDIH, and numberToRef().

Referenced by Dbdih::allNodesLcpCompletedLab(), Dblqh::checkDropTab(), Dbdih::checkStopMe(), Dbdih::copyTableNode(), Dbdih::execDIHNDBTAMPER(), Dbdih::execEND_TOCONF(), Dbdih::execGCP_PREPARE(), Dbdih::execNF_COMPLETEREP(), Dbdih::execREAD_NODESCONF(), Dbdih::execUNBLO_DICTCONF(), Dbtc::intstartphase1x010Lab(), Dbdih::nodeRestartTakeOver(), Dbdih::sendCOPY_GCIREQ(), Dbdih::sendCreateFragReq(), Dbdih::sendDIH_SWITCH_REPLICA_REQ(), Dblqh::sendEMPTY_LCP_CONF(), Dbdih::sendEND_TOREQ(), Dbdih::sendGCP_COMMIT(), Dbdih::sendGCP_PREPARE(), Dbdih::sendINCL_NODEREQ(), Dblqh::sendLCP_COMPLETE_REP(), Dblqh::sendLCP_FRAG_REP(), Dbdih::sendMASTER_GCPREQ(), Dbdih::sendMASTER_LCPREQ(), Dbdih::sendSTART_INFOREQ(), Dbdih::sendSTART_LCP_REQ(), Dbdih::sendSTART_TOREQ(), Dbdih::sendSTOP_ME_REQ(), Dbdih::sendUPDATE_TOREQ(), and Dbdih::startInfoReply().

00654                                                {
00655   return numberToRef(DBDIH, aNodeId);
00656 }

Here is the call graph for this function:

Here is the caller graph for this function:

BlockReference SimulatedBlock::calcLqhBlockRef ( NodeId aNode ) [inline, static, protected]

Definition at line 630 of file SimulatedBlock.hpp.

References DBLQH, and numberToRef().

Referenced by Dbdict::alterTrigger_toCreateLocal(), Dbdict::alterTrigger_toDropLocal(), Dbtc::attrinfoDihReceivedLab(), Dbtc::checkWaitDropTabFailedLqh(), Dbdih::checkWaitDropTabFailedLqh(), Dblqh::execABORT(), Dbdih::execCREATE_FRAGCONF(), Dbdih::execNDB_STTOR(), Dbtc::execPREP_DROP_TAB_REQ(), Dblqh::execSTART_EXEC_SR(), Dbdih::execUPDATE_TOCONF(), Dbtc::inithost(), Dbtc::intstartphase1x010Lab(), Dblqh::packLqhkeyreqLab(), Dbtc::releaseAndAbort(), Dbtc::sendAbortedAfterTimeout(), Dbdih::sendEMPTY_LCP_REQ(), Dbdih::sendGCP_SAVEREQ(), Dbdih::sendLastLCP_FRAG_ORD(), Dbdih::sendLCP_FRAG_ORD(), Dbdih::sendSTART_RECREQ(), Dbdih::sendStartFragreq(), Dblqh::sendTupkey(), Dblqh::srPhase3Comp(), Dblqh::startphase1Lab(), Dbtc::startTakeOverLab(), Dbtc::toAbortHandlingLab(), Dbtc::toCommitHandlingLab(), and Dbtc::toCompleteHandlingLab().

00630                                                {
00631 return numberToRef(DBLQH, aNodeId);
00632 }

Here is the call graph for this function:

Here is the caller graph for this function:

BlockReference SimulatedBlock::calcNdbCntrBlockRef ( NodeId aNode ) [inline, static, protected]

Definition at line 672 of file SimulatedBlock.hpp.

References NDBCNTR, and numberToRef().

Referenced by Dbdih::execCOPY_FRAGREF(), Ndbcntr::execDUMP_STATE_ORD(), Dbdih::execSTART_FRAGREF(), Suma::execSUB_CREATE_REF(), Suma::execSUB_START_REF(), Dbdih::handleTakeOverNewMaster(), Dbtc::intstartphase1x010Lab(), Ndbcntr::ph5ALab(), UpgradeStartup::sendCntrMasterReq(), Ndbcntr::sendCntrStartRef(), Ndbcntr::sendCntrStartReq(), Ndbcntr::startWaitingNodes(), Ndbcntr::waitpoint41Lab(), Ndbcntr::waitpoint61Lab(), and Ndbcntr::waitpoint71Lab().

00672                                                   {
00673   return numberToRef(NDBCNTR, aNodeId);
00674 }

Here is the call graph for this function:

Here is the caller graph for this function:

BlockReference SimulatedBlock::calcQmgrBlockRef ( NodeId aNode ) [inline, static, protected]

Definition at line 666 of file SimulatedBlock.hpp.

References numberToRef(), and QMGR.

Referenced by Qmgr::check_readnodes_reply(), Qmgr::execCM_ACKADD(), Qmgr::execCONNECT_REP(), UpgradeStartup::sendCmAppChg(), Qmgr::sendCmNodeInfoReq(), and Qmgr::sendCmRegReq().

00666                                                {
00667   return numberToRef(QMGR, aNodeId);
00668 }

Here is the call graph for this function:

Here is the caller graph for this function:

BlockReference SimulatedBlock::calcSumaBlockRef ( NodeId aNode ) [inline, static, protected]

Definition at line 690 of file SimulatedBlock.hpp.

References numberToRef(), and SUMA.

Referenced by Suma::execSUMA_HANDOVER_REQ(), and Suma::send_start_me_req().

00690                                                {
00691   return numberToRef(SUMA, aNodeId);
00692 }

Here is the call graph for this function:

Here is the caller graph for this function:

BlockReference SimulatedBlock::calcTcBlockRef ( NodeId aNode ) [inline, static, protected]

Definition at line 624 of file SimulatedBlock.hpp.

References DBTC, and numberToRef().

Referenced by Dbdict::alterIndex_toCreateTc(), Dbdict::alterIndex_toDropTc(), Dbdict::alterTrigger_toCreateLocal(), Dbdict::alterTrigger_toDropLocal(), Dbdict::buildIndex_toOnline(), Dblqh::checkDropTab(), Dbdih::execNDB_STTOR(), Dbtc::initApiConnectFail(), Dbtc::intstartphase1x010Lab(), Dbdih::sendTC_CLOPSIZEREQ(), Dbdih::sendTCGETOPSIZEREQ(), and Dblqh::startphase1Lab().

00624                                                {
00625   return numberToRef(DBTC, aNodeId);
00626 }

Here is the call graph for this function:

Here is the caller graph for this function:

BlockReference SimulatedBlock::calcTrixBlockRef ( NodeId aNode ) [inline, static, protected]

Definition at line 678 of file SimulatedBlock.hpp.

References numberToRef(), and TRIX.

Referenced by Dbdict::buildIndex_buildTrix(), Trix::execINCL_NODEREQ(), Trix::execNDB_STTOR(), and Trix::execREAD_NODESCONF().

00678                                                {
00679   return numberToRef(TRIX, aNodeId);
00680 }

Here is the call graph for this function:

Here is the caller graph for this function:

BlockReference SimulatedBlock::calcTupBlockRef ( NodeId aNode ) [inline, static, protected]

Definition at line 642 of file SimulatedBlock.hpp.

References DBTUP, and numberToRef().

Referenced by Dbdict::buildIndex_buildTrix(), Dbtup::execNDB_STTOR(), Dbtup::execSTTOR(), and Dblqh::startphase1Lab().

00642                                                {
00643   return numberToRef(DBTUP, aNodeId);
00644 }

Here is the call graph for this function:

Here is the caller graph for this function:

BlockReference SimulatedBlock::calcTuxBlockRef ( NodeId aNode ) [inline, static, protected]

Definition at line 648 of file SimulatedBlock.hpp.

References DBTUX, and numberToRef().

Referenced by Dbdict::buildIndex_toOnline(), and Dblqh::startphase1Lab().

00648                                                {
00649   return numberToRef(DBTUX, aNodeId);
00650 }

Here is the call graph for this function:

Here is the caller graph for this function:

Uint32 SimulatedBlock::create_distr_key	(	Uint32	tableId,
		Uint32 *	data,
		const Uint32	keyPaLen[MAX_ATTRIBUTES_IN_INDEX]
	)			const `[protected]`

Definition at line 1995 of file SimulatedBlock.cpp.

References KeyDescriptor::KeyAttr::attributeDescriptor, g_key_descriptor_pool, AttributeDescriptor::getArrayType(), AttributeDescriptor::getDKey(), AttributeDescriptor::getSizeInWords(), KeyDescriptor::keyAttr, memmove, NDB_ARRAYTYPE_FIXED, ndbrequire, KeyDescriptor::noOfDistrKeys, and KeyDescriptor::noOfKeyAttr.

Referenced by Dbtc::handle_special_hash().

01999 {
02000   const KeyDescriptor* desc = g_key_descriptor_pool.getPtr(tableId);
02001   const Uint32 noOfKeyAttr = desc->noOfKeyAttr;
02002   Uint32 noOfDistrKeys = desc->noOfDistrKeys;
02003   
02004   Uint32 *src = data;
02005   Uint32 *dst = data;
02006   Uint32 i = 0;
02007   Uint32 dstPos = 0;
02008   
02009   if(keyPartLen)
02010   {
02011     while (i < noOfKeyAttr && noOfDistrKeys) 
02012     {
02013       Uint32 attr = desc->keyAttr[i].attributeDescriptor;
02014       Uint32 len = keyPartLen[i];
02015       if(AttributeDescriptor::getDKey(attr))
02016       {
02017         noOfDistrKeys--;
02018         memmove(dst+dstPos, src, len << 2);
02019         dstPos += len;
02020       }
02021       src += len;
02022       i++;
02023     }
02024   }
02025   else
02026   {
02027     while (i < noOfKeyAttr && noOfDistrKeys) 
02028     {
02029       Uint32 attr = desc->keyAttr[i].attributeDescriptor;
02030       Uint32 len = AttributeDescriptor::getSizeInWords(attr);
02031       ndbrequire(AttributeDescriptor::getArrayType(attr) == NDB_ARRAYTYPE_FIXED);
02032       if(AttributeDescriptor::getDKey(attr))
02033       {
02034         noOfDistrKeys--;
02035         memmove(dst+dstPos, src, len << 2);
02036         dstPos += len;
02037       }
02038       src += len;
02039       i++;
02040     }
02041   }
02042   return dstPos;
02043 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::deallocRecord	(	void **	,
		const char *	type,
		size_t	s,
		size_t	n
	)			`[protected]`

Deallocate record

NOTE: Also resets pointer

Definition at line 703 of file SimulatedBlock.cpp.

References ndbd_free().

Referenced by Dbacc::~Dbacc(), Dbdih::~Dbdih(), Dblqh::~Dblqh(), Dbtc::~Dbtc(), and Dbtup::~Dbtup().

00704                                                                     {
00705   (void)type;
00706 
00707   if(* ptr != 0){
00708       ndbd_free(* ptr, n*s);
00709     * ptr = 0;
00710   }
00711 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::exec_node_start_rep ( Signal * signal ) [private, virtual]

Reimplemented in Dbdih.

Definition at line 931 of file SimulatedBlock.cpp.

Referenced by execNODE_START_REP().

00932 {
00933 }

Here is the caller graph for this function:

void SimulatedBlock::execAPI_START_REP ( Signal * signal ) [private]

Reimplemented in Ndbcntr, and Suma.

Definition at line 936 of file SimulatedBlock.cpp.

Referenced by installSimulatedBlockFunctions().

00937 {
00938 }

Here is the caller graph for this function:

void SimulatedBlock::execCHANGE_NODE_STATE_REQ ( Signal * signal ) [private]

Definition at line 832 of file SimulatedBlock.cpp.

References GSN_CHANGE_NODE_STATE_CONF, JBB, ChangeNodeStateReq::nodeState, ChangeNodeStateReq::senderData, ChangeNodeStateReq::senderRef, sendSignal(), and Signal::theData.

Referenced by installSimulatedBlockFunctions().

00832                                                        {
00833   const ChangeNodeStateReq * const  req = 
00834     (ChangeNodeStateReq *)&signal->theData[0];
00835   
00836   this->theNodeState = req->nodeState;
00837   const Uint32 senderData = req->senderData;
00838   const BlockReference senderRef = req->senderRef;
00839 
00843   ChangeNodeStateConf * const  conf = 
00844     (ChangeNodeStateConf *)&signal->theData[0];
00845   
00846   conf->senderData = senderData;
00847 
00848   sendSignal(senderRef, GSN_CHANGE_NODE_STATE_CONF, signal, 
00849              ChangeNodeStateConf::SignalLength, JBB);
00850 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execCONTINUE_FRAGMENTED ( Signal * signal ) [private]

Definition at line 870 of file SimulatedBlock.cpp.

References c_fragSenderRunning, c_linearFragmentSendList, c_segmentedFragmentSendList, execute(), Signal::getDataPtrSend(), GSN_CONTINUE_FRAGMENTED, Ptr< T >::isNull(), JBB, ljam, ljamEntry, SimulatedBlock::FragmentSendInfo::m_callback, SimulatedBlock::Callback::m_callbackFunction, SimulatedBlock::FragmentSendInfo::m_status, Ptr< T >::p, reference(), SimulatedBlock::FragmentSendInfo::SendComplete, sendNextLinearFragment(), sendNextSegmentedFragment(), sendSignal(), and sig().

Referenced by installSimulatedBlockFunctions().

00870                                                       {
00871   ljamEntry();
00872   
00873   Ptr<FragmentSendInfo> fragPtr;
00874   
00875   c_segmentedFragmentSendList.first(fragPtr);  
00876   for(; !fragPtr.isNull();){
00877     ljam();
00878     Ptr<FragmentSendInfo> copyPtr = fragPtr;
00879     c_segmentedFragmentSendList.next(fragPtr);
00880     
00881     sendNextSegmentedFragment(signal, * copyPtr.p);
00882     if(copyPtr.p->m_status == FragmentSendInfo::SendComplete){
00883       ljam();
00884       if(copyPtr.p->m_callback.m_callbackFunction != 0) {
00885         ljam();
00886         execute(signal, copyPtr.p->m_callback, 0);
00887       }//if
00888       c_segmentedFragmentSendList.release(copyPtr);
00889     }
00890   }
00891   
00892   c_linearFragmentSendList.first(fragPtr);  
00893   for(; !fragPtr.isNull();){
00894     ljam(); 
00895     Ptr<FragmentSendInfo> copyPtr = fragPtr;
00896     c_linearFragmentSendList.next(fragPtr);
00897     
00898     sendNextLinearFragment(signal, * copyPtr.p);
00899     if(copyPtr.p->m_status == FragmentSendInfo::SendComplete){
00900       ljam();
00901       if(copyPtr.p->m_callback.m_callbackFunction != 0) {
00902         ljam();
00903         execute(signal, copyPtr.p->m_callback, 0);
00904       }//if
00905       c_linearFragmentSendList.release(copyPtr);
00906     }
00907   }
00908   
00909   if(c_segmentedFragmentSendList.isEmpty() && 
00910      c_linearFragmentSendList.isEmpty()){
00911     ljam();
00912     c_fragSenderRunning = false;
00913     return;
00914   }
00915   
00916   ContinueFragmented * sig = (ContinueFragmented*)signal->getDataPtrSend();
00917   sig->line = __LINE__;
00918   sendSignal(reference(), GSN_CONTINUE_FRAGMENTED, signal, 1, JBB);
00919 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execFSAPPENDREF ( Signal * signal ) [protected]

Reimplemented in Backup.

Definition at line 1852 of file SimulatedBlock.cpp.

References fsRefError().

Referenced by installSimulatedBlockFunctions().

01853 {
01854   fsRefError(signal, __LINE__, "File system append failed");
01855 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execFSCLOSEREF ( Signal * signal ) [protected]

Reimplemented in Backup, Dbdih, Lgman, Restore, and Tsman.

Definition at line 1828 of file SimulatedBlock.cpp.

References fsRefError().

Referenced by Restore::execFSCLOSEREF(), and installSimulatedBlockFunctions().

01829 {
01830   fsRefError(signal, __LINE__, "File system close failed");
01831 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execFSOPENREF ( Signal * signal ) [protected]

Reimplemented in Backup, Dbdict, Dbdih, Lgman, Restore, and Tsman.

Definition at line 1834 of file SimulatedBlock.cpp.

References fsRefError().

Referenced by installSimulatedBlockFunctions().

01835 {
01836   fsRefError(signal, __LINE__, "File system open failed");
01837 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execFSREADREF ( Signal * signal ) [protected]

Reimplemented in Dbdict, Dbdih, Dblqh, Lgman, Pgman, Restore, and Tsman.

Definition at line 1822 of file SimulatedBlock.cpp.

References fsRefError().

Referenced by Restore::execFSREADREF(), Pgman::execFSREADREF(), Lgman::execFSREADREF(), and installSimulatedBlockFunctions().

01823 {
01824   fsRefError(signal, __LINE__, "File system read failed");
01825 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execFSREMOVEREF ( Signal * signal ) [protected]

Reimplemented in Backup.

Definition at line 1840 of file SimulatedBlock.cpp.

References fsRefError().

Referenced by installSimulatedBlockFunctions().

01841 {
01842   fsRefError(signal, __LINE__, "File system remove failed");
01843 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execFSSYNCREF ( Signal * signal ) [protected]

Definition at line 1846 of file SimulatedBlock.cpp.

References fsRefError().

Referenced by installSimulatedBlockFunctions().

01847 {
01848   fsRefError(signal, __LINE__, "File system sync failed");
01849 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execFSWRITEREF ( Signal * signal ) [protected]

Reimplemented in Dbdih, Dblqh, Lgman, and Pgman.

Definition at line 1816 of file SimulatedBlock.cpp.

References fsRefError().

Referenced by Pgman::execFSWRITEREF(), Lgman::execFSWRITEREF(), and installSimulatedBlockFunctions().

01817 {
01818   fsRefError(signal, __LINE__, "File system write failed");
01819 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execNDB_TAMPER ( Signal * signal ) [private]

Reimplemented in Cmvmi, and Dbdih.

Definition at line 853 of file SimulatedBlock.cpp.

References SET_ERROR_INSERT_VALUE, and Signal::theData.

Referenced by installSimulatedBlockFunctions().

00853                                              {
00854   SET_ERROR_INSERT_VALUE(signal->theData[0]);
00855 }

Here is the caller graph for this function:

void SimulatedBlock::execNODE_START_REP ( Signal * signal ) [private]

Definition at line 922 of file SimulatedBlock.cpp.

References exec_node_start_rep().

Referenced by installSimulatedBlockFunctions().

00923 {
00924   // common stuff for all blocks
00925 
00926   // block specific stuff by virtual method override (default empty)
00927   exec_node_start_rep(signal);
00928 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execNODE_STATE_REP ( Signal * signal ) [private]

Definition at line 825 of file SimulatedBlock.cpp.

References NodeStateRep::nodeState, and Signal::theData.

Referenced by installSimulatedBlockFunctions().

00825                                                 {
00826   const NodeStateRep * const  rep = (NodeStateRep *)&signal->theData[0];
00827   
00828   this->theNodeState = rep->nodeState;
00829 }

Here is the caller graph for this function:

void SimulatedBlock::execSIGNAL_DROPPED_REP ( Signal * signal ) [private]

Reimplemented in Suma.

Definition at line 858 of file SimulatedBlock.cpp.

References getBlockName(), ErrorReporter::handleError(), NDBD_EXIT_OUT_OF_LONG_SIGNAL_MEMORY, NST_ErrorHandler, number(), SignalDroppedRep::originalGsn, SignalDroppedRep::originalLength, SignalDroppedRep::originalSectionCount, and Signal::theData.

Referenced by installSimulatedBlockFunctions().

00858                                                      {
00859   char msg[64];
00860   const SignalDroppedRep * const rep = (SignalDroppedRep *)&signal->theData[0];
00861   snprintf(msg, sizeof(msg), "%s GSN: %u (%u,%u)", getBlockName(number()),
00862            rep->originalGsn, rep->originalLength,rep->originalSectionCount);
00863   ErrorReporter::handleError(NDBD_EXIT_OUT_OF_LONG_SIGNAL_MEMORY,
00864                              msg,
00865                              __FILE__,
00866                              NST_ErrorHandler);
00867 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execUPGRADE ( Signal * signal ) [protected]

Definition at line 1787 of file SimulatedBlock.cpp.

References UpgradeStartup::execCM_APPCHG(), UpgradeStartup::execCNTR_MASTER_REPLY(), Signal::header, and SignalHeader::theVerId_signalNumber.

Referenced by UpgradeStartup::installEXEC().

01787                                          {
01788   Uint32 gsn = signal->header.theVerId_signalNumber;
01789   switch(gsn){
01790   case UpgradeStartup::GSN_CM_APPCHG:
01791     UpgradeStartup::execCM_APPCHG(* this, signal);
01792     break;
01793   case UpgradeStartup::GSN_CNTR_MASTERREF:
01794     UpgradeStartup::execCNTR_MASTER_REPLY(* this, signal);
01795     break;
01796   case UpgradeStartup::GSN_CNTR_MASTERCONF:
01797     UpgradeStartup::execCNTR_MASTER_REPLY(* this, signal);
01798     break;
01799   }
01800 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execute	(	Signal *	signal,
		Callback &	c,
		Uint32	returnCode
	)			`[inline, protected]`

Definition at line 597 of file SimulatedBlock.hpp.

References SimulatedBlock::Callback::m_callbackData, SimulatedBlock::Callback::m_callbackFunction, ndbrequire, and NULL.

Referenced by Dbdict::checkSchemaStatus(), Dbdict::closeReadTableConf(), Dbdict::closeWriteSchemaConf(), Dbdict::closeWriteTableConf(), Dbdict::create_fg_abort_complete(), Dbdict::create_fg_abort_start(), Dbdict::create_fg_prepare_start(), Dbdict::create_file_abort_complete(), Dbdict::create_file_abort_start(), Dbdict::create_file_prepare_start(), Dbdict::createObj_abort(), Dbdict::createObj_abort_writeSchemaConf(), Dbdict::createObj_commit(), Dbdict::createObj_writeSchemaConf2(), Dbtup::disk_page_prealloc(), Dbtup::disk_restart_undo(), Dbdict::drop_fg_commit_complete(), Dbdict::drop_fg_prepare_start(), Dbdict::drop_file_commit_complete(), Dbdict::drop_undofile_prepare_start(), Dbdict::dropObj_abort(), Dbdict::dropObj_abort_start_done(), Dbdict::dropObj_abort_writeSchemaConf(), Dbdict::dropObj_commit(), Dbdict::dropObj_commit_writeSchemaConf(), Dbdict::dropObj_prepare_writeSchemaConf(), Dbdict::dropTab_nextStep(), execCONTINUE_FRAGMENTED(), Dbdict::execCREATE_FILE_CONF(), Dbdict::execCREATE_FILE_REF(), Dbdict::execCREATE_FILEGROUP_CONF(), Dbdict::execCREATE_FILEGROUP_REF(), Dbdict::execDIADDTABCONF(), Dbdict::execDIADDTABREF(), Dbdict::execDROP_FILE_CONF(), Dbdict::execDROP_FILE_REF(), Dbdict::execDROP_FILEGROUP_CONF(), Dbdict::execDROP_FILEGROUP_REF(), Dbdict::execTAB_COMMITCONF(), Dbdict::execTC_SCHVERCONF(), Dbtup::execTUP_ADD_ATTRREQ(), SimulatedBlock::MutexManager::execUTIL_CREATE_LOCK_CONF(), SimulatedBlock::MutexManager::execUTIL_CREATE_LOCK_REF(), SimulatedBlock::MutexManager::execUTIL_DESTORY_LOCK_CONF(), SimulatedBlock::MutexManager::execUTIL_DESTORY_LOCK_REF(), SimulatedBlock::MutexManager::execUTIL_LOCK_CONF(), SimulatedBlock::MutexManager::execUTIL_LOCK_REF(), SimulatedBlock::MutexManager::execUTIL_UNLOCK_CONF(), SimulatedBlock::MutexManager::execUTIL_UNLOCK_REF(), Pgman::process_callback(), Lgman::process_log_buffer_waiters(), Lgman::process_log_sync_waiters(), Dbdih::recvDictLockConf(), Dbdict::recvSignalUtilReq(), Tsman::release_extent_pages(), Dbdict::restartCreateObj_commit_start_done(), Dbdict::restartCreateObj_prepare_complete_done(), Dbdict::restartCreateObj_readConf(), Dbdict::restartCreateObj_write_complete(), Dbdict::schemaOp_reply(), and sendFragmentedSignal().

00597                                                                       {
00598   CallbackFunction fun = c.m_callbackFunction; 
00599   ndbrequire(fun != 0);
00600   c.m_callbackFunction = NULL;
00601   (this->*fun)(signal, c.m_callbackData, returnCode);
00602 }

Here is the caller graph for this function:

void SimulatedBlock::EXECUTE_DIRECT	(	Uint32	block,
		Uint32	gsn,
		Signal *	signal,
		Uint32	len
	)			`[inline, protected]`

Definition at line 715 of file SimulatedBlock.hpp.

References executeFunction(), GlobalData::getBlock(), globalData, Signal::header, NdbTick_CurrentMicrosecond(), GlobalData::ownId, reference(), Signal::setLength(), GlobalData::testOn, Signal::theData, SignalHeader::theReceiversBlockNumber, SignalHeader::theSendersBlockRef, and SignalHeader::theVerId_signalNumber.

Referenced by Dblqh::abortContinueAfterBlockedLab(), Dblqh::acckeyconf_tupkeyreq(), Dblqh::accScanConfScanLab(), Dbtup::addTuxEntries(), Dbdict::alterTab_writeTableConf(), Dbtup::buildIndex(), Qmgr::check_multi_node_shutdown(), Qmgr::check_startup(), Ndbcntr::StopRecord::checkNodeFail(), Ndbcntr::checkNodeGroups(), Backup::cleanup(), Dblqh::commitContinueAfterBlockedLab(), Dblqh::commitReqLab(), Dblqh::continueAfterCheckLcpStopBlocked(), Dbdih::crashSystemAtGcpStop(), Dbtc::deleteFromIndexTable(), Dbtc::diFcountReqLab(), Dbtc::diverify010Lab(), Dbdict::dropTab_writeSchemaConf(), Dblqh::execACC_ABORTCONF(), Dbtux::execACC_CHECK_SCAN(), Dbtup::execACC_CHECK_SCAN(), Dbacc::execACC_CHECK_SCAN(), Dbacc::execACC_LOCKREQ(), Dbtux::execACCKEYCONF(), Dbtup::execACCKEYCONF(), Dbtux::execACCKEYREF(), Dbtup::execACCKEYREF(), Qmgr::execAPI_REGREQ(), Qmgr::execCOMMIT_FAILREQ(), Backup::execCONTINUEB(), Dbdict::execCREATE_TABLE_REQ(), Dbdih::execDUMP_STATE_ORD(), Cmvmi::execDUMP_STATE_ORD(), Backup::execGET_TABINFO_CONF(), Dblqh::execLCP_PREPARE_CONF(), Dblqh::execLCP_PREPARE_REF(), Dblqh::execLQH_ALLOCREQ(), Dbtc::execLQHKEYREF(), Dbtux::execNEXT_SCANREQ(), Dbtup::execNEXT_SCANREQ(), Dbacc::execNEXT_SCANREQ(), Dblqh::execREAD_PSEUDO_REQ(), Dblqh::execTUP_DEALLOCREQ(), Dbtup::execTUP_WRITELOG_REQ(), Dbtc::executeIndexOperation(), Dbtup::executeTrigger(), Ndbcntr::execWAIT_GCP_CONF(), Ndbcntr::getNodeGroup(), Suma::getNodeGroupMembers(), Dblqh::handle_nr_copy(), Qmgr::handleArbitCheck(), Dbtc::insertIntoIndexTable(), Dblqh::nr_copy_delete_row(), AsyncFile::openReq(), Dbdict::packTableIntoPages(), Restore::parse_record(), Dblqh::prepareContinueAfterBlockedLab(), Dbtup::read_pseudo(), Dbtc::readIndexTable(), Dblqh::releaseOprec(), Dbtup::removeTuxEntries(), Dbacc::report_dealloc(), Dbtux::scanClose(), Dbtup::scanClose(), Dbtup::scanNext(), Dbtup::scanReply(), Qmgr::sendCmAckAdd(), Dbtup::sendFireTrigOrd(), Dblqh::sendKeyinfo20(), Dbtup::sendLogAttrinfo(), Dblqh::sendLqhkeyconfTc(), Dbacc::sendNextScanConf(), Dbtup::sendReadAttrinfo(), Dbacc::sendScanHbRep(), Dbtc::sendtckeyconf(), Dbtup::sendTrigAttrInfo(), Dbtup::sendTUPKEYCONF(), Dbtc::tckeyreq050Lab(), Dblqh::tupcommit_conf_callback(), and Dbdih::writingCopyGciLab().

00718                                           {
00719   signal->setLength(len);
00720 #ifdef VM_TRACE
00721   if(globalData.testOn){
00722     signal->header.theVerId_signalNumber = gsn;
00723     signal->header.theReceiversBlockNumber = block;
00724     signal->header.theSendersBlockRef = reference();
00725     globalSignalLoggers.executeDirect(signal->header,
00726                                       0,        // in
00727                                       &signal->theData[0],
00728                                       globalData.ownId);
00729   }
00730 #endif
00731   SimulatedBlock* b = globalData.getBlock(block);
00732 #ifdef VM_TRACE_TIME
00733   Uint32 us1, us2;
00734   Uint64 ms1, ms2;
00735   NdbTick_CurrentMicrosecond(&ms1, &us1);
00736   Uint32 tGsn = m_currentGsn;
00737   b->m_currentGsn = gsn;
00738 #endif
00739   b->executeFunction(gsn, signal);
00740 #ifdef VM_TRACE_TIME
00741   NdbTick_CurrentMicrosecond(&ms2, &us2);
00742   Uint64 diff = ms2;
00743   diff -= ms1;
00744   diff *= 1000000;
00745   diff += us2;
00746   diff -= us1;
00747   b->addTime(gsn, diff);
00748   m_currentGsn = tGsn;
00749   subTime(tGsn, diff);
00750 #endif
00751 #ifdef VM_TRACE
00752   if(globalData.testOn){
00753     signal->header.theVerId_signalNumber = gsn;
00754     signal->header.theReceiversBlockNumber = block;
00755     signal->header.theSendersBlockRef = reference();
00756     globalSignalLoggers.executeDirect(signal->header,
00757                                       1,        // out
00758                                       &signal->theData[0],
00759                                       globalData.ownId);
00760   }
00761 #endif
00762 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::executeFunction	(	GlobalSignalNumber	gsn,
		Signal *	signal
	)			`[inline]`

Definition at line 570 of file SimulatedBlock.hpp.

References ERROR_SET, f, yaSSL::fatal, MAX_GSN, NDBD_EXIT_PRGERR, ndbrequire, BaseString::snprintf(), and theExecArray.

Referenced by FastScheduler::doJob(), EXECUTE_DIRECT(), and FastScheduler::sendPacked().

00570                                                                      {
00571   ExecFunction f = theExecArray[gsn];
00572   if(gsn <= MAX_GSN && f != 0){
00573 #ifdef VM_TRACE
00574     clear_global_variables();
00575 #endif
00576     (this->*f)(signal);
00577     return;
00578   }
00579 
00583   char errorMsg[255];
00584   if (!(gsn <= MAX_GSN)) {
00585     BaseString::snprintf(errorMsg, 255, "Illegal signal received (GSN %d too high)", gsn);
00586     ERROR_SET(fatal, NDBD_EXIT_PRGERR, errorMsg, errorMsg);
00587   }
00588   if (!(theExecArray[gsn] != 0)) {
00589     BaseString::snprintf(errorMsg, 255, "Illegal signal received (GSN %d not added)", gsn);
00590     ERROR_SET(fatal, NDBD_EXIT_PRGERR, errorMsg, errorMsg);
00591   }
00592   ndbrequire(false);
00593 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execUTIL_CREATE_LOCK_CONF ( Signal * signal ) [private]

Definition at line 1731 of file SimulatedBlock.cpp.

References c_mutexMgr, SimulatedBlock::MutexManager::execUTIL_CREATE_LOCK_CONF(), and ljamEntry.

Referenced by installSimulatedBlockFunctions().

01731                                                             {
01732   ljamEntry();
01733   c_mutexMgr.execUTIL_CREATE_LOCK_CONF(signal);
01734 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execUTIL_CREATE_LOCK_REF ( Signal * signal ) [private]

Definition at line 1726 of file SimulatedBlock.cpp.

References c_mutexMgr, SimulatedBlock::MutexManager::execUTIL_CREATE_LOCK_REF(), and ljamEntry.

Referenced by installSimulatedBlockFunctions().

01726                                                       {
01727   ljamEntry();
01728   c_mutexMgr.execUTIL_CREATE_LOCK_REF(signal);
01729 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execUTIL_DESTORY_LOCK_CONF ( Signal * signal ) [private]

Definition at line 1741 of file SimulatedBlock.cpp.

References c_mutexMgr, SimulatedBlock::MutexManager::execUTIL_DESTORY_LOCK_CONF(), and ljamEntry.

Referenced by installSimulatedBlockFunctions().

01741                                                              {
01742   ljamEntry();
01743   c_mutexMgr.execUTIL_DESTORY_LOCK_CONF(signal);
01744 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execUTIL_DESTORY_LOCK_REF ( Signal * signal ) [private]

Definition at line 1736 of file SimulatedBlock.cpp.

References c_mutexMgr, SimulatedBlock::MutexManager::execUTIL_DESTORY_LOCK_REF(), and ljamEntry.

Referenced by installSimulatedBlockFunctions().

01736                                                             {
01737   ljamEntry();
01738   c_mutexMgr.execUTIL_DESTORY_LOCK_REF(signal);
01739 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execUTIL_LOCK_CONF ( Signal * signal ) [private]

Definition at line 1751 of file SimulatedBlock.cpp.

References c_mutexMgr, SimulatedBlock::MutexManager::execUTIL_LOCK_CONF(), and ljamEntry.

Referenced by installSimulatedBlockFunctions().

01751                                                      {
01752   ljamEntry();
01753   c_mutexMgr.execUTIL_LOCK_CONF(signal);
01754 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execUTIL_LOCK_REF ( Signal * signal ) [private]

Definition at line 1746 of file SimulatedBlock.cpp.

References c_mutexMgr, SimulatedBlock::MutexManager::execUTIL_LOCK_REF(), and ljamEntry.

Referenced by installSimulatedBlockFunctions().

01746                                                     {
01747   ljamEntry();
01748   c_mutexMgr.execUTIL_LOCK_REF(signal);
01749 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execUTIL_UNLOCK_CONF ( Signal * signal ) [private]

Definition at line 1761 of file SimulatedBlock.cpp.

References c_mutexMgr, SimulatedBlock::MutexManager::execUTIL_UNLOCK_CONF(), and ljamEntry.

Referenced by installSimulatedBlockFunctions().

01761                                                        {
01762   ljamEntry();
01763   c_mutexMgr.execUTIL_UNLOCK_CONF(signal);
01764 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::execUTIL_UNLOCK_REF ( Signal * signal ) [private]

Definition at line 1756 of file SimulatedBlock.cpp.

References c_mutexMgr, SimulatedBlock::MutexManager::execUTIL_UNLOCK_REF(), and ljamEntry.

Referenced by installSimulatedBlockFunctions().

01756                                                       {
01757   ljamEntry();
01758   c_mutexMgr.execUTIL_UNLOCK_REF(signal);
01759 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::freeBat ( ) [protected]

Definition at line 636 of file SimulatedBlock.cpp.

References free, and NewVarRef.

Referenced by ~SimulatedBlock().

00636                        {
00637   if(NewVarRef != 0){
00638     free(NewVarRef);
00639     NewVarRef = 0;
00640   }
00641 }

Here is the caller graph for this function:

void SimulatedBlock::fsRefError	(	Signal *	signal,
		Uint32	line,
		const char *	msg
	)			`[protected]`

Definition at line 1803 of file SimulatedBlock.cpp.

References FsRef::errorCode, getBlockName(), Signal::getDataPtr(), number(), FsRef::osErrorCode, and progError().

Referenced by execFSAPPENDREF(), execFSCLOSEREF(), Dbdih::execFSCLOSEREF(), execFSOPENREF(), Dbdih::execFSOPENREF(), Dbdict::execFSOPENREF(), execFSREADREF(), Dblqh::execFSREADREF(), Dbdih::execFSREADREF(), Dbdict::execFSREADREF(), execFSREMOVEREF(), execFSSYNCREF(), execFSWRITEREF(), Dblqh::execFSWRITEREF(), and Dbdih::execFSWRITEREF().

01804 {
01805   const FsRef *fsRef = (FsRef*)signal->getDataPtr();
01806   Uint32 errorCode = fsRef->errorCode;
01807   Uint32 osErrorCode = fsRef->osErrorCode;
01808   char msg2[100];
01809 
01810   sprintf(msg2, "%s: %s. OS errno: %u", getBlockName(number()), msg, osErrorCode);
01811 
01812   progError(line, errorCode, msg2);
01813 }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual const char* SimulatedBlock::get_filename ( Uint32 fd ) const [inline, virtual]

Reimplemented in Ndbfs.

Definition at line 132 of file SimulatedBlock.hpp.

Referenced by Lgman::find_log_head_in_file(), and Lgman::stop_run_undo_log().

00132 { return "";}

Here is the caller graph for this function:

static const NewVARIABLE* SimulatedBlock::getBat ( BlockNumber blockNo ) [static, protected]

Referenced by Ndbfs::execFSAPPENDREQ(), and Ndbfs::readWriteRequest().

Here is the caller graph for this function:

static Uint16 SimulatedBlock::getBatSize ( BlockNumber blockNo ) [static, protected]

Referenced by Ndbfs::execFSAPPENDREQ(), and Ndbfs::readWriteRequest().

Here is the caller graph for this function:

const NodeInfo & SimulatedBlock::getNodeInfo ( NodeId nodeId ) const [inline, protected]

Get node info

Definition at line 708 of file SimulatedBlock.hpp.

References globalData, GlobalData::m_nodeInfo, MAX_NODES, and ndbrequire.

Referenced by Qmgr::apiHbHandlingLab(), Dbdict::check_ndb_versions(), Qmgr::checkHeartbeat(), Qmgr::checkStartInterface(), Qmgr::cmAddPrepare(), Qmgr::cmInfoconf010Lab(), Qmgr::completeAllocNodeIdReq(), Qmgr::computeArbitNdbMask(), Qmgr::execALLOC_NODEID_REQ(), Qmgr::execAPI_BROADCAST_REP(), Qmgr::execAPI_FAILREQ(), Qmgr::execAPI_REGREQ(), Qmgr::execAPI_VERSION_REQ(), Qmgr::execCM_ACKADD(), Qmgr::execCM_REGREQ(), Qmgr::execCONNECT_REP(), Cmvmi::execCONNECT_REP(), Dbdict::execDICT_LOCK_REQ(), Qmgr::execDISCONNECT_REP(), Cmvmi::execDISCONNECT_REP(), Qmgr::execDUMP_STATE_ORD(), Cmvmi::execDUMP_STATE_ORD(), Cmvmi::execENABLE_COMORD(), Dbdih::execINCL_NODEREQ(), Dblqh::execLQHKEYREQ(), Cmvmi::execOPEN_COMREQ(), Cmvmi::execSTART_ORD(), Dbdih::gcpBlockedLab(), Qmgr::initData(), Qmgr::node_failed(), Dblqh::packLqhkeyreqLab(), UpgradeStartup::sendCmAppChg(), Qmgr::sendCmNodeInfoReq(), UpgradeStartup::sendCntrMasterReq(), Dbdih::sendDictLockReq(), Dbdih::sendDictUnlockOrd(), Dblqh::sendKeyinfo20(), Dbtc::sendlqhkeyreq(), Ndbcntr::Missra::sendNextSTTOR(), Dbtup::sendReadAttrinfo(), Dbtc::sendTcIndxConf(), Dbtc::sendtckeyconf(), Dbtc::timeOutFoundFragLab(), and Backup::verifyNodesAlive().

00708                                                {
00709   ndbrequire(nodeId > 0 && nodeId < MAX_NODES);
00710   return globalData.m_nodeInfo[nodeId];
00711 }

Here is the caller graph for this function:

const NodeState & SimulatedBlock::getNodeState ( ) const [inline, protected]

Get node state

Definition at line 702 of file SimulatedBlock.hpp.

References theNodeState.

Referenced by Qmgr::check_readnodes_reply(), Ndbcntr::StopRecord::checkNodeFail(), Ndbcntr::StopRecord::checkTimeout(), Dbdih::copyTableNode(), Dbtc::execABORT_ALL_REQ(), Qmgr::execAPI_REGREQ(), Ndbcntr::execCNTR_START_REQ(), Ndbcntr::execCONTINUEB(), Dbdih::execCOPY_TABCONF(), Dbdih::execDIADDTABREQ(), Qmgr::execDISCONNECT_REP(), Dblqh::execGCP_SAVEREQ(), Ndbcntr::execNODE_FAILREP(), Qmgr::execPREP_FAILCONF(), Suma::execREAD_NODESCONF(), Ndbcntr::execREAD_NODESREQ(), Dbdict::execSCHEMA_INFO(), Dblqh::execSTART_EXEC_SR(), Dbdih::execSTART_RECCONF(), Ndbcntr::execSTOP_REQ(), Suma::execSUB_GCP_COMPLETE_REP(), Dbtc::execTCSEIZEREQ(), Dbtup::execTUP_ADD_ATTRREQ(), Dblqh::findLogfile(), Dbdih::GCP_SAVEhandling(), Dblqh::getAllowRead(), Dbtc::getAllowStartTransaction(), Tsman::load_extent_page_callback(), Dbdih::readPagesIntoFragLab(), Dbdih::sendAddFragreq(), Dbdih::setLcpActiveStatusEnd(), and Dbtc::TCKEY_abort().

00702                                    {
00703   return theNodeState;
00704 }

Here is the caller graph for this function:

NodeId SimulatedBlock::getOwnNodeId ( ) const [inline, protected]

Definition at line 618 of file SimulatedBlock.hpp.

References theNodeId.

00618                                    {
00619   return theNodeId;
00620 }

Here is the caller graph for this function:

class SectionSegmentPool & SimulatedBlock::getSectionSegmentPool ( ) [protected]

Definition at line 622 of file SimulatedBlock.cpp.

References g_sectionSegmentPool.

Referenced by Dbdict::create_fg_prepare_start(), Dbdict::create_file_prepare_start(), Dbdict::createEvent_RT_USER_CREATE(), Dbdict::createEvent_RT_USER_GET(), Dbdict::createTab_prepare(), Dbdict::execALTER_TAB_CONF(), Dbdict::execALTER_TAB_REF(), Suma::execALTER_TAB_REQ(), Dbdict::execALTER_TAB_REQ(), Dbdict::execALTER_TABLE_REQ(), Trix::execBUILDINDXREQ(), Dbdict::execCREATE_FRAGMENTATION_CONF(), Dbtc::execCREATE_INDX_REQ(), Dbdict::execCREATE_INDX_REQ(), Dbdict::execCREATE_TABLE_REQ(), Dbdict::execCREATE_TRIG_REQ(), Dbdict::execDROP_EVNT_REQ(), Dbdict::execDROP_TRIG_REQ(), Dbdict::execGET_TABINFO_CONF(), Dbdict::execGET_TABINFOREQ(), Suma::execSUB_SYNC_REQ(), DbUtil::execUTIL_EXECUTE_REQ(), DbUtil::execUTIL_PREPARE_REQ(), Dbdict::parseReadEventSys(), Suma::Table::parseTable(), and DbUtil::prepareOperation().

00622                                      {
00623   return g_sectionSegmentPool;
00624 }

Here is the caller graph for this function:

void SimulatedBlock::ignoreMutexUnlockCallback	(	Signal *	signal,
		Uint32	ptrI,
		Uint32	retVal
	)

Definition at line 1767 of file SimulatedBlock.cpp.

References c_mutexMgr, and SimulatedBlock::MutexManager::release().

Referenced by Mutex::unlock().

01768                                                                      {
01769   c_mutexMgr.release(ptrI);
01770 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::infoEvent	(	const char *	msg,
			...
	)			const `[protected]`

General info event (sent to cluster log)

Init and put it into the job buffer

Definition at line 743 of file SimulatedBlock.cpp.

References buf, CMVMI, FastScheduler::execute(), FastScheduler::getVMSignals(), globalScheduler, GSN_EVENT_REP, Signal::header, JBB, memset, NDB_LE_InfoEvent, reference(), strlen(), SignalHeader::theLength, SignalHeader::theReceiversBlockNumber, SignalHeader::theSendersBlockRef, SignalHeader::theSignalId, SignalHeader::theTrace, SignalHeader::theVerId_signalNumber, and BaseString::vsnprintf().

00743                                                      {
00744   if(msg == 0)
00745     return;
00746   
00747   Uint32 theData[25];
00748   theData[0] = NDB_LE_InfoEvent;
00749   char * buf = (char *)&(theData[1]);
00750   
00751   va_list ap;
00752   va_start(ap, msg);
00753   BaseString::vsnprintf(buf, 96, msg, ap); // 96 = 100 - 4
00754   va_end(ap);
00755   
00756   int len = strlen(buf) + 1;
00757   if(len > 96){
00758     len = 96;
00759     buf[95] = 0;
00760   }
00761 
00765   SignalHeader sh;
00766   memset(&sh, 0, sizeof(SignalHeader));
00767   
00768   const Signal * signal = globalScheduler.getVMSignals();
00769   Uint32 tTrace = signal->header.theTrace;
00770   Uint32 tSignalId = signal->header.theSignalId;
00771   
00772   sh.theVerId_signalNumber   = GSN_EVENT_REP;
00773   sh.theReceiversBlockNumber = CMVMI;
00774   sh.theSendersBlockRef      = reference();
00775   sh.theTrace                = tTrace;
00776   sh.theSignalId             = tSignalId;
00777   sh.theLength               = ((len+3)/4)+1;
00778   
00779   Uint32 secPtrI[3]; // Dummy
00780   globalScheduler.execute(&sh, JBB, theData, secPtrI);
00781 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::installSimulatedBlockFunctions ( ) [protected]

Definition at line 132 of file SimulatedBlock.cpp.

References execAPI_START_REP(), execCHANGE_NODE_STATE_REQ(), execCONTINUE_FRAGMENTED(), execFSAPPENDREF(), execFSCLOSEREF(), execFSOPENREF(), execFSREADREF(), execFSREMOVEREF(), execFSSYNCREF(), execFSWRITEREF(), execNDB_TAMPER(), execNODE_START_REP(), execNODE_STATE_REP(), execSIGNAL_DROPPED_REP(), execUTIL_CREATE_LOCK_CONF(), execUTIL_CREATE_LOCK_REF(), execUTIL_DESTORY_LOCK_CONF(), execUTIL_DESTORY_LOCK_REF(), execUTIL_LOCK_CONF(), execUTIL_LOCK_REF(), execUTIL_UNLOCK_CONF(), execUTIL_UNLOCK_REF(), GSN_API_START_REP, GSN_CHANGE_NODE_STATE_REQ, GSN_CONTINUE_FRAGMENTED, GSN_FSAPPENDREF, GSN_FSCLOSEREF, GSN_FSOPENREF, GSN_FSREADREF, GSN_FSREMOVEREF, GSN_FSSYNCREF, GSN_FSWRITEREF, GSN_NDB_TAMPER, GSN_NODE_START_REP, GSN_NODE_STATE_REP, GSN_SIGNAL_DROPPED_REP, GSN_UTIL_CREATE_LOCK_CONF, GSN_UTIL_CREATE_LOCK_REF, GSN_UTIL_DESTROY_LOCK_CONF, GSN_UTIL_DESTROY_LOCK_REF, GSN_UTIL_LOCK_CONF, GSN_UTIL_LOCK_REF, GSN_UTIL_UNLOCK_CONF, GSN_UTIL_UNLOCK_REF, and theExecArray.

Referenced by SimulatedBlock().

00132                                               {
00133   ExecFunction * a = theExecArray;
00134   a[GSN_NODE_STATE_REP] = &SimulatedBlock::execNODE_STATE_REP;
00135   a[GSN_CHANGE_NODE_STATE_REQ] = &SimulatedBlock::execCHANGE_NODE_STATE_REQ;
00136   a[GSN_NDB_TAMPER] = &SimulatedBlock::execNDB_TAMPER;
00137   a[GSN_SIGNAL_DROPPED_REP] = &SimulatedBlock::execSIGNAL_DROPPED_REP;
00138   a[GSN_CONTINUE_FRAGMENTED]= &SimulatedBlock::execCONTINUE_FRAGMENTED;
00139   a[GSN_UTIL_CREATE_LOCK_REF]   = &SimulatedBlock::execUTIL_CREATE_LOCK_REF;
00140   a[GSN_UTIL_CREATE_LOCK_CONF]  = &SimulatedBlock::execUTIL_CREATE_LOCK_CONF;
00141   a[GSN_UTIL_DESTROY_LOCK_REF]  = &SimulatedBlock::execUTIL_DESTORY_LOCK_REF;
00142   a[GSN_UTIL_DESTROY_LOCK_CONF] = &SimulatedBlock::execUTIL_DESTORY_LOCK_CONF;
00143   a[GSN_UTIL_LOCK_REF]    = &SimulatedBlock::execUTIL_LOCK_REF;
00144   a[GSN_UTIL_LOCK_CONF]   = &SimulatedBlock::execUTIL_LOCK_CONF;
00145   a[GSN_UTIL_UNLOCK_REF]  = &SimulatedBlock::execUTIL_UNLOCK_REF;
00146   a[GSN_UTIL_UNLOCK_CONF] = &SimulatedBlock::execUTIL_UNLOCK_CONF;
00147   a[GSN_FSOPENREF]    = &SimulatedBlock::execFSOPENREF;
00148   a[GSN_FSCLOSEREF]   = &SimulatedBlock::execFSCLOSEREF;
00149   a[GSN_FSWRITEREF]   = &SimulatedBlock::execFSWRITEREF;
00150   a[GSN_FSREADREF]    = &SimulatedBlock::execFSREADREF;
00151   a[GSN_FSREMOVEREF]  = &SimulatedBlock::execFSREMOVEREF;
00152   a[GSN_FSSYNCREF]    = &SimulatedBlock::execFSSYNCREF;
00153   a[GSN_FSAPPENDREF]  = &SimulatedBlock::execFSAPPENDREF;
00154   a[GSN_NODE_START_REP] = &SimulatedBlock::execNODE_START_REP;
00155   a[GSN_API_START_REP] = &SimulatedBlock::execAPI_START_REP;
00156 }

Here is the call graph for this function:

Here is the caller graph for this function:

BlockNumber SimulatedBlock::number ( ) const [inline, protected]

Definition at line 606 of file SimulatedBlock.hpp.

References theNumber.

Referenced by allocRecord(), Dbdih::execLCP_COMPLETE_REP(), Dbdih::execLCP_FRAG_REP(), execSIGNAL_DROPPED_REP(), DbUtil::execSTTOR(), fsRefError(), Suma::SyncRecord::number(), Ndbcntr::Missra::number(), Ndbcntr::StopRecord::number(), Backup::BackupRecord::number(), Backup::CompoundState::number(), Backup::OperationRecord::number(), progError(), and sendSignal().

00606                              {
00607    return theNumber;
00608 }

Here is the caller graph for this function:

void SimulatedBlock::progError	(	int	line,
		int	err_code,
		const char *	extradata = `NULL`
	)			const `[protected]`

Prog error This function should be called when this node should be shutdown If the cause of the shutdown is known use extradata to add an errormessage describing the problem

Definition at line 720 of file SimulatedBlock.cpp.

References buf, getBlockName(), Configuration::getDaemonMode(), Configuration::getInitialStart(), ErrorReporter::handleError(), jamLine, Block_context::m_config, m_ctx, number(), BaseString::snprintf(), and Configuration::stopOnError().

Referenced by Restore::check_file_version(), Qmgr::check_readnodes_reply(), Suma::createSequenceReply(), Qmgr::execCM_REGREF(), Ndbcntr::execCNTR_START_REF(), Qmgr::execCONTINUEB(), Ndbcntr::execCONTINUEB(), Ndbcntr::execCREATE_TABLE_REF(), Dblqh::execDEBUG_SIG(), Dbacc::execDEBUG_SIG(), Qmgr::execDISCONNECT_REP(), Dblqh::execDUMP_STATE_ORD(), Qmgr::execNDB_FAILCONF(), Suma::execNODE_FAILREP(), Ndbcntr::execNODE_FAILREP(), Dbdih::execREAD_NODESCONF(), Dbdih::execSTART_PERMREF(), Ndbcntr::execSYSTEM_ERROR(), Dbdict::execWAIT_GCP_REF(), Qmgr::failReportLab(), Dblqh::findLogfile(), fsRefError(), Pool_context::handleAbort(), Dbdih::initCommonData(), Dblqh::logLqhkeyrefLab(), Dbdih::makeNodeGroups(), SafeCounterManager::progError(), SimulatedBlock::MutexManager::progError(), Suma::Restart::progError(), Suma::SyncRecord::progError(), Ndbcntr::Missra::progError(), Ndbcntr::StopRecord::progError(), Backup::BackupRecord::progError(), Backup::CompoundState::progError(), Backup::OperationRecord::progError(), Dbdict::restartCreateTab_readTableConf(), Dbdih::selectMasterCandidateAndSend(), UpgradeStartup::sendCntrMasterReq(), Dbtc::sendSystemError(), Dbacc::sendSystemerror(), Suma::start_resend(), Dbdih::startFragment(), Qmgr::stateArbitCrash(), Dblqh::systemError(), Qmgr::systemErrorBecauseOtherNodeFailed(), Qmgr::systemErrorLab(), Ndbcntr::systemErrorLab(), Dbtc::systemErrorLab(), and Dblqh::systemErrorLab().

00720                                                                          {
00721   jamLine(line);
00722 
00723   const char *aBlockName = getBlockName(number(), "VM Kernel");
00724 
00725   // Pack status of interesting config variables 
00726   // so that we can print them in error.log
00727   int magicStatus = 
00728     (m_ctx.m_config.stopOnError()<<1) + 
00729     (m_ctx.m_config.getInitialStart()<<2) + 
00730     (m_ctx.m_config.getDaemonMode()<<3);
00731   
00732 
00733   /* Add line number to block name */
00734   char buf[100];
00735   BaseString::snprintf(&buf[0], 100, "%s (Line: %d) 0x%.8x", 
00736            aBlockName, line, magicStatus);
00737 
00738   ErrorReporter::handleError(err_code, extra, buf);
00739 
00740 }

Here is the call graph for this function:

Here is the caller graph for this function:

BlockReference SimulatedBlock::reference ( ) const [inline, protected]

Definition at line 612 of file SimulatedBlock.hpp.

References theReference.

00612                                 {
00613    return theReference;
00614 }

Here is the caller graph for this function:

void SimulatedBlock::refresh_watch_dog ( ) [protected]

Refresh Watch Dog in initialising code

Definition at line 714 of file SimulatedBlock.cpp.

References globalData, and GlobalData::incrementWatchDogCounter().

Referenced by allocRecord(), Dbtux::execREAD_CONFIG_REQ(), Dbtc::initApiConnect(), Dbtc::initattrbuf(), Dbtc::initdatabuf(), Dblqh::initialiseAttrbuf(), Dblqh::initialiseDatabuf(), Dbacc::initialiseDirRangeRec(), Dbacc::initialiseDirRec(), Dblqh::initialiseFragrec(), Dbacc::initialiseFragRec(), Dbdih::initialiseFragstore(), Dblqh::initialiseLogPage(), Dbacc::initialiseOperationRec(), Dbacc::initialiseOverflowRec(), Dbdih::initialiseRecordsLab(), Dbtc::initialiseScanrec(), Dblqh::initialiseScanrec(), Dbacc::initialiseTableRec(), Dblqh::initialiseTabrec(), Dbtc::initialiseTcConnect(), Dblqh::initialiseTcrec(), Dbtup::initializeAttrbufrec(), Dbtup::initializeFragrecord(), Dbtup::initializeOperationrec(), Dbtup::initializePage(), Dbtup::initializeTabDescr(), Dbtup::initializeTablerec(), Dbtc::initTable(), Dbdict::initTableRecords(), and Dbdict::initTriggerRecords().

00715 {
00716   globalData.incrementWatchDogCounter(1);
00717 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::releaseSections ( Signal * signal ) [protected]

Definition at line 616 of file SimulatedBlock.cpp.

References Signal::header, SignalHeader::m_noOfSections, and Signal::m_sectionPtr.

Referenced by Dbdict::alterTab_writeTableConf(), Dbdict::alterTableRef(), Dbdict::alterTabRef(), Dbdict::createEvent_RT_USER_CREATE(), Dbdict::createEvent_RT_USER_GET(), Dbdict::createObj_prepare_start_done(), Dbdict::createObj_writeSchemaConf1(), Dbdict::createTab_writeSchemaConf1(), Dbdict::execALTER_INDX_REQ(), Dbdict::execALTER_TAB_CONF(), Suma::execALTER_TAB_REQ(), Dbdict::execALTER_TAB_REQ(), Dbdict::execALTER_TABLE_REQ(), Trix::execBUILDINDXREQ(), Dbdict::execBUILDINDXREQ(), Dbdict::execCREATE_EVNT_REQ(), Dbtc::execCREATE_INDX_REQ(), Dbdict::execCREATE_INDX_REQ(), Dbdict::execCREATE_SUBID_CONF(), Dbdict::execCREATE_TABLE_REQ(), Dbtc::execCREATE_TRIG_REQ(), Dbdict::execCREATE_TRIG_REQ(), Dbdih::execDIADDTABREQ(), Dbdict::execDROP_EVNT_REQ(), Dbdict::execDROP_TRIG_REQ(), Ndbfs::execFSOPENREQ(), Suma::execGET_TABINFO_CONF(), Dbdict::execGET_TABINFO_CONF(), Backup::execGET_TABINFO_CONF(), Tsman::execGET_TABINFOREQ(), Lgman::execGET_TABINFOREQ(), Dbdict::execGET_TABINFOREQ(), Dbdict::execGET_TABLEDID_REQ(), Dbtc::execSCAN_TABREQ(), Dbdict::execSCHEMA_INFO(), Suma::execSUB_SYNC_REQ(), DbUtil::execUTIL_EXECUTE_REQ(), DbUtil::execUTIL_PREPARE_REQ(), Dbdict::parseReadEventSys(), DbUtil::prepareOperation(), Dbdict::releaseCreateTableOp(), Dbdict::restartCreateObj_write_complete(), sendFirstFragment(), sendSignal(), Suma::sendSubIdRef(), Suma::sendSubRemoveRef(), Suma::sendSubStartRef(), and Suma::sendSubSyncRef().

00616                                              {
00617   ::releaseSections(signal->header.m_noOfSections, signal->m_sectionPtr);
00618   signal->header.m_noOfSections = 0;
00619 }

Here is the caller graph for this function:

bool SimulatedBlock::sendFirstFragment	(	FragmentSendInfo &	info,
		NodeReceiverGroup	rg,
		GlobalSignalNumber	gsn,
		Signal *	signal,
		Uint32	length,
		JobBufferLevel	jbuf,
		Uint32	messageSize = `240`
	)			`[protected]`

Definition at line 1091 of file SimulatedBlock.cpp.

01097                                                      {
01098   
01099   info.m_sectionPtr[0].m_segmented.i = RNIL;
01100   info.m_sectionPtr[1].m_segmented.i = RNIL;
01101   info.m_sectionPtr[2].m_segmented.i = RNIL;
01102   
01103   Uint32 totalSize = 0;
01104   SectionSegment * p;
01105   switch(signal->header.m_noOfSections){
01106   case 3:
01107     p = signal->m_sectionPtr[2].p;  
01108     info.m_sectionPtr[2].m_segmented.p = p;
01109     info.m_sectionPtr[2].m_segmented.i = signal->m_sectionPtr[2].i;
01110     totalSize += p->m_sz;
01111   case 2:
01112     p = signal->m_sectionPtr[1].p;  
01113     info.m_sectionPtr[1].m_segmented.p = p;
01114     info.m_sectionPtr[1].m_segmented.i = signal->m_sectionPtr[1].i;
01115     totalSize += p->m_sz;
01116   case 1:
01117     p = signal->m_sectionPtr[0].p;  
01118     info.m_sectionPtr[0].m_segmented.p = p;
01119     info.m_sectionPtr[0].m_segmented.i = signal->m_sectionPtr[0].i;
01120     totalSize += p->m_sz;
01121   }
01122 
01123   if(totalSize <= messageSize + SectionSegment::DataLength){
01127     sendSignal(rg, gsn, signal, length, jbuf);
01128     info.m_status = FragmentSendInfo::SendComplete;
01129     return true;
01130   }
01131 
01135   signal->header.m_noOfSections = 0;
01136     
01140   info.m_status = FragmentSendInfo::SendNotComplete;
01141   info.m_prio = (Uint8)jbuf;
01142   info.m_gsn = gsn;
01143   info.m_fragInfo = 1;
01144   info.m_messageSize = messageSize;
01145   info.m_fragmentId = c_fragmentIdCounter++;
01146   info.m_nodeReceiverGroup = rg;
01147   info.m_callback.m_callbackFunction = 0;
01148   
01149   Ptr<SectionSegment> tmp;
01150   if(!import(tmp, &signal->theData[0], length)){
01151     ndbrequire(false);
01152     return false;
01153   }
01154   info.m_theDataSection.p = &tmp.p->theData[0];
01155   info.m_theDataSection.sz = length;
01156   tmp.p->theData[length] = tmp.i;
01157   
01158   sendNextSegmentedFragment(signal, info);
01159   
01160   if(c_fragmentIdCounter == 0){
01164     c_fragmentIdCounter = 1;
01165   }
01166 
01167   return true;
01168 }

Here is the call graph for this function:

bool SimulatedBlock::sendFirstFragment	(	FragmentSendInfo &	info,
		NodeReceiverGroup	rg,
		GlobalSignalNumber	gsn,
		Signal *	signal,
		Uint32	length,
		JobBufferLevel	jbuf,
		LinearSectionPtr	ptr[3],
		Uint32	noOfSections,
		Uint32	messageSize = `240`
	)			`[protected]`

setupFragmentSendInfo Setup a struct to be used with sendSignalFragment Used by sendFragmentedSignal

Send signal directly

Indicate to sendLinearSignalFragment that we'r already done

Setup info object

Fragment id 0 is invalid

Definition at line 1337 of file SimulatedBlock.cpp.

Referenced by sendFragmentedSignal().

01345                                                      {
01346   
01347   ::releaseSections(signal->header.m_noOfSections, signal->m_sectionPtr);
01348   signal->header.m_noOfSections = 0;
01349   
01350   info.m_sectionPtr[0].m_linear.p = NULL;
01351   info.m_sectionPtr[1].m_linear.p = NULL;
01352   info.m_sectionPtr[2].m_linear.p = NULL;
01353   
01354   Uint32 totalSize = 0;
01355   switch(noOfSections){
01356   case 3:
01357     info.m_sectionPtr[2].m_linear = ptr[2];
01358     totalSize += ptr[2].sz;
01359   case 2:
01360     info.m_sectionPtr[1].m_linear = ptr[1];
01361     totalSize += ptr[1].sz;
01362   case 1:
01363     info.m_sectionPtr[0].m_linear = ptr[0];
01364     totalSize += ptr[0].sz;
01365   }
01366 
01367   if(totalSize <= messageSize + SectionSegment::DataLength){
01371     sendSignal(rg, gsn, signal, length, jbuf, ptr, noOfSections);
01372     info.m_status = FragmentSendInfo::SendComplete;
01373     
01378     return true;
01379   }
01380 
01384   info.m_status = FragmentSendInfo::SendNotComplete;
01385   info.m_prio = (Uint8)jbuf;
01386   info.m_gsn = gsn;
01387   info.m_messageSize = messageSize;
01388   info.m_fragInfo = 1;
01389   info.m_fragmentId = c_fragmentIdCounter++;
01390   info.m_nodeReceiverGroup = rg;
01391   info.m_callback.m_callbackFunction = 0;
01392 
01393   Ptr<SectionSegment> tmp;
01394   if(!import(tmp, &signal->theData[0], length)){
01395     ndbrequire(false);
01396     return false;
01397   }
01398 
01399   info.m_theDataSection.p = &tmp.p->theData[0];
01400   info.m_theDataSection.sz = length;
01401   tmp.p->theData[length] = tmp.i;
01402   
01403   sendNextLinearFragment(signal, info);
01404 
01405   if(c_fragmentIdCounter == 0){
01409     c_fragmentIdCounter = 1;
01410   }
01411   
01412   return true;
01413 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::sendFragmentedSignal	(	NodeReceiverGroup	rg,
		GlobalSignalNumber	gsn,
		Signal *	signal,
		Uint32	length,
		JobBufferLevel	jbuf,
		LinearSectionPtr	ptr[3],
		Uint32	noOfSections,
		Callback &	,
		Uint32	messageSize = `240`
	)			`[protected]`

Definition at line 1678 of file SimulatedBlock.cpp.

References c_fragSenderRunning, c_linearFragmentSendList, execute(), Signal::getDataPtrSend(), GSN_CONTINUE_FRAGMENTED, JBB, SimulatedBlock::FragmentSendInfo::m_callback, SimulatedBlock::Callback::m_callbackFunction, SimulatedBlock::FragmentSendInfo::m_status, ndbrequire, Ptr< T >::p, reference(), SimulatedBlock::FragmentSendInfo::SendComplete, sendFirstFragment(), sendSignal(), and sig().

01686                                                         {
01687   bool res = true;
01688   Ptr<FragmentSendInfo> tmp;
01689   res = c_linearFragmentSendList.seize(tmp);
01690   ndbrequire(res);
01691 
01692   res = sendFirstFragment(* tmp.p, 
01693                           rg,
01694                           gsn,
01695                           signal,
01696                           length,
01697                           jbuf,
01698                           ptr,
01699                           noOfSections,
01700                           messageSize);
01701   ndbrequire(res);
01702   
01703   if(tmp.p->m_status == FragmentSendInfo::SendComplete){
01704     c_linearFragmentSendList.release(tmp);
01705     if(c.m_callbackFunction != 0)
01706       execute(signal, c, 0);
01707     return;
01708   }
01709   tmp.p->m_callback = c;
01710   
01711   if(!c_fragSenderRunning){
01712     c_fragSenderRunning = true;
01713     ContinueFragmented * sig = (ContinueFragmented*)signal->getDataPtrSend();
01714     sig->line = __LINE__;
01715     sendSignal(reference(), GSN_CONTINUE_FRAGMENTED, signal, 1, JBB);
01716   }
01717 }

Here is the call graph for this function:

void SimulatedBlock::sendFragmentedSignal	(	BlockReference	ref,
		GlobalSignalNumber	gsn,
		Signal *	signal,
		Uint32	length,
		JobBufferLevel	jbuf,
		LinearSectionPtr	ptr[3],
		Uint32	noOfSections,
		Callback &	,
		Uint32	messageSize = `240`
	)			`[protected]`

Definition at line 1636 of file SimulatedBlock.cpp.

01644                                                         {
01645   bool res = true;
01646   Ptr<FragmentSendInfo> tmp;
01647   res = c_linearFragmentSendList.seize(tmp);
01648   ndbrequire(res);
01649 
01650   res = sendFirstFragment(* tmp.p, 
01651                           NodeReceiverGroup(ref),
01652                           gsn,
01653                           signal,
01654                           length,
01655                           jbuf,
01656                           ptr,
01657                           noOfSections,
01658                           messageSize);
01659   ndbrequire(res);
01660   
01661   if(tmp.p->m_status == FragmentSendInfo::SendComplete){
01662     c_linearFragmentSendList.release(tmp);
01663     if(c.m_callbackFunction != 0)
01664       execute(signal, c, 0);
01665     return;
01666   }
01667   tmp.p->m_callback = c;
01668   
01669   if(!c_fragSenderRunning){
01670     c_fragSenderRunning = true;
01671     ContinueFragmented * sig = (ContinueFragmented*)signal->getDataPtrSend();
01672     sig->line = __LINE__;
01673     sendSignal(reference(), GSN_CONTINUE_FRAGMENTED, signal, 1, JBB);
01674   }
01675 }

Here is the call graph for this function:

void SimulatedBlock::sendFragmentedSignal	(	NodeReceiverGroup	rg,
		GlobalSignalNumber	gsn,
		Signal *	signal,
		Uint32	length,
		JobBufferLevel	jbuf,
		Callback &	= `TheEmptyCallback`,
		Uint32	messageSize = `240`
	)			`[protected]`

Definition at line 1596 of file SimulatedBlock.cpp.

References c_fragSenderRunning, c_segmentedFragmentSendList, execute(), Signal::getDataPtrSend(), GSN_CONTINUE_FRAGMENTED, JBB, SimulatedBlock::FragmentSendInfo::m_callback, SimulatedBlock::Callback::m_callbackFunction, SimulatedBlock::FragmentSendInfo::m_status, ndbrequire, Ptr< T >::p, reference(), SimulatedBlock::FragmentSendInfo::SendComplete, sendFirstFragment(), sendSignal(), and sig().

01602                                                         {
01603   bool res = true;
01604   Ptr<FragmentSendInfo> ptr;
01605   res = c_segmentedFragmentSendList.seize(ptr);
01606   ndbrequire(res);
01607   
01608   res = sendFirstFragment(* ptr.p, 
01609                           rg,
01610                           gsn,
01611                           signal,
01612                           length,
01613                           jbuf,
01614                           messageSize);
01615   ndbrequire(res);
01616   
01617   if(ptr.p->m_status == FragmentSendInfo::SendComplete){
01618     c_segmentedFragmentSendList.release(ptr);
01619     if(c.m_callbackFunction != 0)
01620       execute(signal, c, 0);
01621     return;
01622   }
01623   ptr.p->m_callback = c;
01624 
01625   if(!c_fragSenderRunning){
01626     c_fragSenderRunning = true;
01627     ContinueFragmented * sig = (ContinueFragmented*)signal->getDataPtrSend();
01628     sig->line = __LINE__;
01629     sendSignal(reference(), GSN_CONTINUE_FRAGMENTED, signal, 1, JBB);
01630   }
01631 }

Here is the call graph for this function:

void SimulatedBlock::sendFragmentedSignal	(	BlockReference	ref,
		GlobalSignalNumber	gsn,
		Signal *	signal,
		Uint32	length,
		JobBufferLevel	jbuf,
		Callback &	= `TheEmptyCallback`,
		Uint32	messageSize = `240`
	)			`[protected]`

Definition at line 1558 of file SimulatedBlock.cpp.

Referenced by Dbdict::alterTable_backup_mutex_locked(), Dbdict::execALTER_TAB_CONF(), Suma::execALTER_TAB_REQ(), Dbdict::execCREATE_FRAGMENTATION_CONF(), Dbdict::masterRestart_checkSchemaStatusComplete(), and Dbdict::sendGetTabResponse().

01564                                                         {
01565   bool res = true;
01566   Ptr<FragmentSendInfo> ptr;
01567   res = c_segmentedFragmentSendList.seize(ptr);
01568   ndbrequire(res);
01569   
01570   res = sendFirstFragment(* ptr.p, 
01571                           NodeReceiverGroup(ref),
01572                           gsn,
01573                           signal,
01574                           length,
01575                           jbuf,
01576                           messageSize);
01577   ndbrequire(res);
01578   
01579   if(ptr.p->m_status == FragmentSendInfo::SendComplete){
01580     c_segmentedFragmentSendList.release(ptr);
01581     if(c.m_callbackFunction != 0)
01582       execute(signal, c, 0);
01583     return;
01584   }
01585   ptr.p->m_callback = c;
01586 
01587   if(!c_fragSenderRunning){
01588     c_fragSenderRunning = true;
01589     ContinueFragmented * sig = (ContinueFragmented*)signal->getDataPtrSend();
01590     sig->line = __LINE__;
01591     sendSignal(reference(), GSN_CONTINUE_FRAGMENTED, signal, 1, JBB);
01592   }
01593 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::sendNextLinearFragment	(	Signal *	signal,
		FragmentSendInfo &	info
	)			`[protected]`

Send signal fragment

See also:: sendFragmentedSignal

Store "theData"

The section fits

Only one segment left to send send even if sizeLeft <= size

Less than one segment left (space) dont bother sending

Split list 1) Find place to split 2) Rewrite header (the part that will be sent) 3) Write new header (for remaining part) 4) Store new header on FragmentSendInfo - record

Rewrite header w.r.t size

Write/store "new" header

Store fragment id

Not finished

This is the last signal

Definition at line 1416 of file SimulatedBlock.cpp.

References lsout, SimulatedBlock::FragmentSendInfo::m_linear, SimulatedBlock::FragmentSendInfo::m_messageSize, SimulatedBlock::FragmentSendInfo::m_sectionPtr, SimulatedBlock::FragmentSendInfo::m_theDataSection, memcpy, ndbout_c(), NULL, LinearSectionPtr::p, ArrayPool< SectionSegment >::size, LinearSectionPtr::sz, and Signal::theData.

Referenced by execCONTINUE_FRAGMENTED(), and sendFirstFragment().

01417                                                                {
01418   
01422   const Uint32 sigLen = info.m_theDataSection.sz;
01423   memcpy(&signal->theData[0], info.m_theDataSection.p, 4 * sigLen);
01424   
01425   Uint32 sz = 0; 
01426   Uint32 maxSz = info.m_messageSize;
01427   
01428   Int32 secNo = 2;
01429   Uint32 secCount = 0;
01430   Uint32 * secNos = &signal->theData[sigLen];
01431   LinearSectionPtr signalPtr[3];
01432   
01433   enum { Unknown = 0, Full = 2 } loop = Unknown;
01434   for(; secNo >= 0 && secCount < 3; secNo--){
01435     Uint32 * ptrP = info.m_sectionPtr[secNo].m_linear.p;
01436     if(ptrP == NULL)
01437       continue;
01438     
01439     info.m_sectionPtr[secNo].m_linear.p = NULL;
01440     const Uint32 size = info.m_sectionPtr[secNo].m_linear.sz;
01441     
01442     signalPtr[secCount].p = ptrP;
01443     signalPtr[secCount].sz = size;
01444     secNos[secCount] = secNo;
01445     secCount++;
01446     
01447     const Uint32 sizeLeft = maxSz - sz;
01448     if(size <= sizeLeft){
01452       sz += size;
01453       lsout(ndbout_c("section %d saved as %d", secNo, secCount-1));
01454       continue;
01455     }
01456     
01457     const Uint32 overflow = size - sizeLeft; // > 0
01458     if(overflow <= SectionSegment::DataLength){
01463       lsout(ndbout_c("section %d saved as %d but full over: %d", 
01464                      secNo, secCount-1, overflow));
01465       secNo--;
01466       break;
01467     }
01468 
01469     // size >= 61
01470     if(sizeLeft < SectionSegment::DataLength){
01475       secCount--;
01476       info.m_sectionPtr[secNo].m_linear.p = ptrP;
01477       loop = Full;
01478       lsout(ndbout_c("section %d not saved", secNo));
01479       break;
01480     }
01481     
01489     Uint32 sum = sizeLeft;
01490     sum /= SectionSegment::DataLength;
01491     sum *= SectionSegment::DataLength;
01492     
01496     Uint32 prev = secCount - 1;
01497     signalPtr[prev].sz = sum;
01498     
01502     info.m_sectionPtr[secNo].m_linear.p = ptrP + sum;
01503     info.m_sectionPtr[secNo].m_linear.sz = size - sum;
01504     
01505     loop = Full;
01506     lsout(ndbout_c("section %d split into %d", secNo, prev));
01507     break;
01508   }
01509   
01510   lsout(ndbout_c("loop: %d secNo: %d secCount: %d sz: %d", 
01511                  loop, secNo, secCount, sz));
01512   
01516   secNos[secCount] = info.m_fragmentId;
01517   
01518   Uint32 fragInfo = info.m_fragInfo;
01519   info.m_fragInfo = 2;
01520   switch(loop){
01521   case Unknown:
01522     if(secNo >= 0){
01523       lsout(ndbout_c("Unknown - Full"));
01527       break;
01528     }
01529     // Fall through
01530     lsout(ndbout_c("Unknown - Done"));
01531     info.m_status = FragmentSendInfo::SendComplete;
01532     ndbassert(fragInfo == 2);
01533     fragInfo = 3;
01534   case Full:
01535     break;
01536   }
01537   
01538   signal->header.m_noOfSections = 0;
01539   signal->header.m_fragmentInfo = fragInfo;
01540   
01541   sendSignal(info.m_nodeReceiverGroup,
01542              info.m_gsn,
01543              signal, 
01544              sigLen + secCount + 1,
01545              (JobBufferLevel)info.m_prio,
01546              signalPtr,
01547              secCount);
01548   
01549   if(fragInfo == 3){
01553     g_sectionSegmentPool.release(info.m_theDataSection.p[sigLen]);
01554   }
01555 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::sendNextSegmentedFragment	(	Signal *	signal,
		FragmentSendInfo &	info
	)			`[protected]`

Send signal fragment

See also:: sendFragmentedSignal

Store "theData"

The section fits

Only one segment left to send send even if sizeLeft <= size

Less than one segment left (space) dont bother sending

Split list 1) Find place to split 2) Rewrite header (the part that will be sent) 3) Write new header (for remaining part) 4) Store new header on FragmentSendInfo - record

Rewrite header w.r.t size and last

Write "new" list header

And store it on info-record

Store fragment id

Not finished

This is the last signal

Definition at line 1177 of file SimulatedBlock.cpp.

References mySTL::fill(), g_sectionSegmentPool, ArrayPool< T >::getPtr(), SegmentedSectionPtr::i, lsout, SectionSegment::m_lastSegment, SimulatedBlock::FragmentSendInfo::m_messageSize, Signal::m_sectionPtr, SimulatedBlock::FragmentSendInfo::m_sectionPtr, SimulatedBlock::FragmentSendInfo::m_segmented, SectionSegment::m_sz, SimulatedBlock::FragmentSendInfo::m_theDataSection, memcpy, ndbout_c(), SegmentedSectionPtr::p, LinearSectionPtr::p, RNIL, ArrayPool< SectionSegment >::size, SegmentedSectionPtr::sz, LinearSectionPtr::sz, and Signal::theData.

Referenced by execCONTINUE_FRAGMENTED(), and sendFirstFragment().

01178                                                                   {
01179   
01183   const Uint32 sigLen = info.m_theDataSection.sz;
01184   memcpy(&signal->theData[0], info.m_theDataSection.p, 4 * sigLen);
01185   
01186   Uint32 sz = 0; 
01187   Uint32 maxSz = info.m_messageSize;
01188   
01189   Int32 secNo = 2;
01190   Uint32 secCount = 0;
01191   Uint32 * secNos = &signal->theData[sigLen];
01192   
01193   enum { Unknown = 0, Full = 1 } loop = Unknown;
01194   for(; secNo >= 0 && secCount < 3; secNo--){
01195     Uint32 ptrI = info.m_sectionPtr[secNo].m_segmented.i;
01196     if(ptrI == RNIL)
01197       continue;
01198     
01199     info.m_sectionPtr[secNo].m_segmented.i = RNIL;
01200     
01201     SectionSegment * ptrP = info.m_sectionPtr[secNo].m_segmented.p;
01202     const Uint32 size = ptrP->m_sz;
01203     
01204     signal->m_sectionPtr[secCount].i = ptrI;
01205     signal->m_sectionPtr[secCount].p = ptrP;
01206     signal->m_sectionPtr[secCount].sz = size;
01207     secNos[secCount] = secNo;
01208     secCount++;
01209     
01210     const Uint32 sizeLeft = maxSz - sz;
01211     if(size <= sizeLeft){
01215       sz += size;
01216       lsout(ndbout_c("section %d saved as %d", secNo, secCount-1));
01217       continue;
01218     }
01219     
01220     const Uint32 overflow = size - sizeLeft; // > 0
01221     if(overflow <= SectionSegment::DataLength){
01226       lsout(ndbout_c("section %d saved as %d but full over: %d", 
01227                      secNo, secCount-1, overflow));
01228       secNo--;
01229       break;
01230     }
01231 
01232     // size >= 61
01233     if(sizeLeft < SectionSegment::DataLength){
01238       secCount--;
01239       info.m_sectionPtr[secNo].m_segmented.i = ptrI;
01240       loop = Full;
01241       lsout(ndbout_c("section %d not saved", secNo));
01242       break;
01243     }
01244     
01252     // size >= 61 && sizeLeft >= 60
01253     Uint32 sum = SectionSegment::DataLength;
01254     Uint32 prevPtrI = ptrI;
01255     ptrI = ptrP->m_nextSegment;
01256     const Uint32 fill = sizeLeft - SectionSegment::DataLength;
01257     while(sum < fill){
01258       prevPtrI = ptrI;
01259       ptrP = g_sectionSegmentPool.getPtr(ptrI);
01260       ptrI = ptrP->m_nextSegment;
01261       sum += SectionSegment::DataLength;
01262     }
01263     
01267     Uint32 prev = secCount - 1;
01268     const Uint32 last = signal->m_sectionPtr[prev].p->m_lastSegment;
01269     signal->m_sectionPtr[prev].p->m_lastSegment = prevPtrI;
01270     signal->m_sectionPtr[prev].p->m_sz = sum;
01271     signal->m_sectionPtr[prev].sz = sum;
01272       
01276     ptrP = g_sectionSegmentPool.getPtr(ptrI);
01277     ptrP->m_lastSegment = last;
01278     ptrP->m_sz = size - sum;
01279     
01283     info.m_sectionPtr[secNo].m_segmented.i = ptrI;
01284     info.m_sectionPtr[secNo].m_segmented.p = ptrP;
01285     
01286     loop = Full;
01287     lsout(ndbout_c("section %d split into %d", secNo, prev));
01288     break;
01289   }
01290   
01291   lsout(ndbout_c("loop: %d secNo: %d secCount: %d sz: %d", 
01292                  loop, secNo, secCount, sz));
01293   
01297   secNos[secCount] = info.m_fragmentId;
01298   
01299   Uint32 fragInfo = info.m_fragInfo;
01300   info.m_fragInfo = 2;
01301   switch(loop){
01302   case Unknown:
01303     if(secNo >= 0){
01304       lsout(ndbout_c("Unknown - Full"));
01308       break;
01309     }
01310     // Fall through
01311     lsout(ndbout_c("Unknown - Done"));
01312     info.m_status = FragmentSendInfo::SendComplete;
01313     ndbassert(fragInfo == 2);
01314     fragInfo = 3;
01315   case Full:
01316     break;
01317   }
01318   
01319   signal->header.m_fragmentInfo = fragInfo;
01320   signal->header.m_noOfSections = secCount;
01321   
01322   sendSignal(info.m_nodeReceiverGroup,
01323              info.m_gsn,
01324              signal, 
01325              sigLen + secCount + 1,
01326              (JobBufferLevel)info.m_prio);
01327   
01328   if(fragInfo == 3){
01332     g_sectionSegmentPool.release(info.m_theDataSection.p[sigLen]);
01333   }
01334 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::sendSignal	(	NodeReceiverGroup	rg,
		GlobalSignalNumber	gsn,
		Signal *	signal,
		Uint32	length,
		JobBufferLevel	jbuf,
		LinearSectionPtr	ptr[3],
		Uint32	noOfSections
	)			const `[protected]`

Definition at line 468 of file SimulatedBlock.cpp.

References BitmaskPOD< size >::clear(), FastScheduler::execute(), BitmaskPOD< size >::find(), BitmaskPOD< size >::get(), getBlockName(), getSignalName(), Signal::getTrace(), globalData, globalScheduler, globalTransporterRegistry, Signal::header, Ptr< T >::i, SegmentedSectionPtr::i, BitmaskPOD< size >::isclear(), NodeReceiverGroup::m_block, SignalHeader::m_fragmentInfo, NodeReceiverGroup::m_nodes, SignalHeader::m_noOfSections, Signal::m_sectionPtr, ndbout_c(), ndbrequire, number(), GlobalData::ownId, p, TransporterRegistry::prepareSend(), reference(), releaseSections(), SEND_BLOCKED, SEND_DISCONNECTED, SEND_OK, signal_error(), GlobalData::testOn, Signal::theData, SignalHeader::theLength, SignalHeader::theReceiversBlockNumber, SignalHeader::theSendersBlockRef, SignalHeader::theSendersSignalId, SignalHeader::theSignalId, SignalHeader::theTrace, and SignalHeader::theVerId_signalNumber.

00474                                                       {
00475   
00476   Uint32 tSignalId = signal->header.theSignalId;
00477   Uint32 tTrace    = signal->getTrace();
00478   Uint32 tFragInfo = signal->header.m_fragmentInfo;
00479   
00480   Uint32 ourProcessor = globalData.ownId;
00481   Uint32 recBlock = rg.m_block;
00482   
00483   ::releaseSections(signal->header.m_noOfSections, signal->m_sectionPtr);
00484   
00485   signal->header.theLength = length;
00486   signal->header.theVerId_signalNumber = gsn;
00487   signal->header.theReceiversBlockNumber = recBlock;
00488   signal->header.theSendersSignalId = tSignalId;
00489   signal->header.theSendersBlockRef = reference();
00490   signal->header.m_noOfSections = noOfSections;
00491   
00492   if ((length == 0) || (length + noOfSections > 25) || (recBlock == 0)) {
00493     signal_error(gsn, length, recBlock, __FILE__, __LINE__);
00494     return;
00495   }//if
00496 
00497   SignalHeader sh;
00498   sh.theVerId_signalNumber   = gsn;
00499   sh.theReceiversBlockNumber = recBlock;
00500   sh.theSendersBlockRef      = number();
00501   sh.theLength               = length;
00502   sh.theTrace                = tTrace;
00503   sh.theSignalId             = tSignalId;
00504   sh.m_noOfSections          = noOfSections;
00505   sh.m_fragmentInfo          = tFragInfo;
00506 
00510   if(rg.m_nodes.get(0) || rg.m_nodes.get(ourProcessor)){
00511 #ifdef VM_TRACE
00512     if(globalData.testOn){
00513       globalSignalLoggers.sendSignal(signal->header, 
00514                                      jobBuffer, 
00515                                      &signal->theData[0],
00516                                      ourProcessor,
00517                                      ptr, noOfSections);
00518     }
00519 #endif
00520 
00523     Ptr<SectionSegment> segptr[3];
00524     for(Uint32 i = 0; i<noOfSections; i++){
00525       ndbrequire(import(segptr[i], ptr[i].p, ptr[i].sz));
00526       signal->m_sectionPtr[i].i = segptr[i].i;
00527     }
00528     globalScheduler.execute(signal, jobBuffer, recBlock, gsn);
00529     
00530     rg.m_nodes.clear((Uint32)0);
00531     rg.m_nodes.clear(ourProcessor);
00532   }
00533   
00537   Uint32 recNode = 0;
00538   while(!rg.m_nodes.isclear()){
00539     recNode = rg.m_nodes.find(recNode + 1);
00540     rg.m_nodes.clear(recNode);
00541     
00542 #ifdef VM_TRACE
00543     if(globalData.testOn){
00544       globalSignalLoggers.sendSignal(signal->header, 
00545                                      jobBuffer, 
00546                                      &signal->theData[0],
00547                                      recNode,
00548                                      ptr, noOfSections);
00549     }
00550 #endif
00551     
00552 #ifdef TRACE_DISTRIBUTED
00553     ndbout_c("send: %s(%d) to (%s, %d)",
00554              getSignalName(gsn), gsn, getBlockName(recBlock),
00555              recNode);
00556 #endif
00557 
00558     SendStatus ss = globalTransporterRegistry.prepareSend(&sh, jobBuffer, 
00559                                                           &signal->theData[0],
00560                                                           recNode,
00561                                                           ptr);
00562     ndbrequire(ss == SEND_OK || ss == SEND_BLOCKED || ss == SEND_DISCONNECTED);
00563   }
00564   
00565   signal->header.m_noOfSections = 0;
00566   signal->header.m_fragmentInfo = 0;
00567   
00568   return;
00569 }

Here is the call graph for this function:

void SimulatedBlock::sendSignal	(	BlockReference	ref,
		GlobalSignalNumber	gsn,
		Signal *	signal,
		Uint32	length,
		JobBufferLevel	jbuf,
		LinearSectionPtr	ptr[3],
		Uint32	noOfSections
	)			const `[protected]`

Definition at line 374 of file SimulatedBlock.cpp.

References FastScheduler::execute(), getBlockName(), getSignalName(), Signal::getTrace(), globalData, globalScheduler, globalTransporterRegistry, Signal::header, Ptr< T >::i, SegmentedSectionPtr::i, SignalHeader::m_fragmentInfo, SignalHeader::m_noOfSections, Signal::m_sectionPtr, ndbout_c(), ndbrequire, number(), GlobalData::ownId, p, TransporterRegistry::prepareSend(), reference(), refToBlock(), refToNode(), releaseSections(), SEND_BLOCKED, SEND_DISCONNECTED, SEND_OK, signal_error(), GlobalData::testOn, Signal::theData, SignalHeader::theLength, SignalHeader::theReceiversBlockNumber, SignalHeader::theSendersBlockRef, SignalHeader::theSendersSignalId, SignalHeader::theSignalId, SignalHeader::theTrace, and SignalHeader::theVerId_signalNumber.

00380                                                       {
00381   
00382   BlockNumber sendBnr = number();
00383   BlockReference sendBRef = reference();
00384   
00385   Uint32 recBlock = refToBlock(ref);
00386   Uint32 recNode   = refToNode(ref);
00387   Uint32 ourProcessor         = globalData.ownId;
00388   
00389   ::releaseSections(signal->header.m_noOfSections, signal->m_sectionPtr);
00390   
00391   signal->header.theLength = length;
00392   signal->header.theVerId_signalNumber = gsn;
00393   signal->header.theReceiversBlockNumber = recBlock;
00394   signal->header.m_noOfSections = noOfSections;
00395 
00396   Uint32 tSignalId = signal->header.theSignalId;
00397   Uint32 tFragInfo = signal->header.m_fragmentInfo;
00398   
00399   if ((length == 0) || (length + noOfSections > 25) || (recBlock == 0)) {
00400     signal_error(gsn, length, recBlock, __FILE__, __LINE__);
00401     return;
00402   }//if
00403 #ifdef VM_TRACE
00404   if(globalData.testOn){
00405     Uint16 proc = 
00406       (recNode == 0 ? globalData.ownId : recNode);
00407     signal->header.theSendersBlockRef = sendBRef;
00408     globalSignalLoggers.sendSignal(signal->header, 
00409                                    jobBuffer, 
00410                                    &signal->theData[0],
00411                                    proc,
00412                                    ptr, noOfSections);
00413   }
00414 #endif
00415   
00416   if(recNode == ourProcessor || recNode == 0) {
00417     signal->header.theSendersSignalId = tSignalId;
00418     signal->header.theSendersBlockRef = sendBRef;
00419 
00423     Ptr<SectionSegment> segptr[3];
00424     for(Uint32 i = 0; i<noOfSections; i++){
00425       ndbrequire(import(segptr[i], ptr[i].p, ptr[i].sz));
00426       signal->m_sectionPtr[i].i = segptr[i].i;
00427     }
00428     
00429     globalScheduler.execute(signal, jobBuffer, recBlock,
00430                             gsn);
00431     signal->header.m_noOfSections = 0;
00432     return;
00433   } else { 
00434     // send distributed Signal
00435     SignalHeader sh;
00436 
00437     Uint32 tTrace = signal->getTrace();
00438     Uint32 noOfSections = signal->header.m_noOfSections;
00439     
00440     sh.theVerId_signalNumber   = gsn;
00441     sh.theReceiversBlockNumber = recBlock;
00442     sh.theSendersBlockRef      = sendBnr;
00443     sh.theLength               = length;
00444     sh.theTrace                = tTrace;
00445     sh.theSignalId             = tSignalId;
00446     sh.m_noOfSections          = noOfSections;
00447     sh.m_fragmentInfo          = tFragInfo;
00448     
00449 #ifdef TRACE_DISTRIBUTED
00450     ndbout_c("send: %s(%d) to (%s, %d)",
00451              getSignalName(gsn), gsn, getBlockName(recBlock),
00452              recNode);
00453 #endif
00454 
00455     SendStatus ss = globalTransporterRegistry.prepareSend(&sh, jobBuffer, 
00456                                                           &signal->theData[0],
00457                                                           recNode, 
00458                                                           ptr);
00459     ndbrequire(ss == SEND_OK || ss == SEND_BLOCKED || ss == SEND_DISCONNECTED);
00460   }
00461 
00462   signal->header.m_noOfSections = 0;
00463   signal->header.m_fragmentInfo = 0;
00464   return;
00465 }

Here is the call graph for this function:

void SimulatedBlock::sendSignal	(	NodeReceiverGroup	rg,
		GlobalSignalNumber	gsn,
		Signal *	signal,
		Uint32	length,
		JobBufferLevel	jbuf
	)			const `[protected]`

Definition at line 271 of file SimulatedBlock.cpp.

References BitmaskPOD< size >::clear(), FastScheduler::execute(), BitmaskPOD< size >::find(), g_sectionSegmentPool, BitmaskPOD< size >::get(), getBlockName(), getSignalName(), Signal::getTrace(), globalData, globalScheduler, globalTransporterRegistry, Signal::header, BitmaskPOD< size >::isclear(), NodeReceiverGroup::m_block, SignalHeader::m_fragmentInfo, NodeReceiverGroup::m_nodes, SignalHeader::m_noOfSections, Signal::m_sectionPtr, ndbout_c(), ndbrequire, number(), GlobalData::ownId, TransporterRegistry::prepareSend(), reference(), release(), releaseSections(), SEND_BLOCKED, SEND_DISCONNECTED, SEND_OK, signal_error(), GlobalData::testOn, Signal::theData, SignalHeader::theLength, SignalHeader::theReceiversBlockNumber, SignalHeader::theSendersBlockRef, SignalHeader::theSendersSignalId, SignalHeader::theSignalId, SignalHeader::theTrace, and SignalHeader::theVerId_signalNumber.

00275                                                            {
00276 
00277   Uint32 noOfSections = signal->header.m_noOfSections;
00278   Uint32 tSignalId = signal->header.theSignalId;
00279   Uint32 tTrace = signal->getTrace();
00280   Uint32 tFragInf = signal->header.m_fragmentInfo;
00281   
00282   Uint32 ourProcessor = globalData.ownId;
00283   Uint32 recBlock = rg.m_block;
00284   
00285   signal->header.theLength = length;
00286   signal->header.theVerId_signalNumber = gsn;
00287   signal->header.theReceiversBlockNumber = recBlock;
00288   signal->header.theSendersSignalId = tSignalId;
00289   signal->header.theSendersBlockRef = reference();
00290   
00291   if ((length == 0) || (length + noOfSections > 25) || (recBlock == 0)) {
00292     signal_error(gsn, length, recBlock, __FILE__, __LINE__);
00293     return;
00294   }//if
00295 
00296   SignalHeader sh;
00297   
00298   sh.theVerId_signalNumber   = gsn;
00299   sh.theReceiversBlockNumber = recBlock;
00300   sh.theSendersBlockRef      = number();
00301   sh.theLength               = length;
00302   sh.theTrace                = tTrace;
00303   sh.theSignalId             = tSignalId;
00304   sh.m_noOfSections          = noOfSections;
00305   sh.m_fragmentInfo          = tFragInf;
00306 
00310   bool release = true;
00311   if(rg.m_nodes.get(0) || rg.m_nodes.get(ourProcessor)){
00312 #ifdef VM_TRACE
00313     if(globalData.testOn){
00314       globalSignalLoggers.sendSignal(signal->header, 
00315                                      jobBuffer, 
00316                                      &signal->theData[0],
00317                                      ourProcessor,
00318                                      signal->m_sectionPtr,
00319                                      signal->header.m_noOfSections);
00320     }
00321 #endif
00322     globalScheduler.execute(signal, jobBuffer, recBlock, gsn);
00323     
00324     rg.m_nodes.clear((Uint32)0);
00325     rg.m_nodes.clear(ourProcessor);
00326     release = false;
00327   }
00328 
00332   Uint32 recNode = 0;
00333   while(!rg.m_nodes.isclear()){
00334     recNode = rg.m_nodes.find(recNode + 1);
00335     rg.m_nodes.clear(recNode);
00336 #ifdef VM_TRACE
00337     if(globalData.testOn){
00338       globalSignalLoggers.sendSignal(signal->header, 
00339                                      jobBuffer, 
00340                                      &signal->theData[0],
00341                                      recNode,
00342                                      signal->m_sectionPtr,
00343                                      signal->header.m_noOfSections);
00344     }
00345 #endif
00346 
00347 #ifdef TRACE_DISTRIBUTED
00348     ndbout_c("send: %s(%d) to (%s, %d)",
00349              getSignalName(gsn), gsn, getBlockName(recBlock),
00350              recNode);
00351 #endif
00352 
00353     SendStatus ss = globalTransporterRegistry.prepareSend(&sh, jobBuffer, 
00354                                                           &signal->theData[0],
00355                                                           recNode,
00356                                                           g_sectionSegmentPool,
00357                                                           signal->m_sectionPtr);
00358     ndbrequire(ss == SEND_OK || ss == SEND_BLOCKED || ss == SEND_DISCONNECTED);
00359   }
00360   
00361   if(release){
00362     ::releaseSections(noOfSections, signal->m_sectionPtr);
00363   }
00364   
00365   signal->header.m_noOfSections = 0;
00366   signal->header.m_fragmentInfo = 0;
00367   
00368   return;
00369 }

Here is the call graph for this function:

void SimulatedBlock::sendSignal	(	BlockReference	ref,
		GlobalSignalNumber	gsn,
		Signal *	signal,
		Uint32	length,
		JobBufferLevel	jbuf
	)			const `[protected]`

Definition at line 190 of file SimulatedBlock.cpp.

References FastScheduler::execute(), g_sectionSegmentPool, getBlockName(), getSignalName(), Signal::getTrace(), globalData, globalScheduler, globalTransporterRegistry, Signal::header, SignalHeader::m_fragmentInfo, SignalHeader::m_noOfSections, Signal::m_sectionPtr, ndbout_c(), ndbrequire, number(), GlobalData::ownId, TransporterRegistry::prepareSend(), reference(), refToBlock(), refToNode(), releaseSections(), SEND_BLOCKED, SEND_DISCONNECTED, SEND_OK, signal_error(), GlobalData::testOn, Signal::theData, SignalHeader::theLength, SignalHeader::theReceiversBlockNumber, SignalHeader::theSendersBlockRef, SignalHeader::theSendersSignalId, SignalHeader::theSignalId, SignalHeader::theTrace, and SignalHeader::theVerId_signalNumber.

00194                                                            {
00195 
00196   BlockNumber sendBnr = number();
00197   BlockReference sendBRef = reference();
00198   
00199   Uint32 noOfSections = signal->header.m_noOfSections;
00200   Uint32 recBlock = refToBlock(ref);
00201   Uint32 recNode   = refToNode(ref);
00202   Uint32 ourProcessor         = globalData.ownId;
00203   
00204   signal->header.theLength = length;
00205   signal->header.theVerId_signalNumber = gsn;
00206   signal->header.theReceiversBlockNumber = recBlock;
00207   
00208   Uint32 tSignalId = signal->header.theSignalId;
00209   
00210   if ((length == 0) || (length + noOfSections > 25) || (recBlock == 0)) {
00211     signal_error(gsn, length, recBlock, __FILE__, __LINE__);
00212     return;
00213   }//if
00214 #ifdef VM_TRACE
00215   if(globalData.testOn){
00216     Uint16 proc = 
00217       (recNode == 0 ? globalData.ownId : recNode);
00218     signal->header.theSendersBlockRef = sendBRef;
00219     globalSignalLoggers.sendSignal(signal->header, 
00220                                    jobBuffer, 
00221                                    &signal->theData[0],
00222                                    proc,
00223                                    signal->m_sectionPtr,
00224                                    signal->header.m_noOfSections);
00225   }
00226 #endif
00227   
00228   if(recNode == ourProcessor || recNode == 0) {
00229     signal->header.theSendersSignalId = tSignalId;
00230     signal->header.theSendersBlockRef = sendBRef;
00231     signal->header.theLength = length;
00232     globalScheduler.execute(signal, jobBuffer, recBlock,
00233                             gsn);
00234     signal->header.m_noOfSections = 0;
00235     signal->header.m_fragmentInfo = 0;
00236     return;
00237   } else { 
00238     // send distributed Signal
00239     SignalHeader sh;
00240 
00241     Uint32 tTrace = signal->getTrace();
00242     
00243     sh.theVerId_signalNumber   = gsn;
00244     sh.theReceiversBlockNumber = recBlock;
00245     sh.theSendersBlockRef      = sendBnr;
00246     sh.theLength               = length;
00247     sh.theTrace                = tTrace;
00248     sh.theSignalId             = tSignalId;
00249     sh.m_noOfSections          = noOfSections;
00250     sh.m_fragmentInfo          = 0;
00251     
00252 #ifdef TRACE_DISTRIBUTED
00253     ndbout_c("send: %s(%d) to (%s, %d)",
00254              getSignalName(gsn), gsn, getBlockName(recBlock),
00255              recNode);
00256 #endif
00257     SendStatus ss = globalTransporterRegistry.prepareSend(&sh, jobBuffer, 
00258                                                           &signal->theData[0],
00259                                                           recNode, 
00260                                                           g_sectionSegmentPool,
00261                                                           signal->m_sectionPtr);
00262     
00263     ndbrequire(ss == SEND_OK || ss == SEND_BLOCKED || ss == SEND_DISCONNECTED);
00264     ::releaseSections(noOfSections, signal->m_sectionPtr);
00265     signal->header.m_noOfSections = 0;   
00266   }
00267   return;
00268 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::sendSignalWithDelay	(	BlockReference	ref,
		GlobalSignalNumber	gsn,
		Signal *	signal,
		Uint32	delayInMilliSeconds,
		Uint32	length
	)			const `[protected]`

Definition at line 572 of file SimulatedBlock.cpp.

References bnr_error(), globalData, globalTimeQueue, Signal::header, TimeQueue::insert(), SignalHeader::m_fragmentInfo, SignalHeader::m_noOfSections, Signal::m_sectionPtr, GlobalData::ownId, reference(), refToBlock(), GlobalData::testOn, Signal::theData, SignalHeader::theLength, SignalHeader::theReceiversBlockNumber, SignalHeader::theSendersBlockRef, SignalHeader::theSendersSignalId, SignalHeader::theSignalId, and SignalHeader::theVerId_signalNumber.

Referenced by Dbtc::checkAbortAllTimeout(), Ndbcntr::StopRecord::checkApiTimeout(), Dblqh::checkDropTab(), Backup::checkFile(), Dbdih::checkGcpStopLab(), Dbdih::checkLcpStart(), Ndbcntr::StopRecord::checkLqhTimeout_1(), Ndbcntr::StopRecord::checkLqhTimeout_2(), Backup::checkScan(), Dbdih::checkTcCounterLab(), Ndbcntr::StopRecord::checkTcTimeout(), Qmgr::cmInfoconf010Lab(), Ndbcntr::crSystab9Lab(), Pgman::do_cleanup_loop(), Pgman::do_lcp_loop(), Pgman::do_stats_loop(), Dblqh::execABORT(), Ndbcntr::execABORT_ALL_CONF(), Dbtc::execABORTCONF(), Dbtc::execABORTED(), Dblqh::execABORTREQ(), Backup::execBACKUP_FRAGMENT_REQ(), Dblqh::execCHECK_LCP_STOP(), Qmgr::execCM_INFOCONF(), Qmgr::execCM_REGREQ(), Ndbcntr::execCNTR_START_REQ(), Dblqh::execCOMMIT(), Dbtc::execCOMMITCONF(), Dblqh::execCOMMITREQ(), Dbtc::execCOMMITTED(), Dblqh::execCOMPLETE(), Dbtc::execCOMPLETECONF(), Dbtc::execCOMPLETED(), Dblqh::execCOMPLETEREQ(), Qmgr::execCONTINUEB(), Ndbfs::execCONTINUEB(), Ndbcntr::execCONTINUEB(), Lgman::execCONTINUEB(), Dbtc::execCONTINUEB(), Dblqh::execCONTINUEB(), Dbacc::execCONTINUEB(), Backup::execCONTINUEB(), Dbdih::execCOPY_GCICONF(), Suma::execDI_FCOUNTREF(), Dbtc::execDUMP_STATE_ORD(), Dbdih::execGCP_NODEFINISH(), Dbdih::execGCP_PREPARE(), Dblqh::execGCP_SAVEREQ(), Backup::execGET_TABINFO_CONF(), Suma::execGET_TABINFOREF(), Dbdict::execGET_TABINFOREQ(), Dbdih::execINCL_NODEREQ(), Dbdih::execLCP_COMPLETE_REP(), Dbdih::execMASTER_GCPREQ(), Dbtup::execNDB_STTOR(), Dbtc::execNDB_STTOR(), Dblqh::execNDB_STTOR(), Dbacc::execNDB_STTOR(), Dbdih::execNF_COMPLETEREP(), Ndbcntr::execREAD_NODESCONF(), Dblqh::execSCAN_NEXTREQ(), Backup::execSTART_BACKUP_REQ(), Dbdih::execSTART_PERMREF(), Ndbcntr::execSTOP_ME_CONF(), Ndbcntr::execSTOP_PERM_REF(), Ndbcntr::execSTOP_REQ(), Ndbfs::execSTTOR(), Dbdih::execTCGETOPSIZECONF(), Ndbcntr::execWAIT_GCP_CONF(), Lgman::flush_log(), Lgman::force_log_sync(), Backup::fragmentCompleted(), Dbdih::invalidateNodeLCP(), Backup::openFilesReply(), Lgman::read_undo_log(), Dbtc::removeMarkerForFailedAPI(), Dbdih::removeNodeFromTable(), Suma::resend_bucket(), Restore::restore_next(), Qmgr::runArbitThread(), Dbtc::sendAbortedAfterTimeout(), Dbdih::sendCreateFragReq(), Dbdih::sendEndTo(), Dbacc::sendScanHbRep(), Dbdih::sendStartTo(), Dbtc::sendtckeyconf(), Dbdih::sendUpdateTo(), Dbdict::setDictLockPoll(), Dbdih::startGcp(), Dbdih::startGcpLab(), Dbdih::startTakeOver(), Lgman::stop_run_undo_log(), Logfile_client::sync_lsn(), Qmgr::timerHandlingLab(), Dblqh::timeSup(), Dbdih::waitDropTabWritingToFile(), and Lgman::write_log_pages().

00576                                                          {
00577   
00578   BlockNumber bnr = refToBlock(ref);
00579   
00580   //BlockNumber sendBnr = number();
00581   BlockReference sendBRef = reference();
00582   
00583   if (bnr == 0) {
00584     bnr_error();
00585   }//if
00586   
00587   signal->header.theLength = length;
00588   signal->header.theSendersSignalId = signal->header.theSignalId;
00589   signal->header.theSendersBlockRef = sendBRef;
00590   signal->header.theVerId_signalNumber = gsn;
00591   signal->header.theReceiversBlockNumber = bnr;
00592 
00593 #ifdef VM_TRACE
00594   {
00595     if(globalData.testOn){
00596       globalSignalLoggers.sendSignalWithDelay(delayInMilliSeconds,
00597                                               signal->header,
00598                                               0,
00599                                               &signal->theData[0], 
00600                                               globalData.ownId,
00601                                               signal->m_sectionPtr,
00602                                               signal->header.m_noOfSections);
00603     }
00604   }
00605 #endif
00606   globalTimeQueue.insert(signal, bnr, gsn, delayInMilliSeconds);
00607 
00608   signal->header.m_noOfSections = 0;
00609   signal->header.m_fragmentInfo = 0;
00610   
00611   // befor 2nd parameter to globalTimeQueue.insert
00612   // (Priority)theSendSig[sigIndex].jobBuffer
00613 }

Here is the call graph for this function:

Here is the caller graph for this function:

NodeInfo & SimulatedBlock::setNodeInfo ( NodeId ) [protected]

Definition at line 1720 of file SimulatedBlock.cpp.

References globalData, GlobalData::m_nodeInfo, MAX_NODES, and ndbrequire.

Referenced by Qmgr::apiHbHandlingLab(), Qmgr::checkHeartbeat(), Qmgr::checkStartInterface(), Cmvmi::Cmvmi(), Qmgr::execAPI_REGREQ(), Qmgr::execCM_ADD(), Qmgr::execCM_HEARTBEAT(), Qmgr::execCM_NODEINFOCONF(), Qmgr::execCM_NODEINFOREQ(), Qmgr::execCM_REGREQ(), Qmgr::execCOMMIT_FAILREQ(), Cmvmi::execDISCONNECT_REP(), Cmvmi::execENABLE_COMORD(), Qmgr::failReport(), Qmgr::findNeighbours(), Qmgr::initData(), Qmgr::joinedCluster(), Qmgr::node_failed(), and Qmgr::sendApiFailReq().

01720                                          {
01721   ndbrequire(nodeId > 0 && nodeId < MAX_NODES);
01722   return globalData.m_nodeInfo[nodeId];
01723 }

Here is the caller graph for this function:

void SimulatedBlock::signal_error	(	Uint32	,
		Uint32	,
		Uint32	,
		const char *	,
		int
	)			const `[private]`

Definition at line 171 of file SimulatedBlock.cpp.

References ErrorReporter::handleError(), NDBD_EXIT_BLOCK_BNR_ZERO, and BaseString::snprintf().

Referenced by sendSignal().

00173 {
00174   char objRef[255];
00175   BaseString::snprintf(objRef, 255, "%s:%d", filename, lineno);
00176   char probData[255];
00177   BaseString::snprintf(probData, 255, 
00178            "Signal (GSN: %d, Length: %d, Rec Block No: %d)", 
00179            gsn, len, recBlockNo);
00180   
00181   ErrorReporter::handleError(NDBD_EXIT_BLOCK_BNR_ZERO,
00182                              probData, 
00183                              objRef);
00184 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SimulatedBlock::warningEvent	(	const char *	msg,
			...
	)			const `[protected]`

Definition at line 784 of file SimulatedBlock.cpp.

References buf, CMVMI, FastScheduler::execute(), FastScheduler::getVMSignals(), globalScheduler, GSN_EVENT_REP, Signal::header, JBB, memset, NDB_LE_WarningEvent, reference(), strlen(), SignalHeader::theLength, SignalHeader::theReceiversBlockNumber, SignalHeader::theSendersBlockRef, SignalHeader::theSignalId, SignalHeader::theTrace, SignalHeader::theVerId_signalNumber, and BaseString::vsnprintf().

Referenced by Lgman::alloc_logbuffer_memory(), Dbdict::alterIndex_recvReply(), Dbdict::buildIndex_recvReply(), Qmgr::checkStartInterface(), Qmgr::cmAddPrepare(), Dblqh::execACCKEYCONF(), Qmgr::execCM_ACKADD(), Dbdih::execDUMP_STATE_ORD(), Cmvmi::execSTTOR(), Dbdih::ndbStartReqLab(), Dbtc::sendAbortedAfterTimeout(), and Dbdih::systemRestartTakeOverLab().

00784                                                         {
00785   if(msg == 0)
00786     return;
00787   
00788   Uint32 theData[25];
00789   theData[0] = NDB_LE_WarningEvent;
00790   char * buf = (char *)&(theData[1]);
00791   
00792   va_list ap;
00793   va_start(ap, msg);
00794   BaseString::vsnprintf(buf, 96, msg, ap); // 96 = 100 - 4
00795   va_end(ap);
00796   
00797   int len = strlen(buf) + 1;
00798   if(len > 96){
00799     len = 96;
00800     buf[95] = 0;
00801   }
00802 
00806   SignalHeader sh;
00807   memset(&sh, 0, sizeof(SignalHeader));
00808   
00809   const Signal * signal = globalScheduler.getVMSignals();
00810   Uint32 tTrace = signal->header.theTrace;
00811   Uint32 tSignalId = signal->header.theSignalId;
00812   
00813   sh.theVerId_signalNumber   = GSN_EVENT_REP;
00814   sh.theReceiversBlockNumber = CMVMI;
00815   sh.theSendersBlockRef      = reference();
00816   sh.theTrace                = tTrace;
00817   sh.theSignalId             = tSignalId;
00818   sh.theLength               = ((len+3)/4)+1;
00819 
00820   Uint32 secPtrI[3]; // Dummy
00821   globalScheduler.execute(&sh, JBB, theData, secPtrI);
00822 }

Here is the call graph for this function:

Here is the caller graph for this function:

Uint32 SimulatedBlock::xfrm_attr	(	Uint32	attrDesc,
		CHARSET_INFO *	cs,
		const Uint32 *	src,
		Uint32 &	srcPos,
		Uint32 *	dst,
		Uint32 &	dstPos,
		Uint32	dstSize
	)			const `[protected]`

Definition at line 1915 of file SimulatedBlock.cpp.

References NdbSqlUtil::get_var_length(), AttributeDescriptor::getArrayType(), AttributeDescriptor::getSizeInBytes(), AttributeDescriptor::getType(), jam, memcpy, n, NDB_ARRAYTYPE_FIXED, NDB_ARRAYTYPE_MEDIUM_VAR, NDB_ARRAYTYPE_SHORT_VAR, ndbout_c(), ndbrequire, NULL, ok(), NdbSqlUtil::strnxfrm_bug7284(), charset_info_st::strxfrm_multiply, and unlikely.

Referenced by Dbtup::checkUpdateOfPrimaryKey(), and xfrm_key().

01918 {
01919   Uint32 array = 
01920     AttributeDescriptor::getArrayType(attrDesc);
01921   Uint32 srcBytes = 
01922     AttributeDescriptor::getSizeInBytes(attrDesc);
01923 
01924   Uint32 srcWords = ~0;
01925   Uint32 dstWords = ~0;
01926   uchar* dstPtr = (uchar*)&dst[dstPos];
01927   const uchar* srcPtr = (const uchar*)&src[srcPos];
01928   
01929   if (cs == NULL)
01930   {
01931     jam();
01932     Uint32 len;
01933     switch(array){
01934     case NDB_ARRAYTYPE_SHORT_VAR:
01935       len = 1 + srcPtr[0];
01936       break;
01937     case NDB_ARRAYTYPE_MEDIUM_VAR:
01938       len = 2 + srcPtr[0] + (srcPtr[1] << 8);
01939       break;
01940 #ifndef VM_TRACE
01941     default:
01942 #endif
01943     case NDB_ARRAYTYPE_FIXED:
01944       len = srcBytes;
01945     }
01946     srcWords = (len + 3) >> 2;
01947     dstWords = srcWords;
01948     memcpy(dstPtr, srcPtr, dstWords << 2);
01949     
01950     if (0)
01951     {
01952       ndbout_c("srcPos: %d dstPos: %d len: %d srcWords: %d dstWords: %d",
01953                srcPos, dstPos, len, srcWords, dstWords);
01954       
01955       for(Uint32 i = 0; i<srcWords; i++)
01956         printf("%.8x ", src[srcPos + i]);
01957       printf("\n");
01958     }
01959   } 
01960   else
01961   {
01962     jam();
01963     Uint32 typeId =
01964       AttributeDescriptor::getType(attrDesc);
01965     Uint32 lb, len;
01966     bool ok = NdbSqlUtil::get_var_length(typeId, srcPtr, srcBytes, lb, len);
01967     if (unlikely(!ok))
01968       return 0;
01969     Uint32 xmul = cs->strxfrm_multiply;
01970     if (xmul == 0)
01971       xmul = 1;
01972     /*
01973      * Varchar end-spaces are ignored in comparisons.  To get same hash
01974      * we blank-pad to maximum length via strnxfrm.
01975      */
01976     Uint32 dstLen = xmul * (srcBytes - lb);
01977     ndbrequire(dstLen <= ((dstSize - dstPos) << 2));
01978     int n = NdbSqlUtil::strnxfrm_bug7284(cs, dstPtr, dstLen, srcPtr + lb, len);
01979     if (unlikely(n == -1))
01980       return 0;
01981     while ((n & 3) != 0) 
01982     {
01983       dstPtr[n++] = 0;
01984     }
01985     dstWords = (n >> 2);
01986     srcWords = (lb + len + 3) >> 2; 
01987   }
01988 
01989   dstPos += dstWords;
01990   srcPos += srcWords;
01991   return dstWords;
01992 }

Here is the call graph for this function:

Here is the caller graph for this function:

Uint32 SimulatedBlock::xfrm_key	(	Uint32	tab,
		const Uint32 *	src,
		Uint32 *	dst,
		Uint32	dstSize,
		Uint32	keyPartLen[MAX_ATTRIBUTES_IN_INDEX]
	)			const `[protected]`

Returns:: length

Definition at line 1882 of file SimulatedBlock.cpp.

References KeyDescriptor::KeyAttr::attributeDescriptor, KeyDescriptor::KeyAttr::charsetInfo, g_key_descriptor_pool, KeyDescriptor::keyAttr, KeyDescriptor::noOfKeyAttr, unlikely, and xfrm_attr().

Referenced by Dblqh::calculateHash(), Restore::calulate_hash(), Dbtc::handle_special_hash(), Dblqh::readPrimaryKeys(), and Dbacc::xfrmKeyData().

01885 {
01886   const KeyDescriptor * desc = g_key_descriptor_pool.getPtr(tab);
01887   const Uint32 noOfKeyAttr = desc->noOfKeyAttr;
01888 
01889   Uint32 i = 0;
01890   Uint32 srcPos = 0;
01891   Uint32 dstPos = 0;
01892   while (i < noOfKeyAttr) 
01893   {
01894     const KeyDescriptor::KeyAttr& keyAttr = desc->keyAttr[i];
01895     Uint32 dstWords =
01896       xfrm_attr(keyAttr.attributeDescriptor, keyAttr.charsetInfo,
01897                 src, srcPos, dst, dstPos, dstSize);
01898     keyPartLen[i++] = dstWords;
01899     if (unlikely(dstWords == 0))
01900       return 0;
01901   }
01902 
01903   if (0)
01904   {
01905     for(Uint32 i = 0; i<dstPos; i++)
01906     {
01907       printf("%.8x ", dst[i]);
01908     }
01909     printf("\n");
01910   }
01911   return dstPos;
01912 }

Here is the call graph for this function:

Here is the caller graph for this function:

The world's most popular open source database

SimulatedBlock Class Reference

Public Types

Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Friends

Classes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function