开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
SimulatedBlock.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：48k
源码类别：

MySQL数据库

开发平台：

Visual C++

SimulatedBlock.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #include <ndb_global.h>
  19. #include "SimulatedBlock.hpp"
  20. #include <NdbOut.hpp>
  21. #include <GlobalData.hpp>
  22. #include <Emulator.hpp>
  23. #include <ErrorHandlingMacros.hpp>
  24. #include <TimeQueue.hpp>
  25. #include <TransporterRegistry.hpp>
  26. #include <SignalLoggerManager.hpp>
  27. #include <FastScheduler.hpp>
  28. #include <NdbMem.h>
  29. #include <signaldata/EventReport.hpp>
  30. #include <signaldata/ContinueFragmented.hpp>
  31. #include <signaldata/NodeStateSignalData.hpp>
  32. #include <signaldata/FsRef.hpp>
  33. #include <DebuggerNames.hpp>
  34. #include "LongSignal.hpp"
  36. #include <Properties.hpp>
  37. #include "Configuration.hpp"
  39. #define ljamEntry() jamEntryLine(30000 + __LINE__)
  40. #define ljam() jamLine(30000 + __LINE__)
  42. //
  43. // Constructor, Destructor
  44. //
  45. SimulatedBlock::SimulatedBlock(BlockNumber blockNumber,
  46.        const class Configuration & conf) 
  47.   : theNodeId(globalData.ownId),
  48.     theNumber(blockNumber),
  49.     theReference(numberToRef(blockNumber, globalData.ownId)),
  50.     theConfiguration(conf),
  51.     c_fragmentInfoHash(c_fragmentInfoPool),
  52.     c_linearFragmentSendList(c_fragmentSendPool),
  53.     c_segmentedFragmentSendList(c_fragmentSendPool),
  54.     c_mutexMgr(* this),
  55.     c_counterMgr(* this),
  56.     c_ptrMetaDataCommon(0)
  57. {
  58.   NewVarRef = 0;
  59.   
  60.   globalData.setBlock(blockNumber, this);
  61.   c_fragmentIdCounter = 1;
  62.   c_fragSenderRunning = false;
  63.   
  64.   Properties tmp;
  65.   const Properties * p = &tmp;
  66.   ndbrequire(p != 0);
  68.   Uint32 count = 10;
  69.   char buf[255];
  71.   count = 10;
  72.   BaseString::snprintf(buf, 255, "%s.FragmentSendPool", getBlockName(blockNumber));
  73.   if(!p->get(buf, &count))
  74.     p->get("FragmentSendPool", &count);
  75.   c_fragmentSendPool.setSize(count);
  77.   count = 10;
  78.   BaseString::snprintf(buf, 255, "%s.FragmentInfoPool", getBlockName(blockNumber));
  79.   if(!p->get(buf, &count))
  80.     p->get("FragmentInfoPool", &count);
  81.   c_fragmentInfoPool.setSize(count);
  83.   count = 10;
  84.   BaseString::snprintf(buf, 255, "%s.FragmentInfoHash", getBlockName(blockNumber));
  85.   if(!p->get(buf, &count))
  86.     p->get("FragmentInfoHash", &count);
  87.   c_fragmentInfoHash.setSize(count);
  89.   count = 5;
  90.   BaseString::snprintf(buf, 255, "%s.ActiveMutexes", getBlockName(blockNumber));
  91.   if(!p->get(buf, &count))
  92.     p->get("ActiveMutexes", &count);
  93.   c_mutexMgr.setSize(count);
  94.   
  95.   c_counterMgr.setSize(5);
  96.   
  97. #ifdef VM_TRACE_TIME
  98.   clearTimes();
  99. #endif
  101.   for(GlobalSignalNumber i = 0; i<=MAX_GSN; i++)
  102.     theExecArray[i] = 0;
  104.   installSimulatedBlockFunctions();
  105.   UpgradeStartup::installEXEC(this);
  107.   CLEAR_ERROR_INSERT_VALUE;
  109. #ifdef VM_TRACE
  110.   m_global_variables = new Ptr<void> * [1];
  111.   m_global_variables[0] = 0;
  112. #endif
  113. }
  115. SimulatedBlock::~SimulatedBlock()
  116. {
  117.   freeBat();
  118. #ifdef VM_TRACE_TIME
  119.   printTimes(stdout);
  120. #endif
  122. #ifdef VM_TRACE
  123.   delete [] m_global_variables;
  124. #endif
  125. }
  127. void 
  128. SimulatedBlock::installSimulatedBlockFunctions(){
  129.   ExecFunction * a = theExecArray;
  130.   a[GSN_NODE_STATE_REP] = &SimulatedBlock::execNODE_STATE_REP;
  131.   a[GSN_CHANGE_NODE_STATE_REQ] = &SimulatedBlock::execCHANGE_NODE_STATE_REQ;
  132.   a[GSN_NDB_TAMPER] = &SimulatedBlock::execNDB_TAMPER;
  133.   a[GSN_SIGNAL_DROPPED_REP] = &SimulatedBlock::execSIGNAL_DROPPED_REP;
  134.   a[GSN_CONTINUE_FRAGMENTED]= &SimulatedBlock::execCONTINUE_FRAGMENTED;
  135.   a[GSN_UTIL_CREATE_LOCK_REF]   = &SimulatedBlock::execUTIL_CREATE_LOCK_REF;
  136.   a[GSN_UTIL_CREATE_LOCK_CONF]  = &SimulatedBlock::execUTIL_CREATE_LOCK_CONF;
  137.   a[GSN_UTIL_DESTROY_LOCK_REF]  = &SimulatedBlock::execUTIL_DESTORY_LOCK_REF;
  138.   a[GSN_UTIL_DESTROY_LOCK_CONF] = &SimulatedBlock::execUTIL_DESTORY_LOCK_CONF;
  139.   a[GSN_UTIL_LOCK_REF]    = &SimulatedBlock::execUTIL_LOCK_REF;
  140.   a[GSN_UTIL_LOCK_CONF]   = &SimulatedBlock::execUTIL_LOCK_CONF;
  141.   a[GSN_UTIL_UNLOCK_REF]  = &SimulatedBlock::execUTIL_UNLOCK_REF;
  142.   a[GSN_UTIL_UNLOCK_CONF] = &SimulatedBlock::execUTIL_UNLOCK_CONF;
  143.   a[GSN_READ_CONFIG_REQ] = &SimulatedBlock::execREAD_CONFIG_REQ;
  144.   a[GSN_FSOPENREF]    = &SimulatedBlock::execFSOPENREF;
  145.   a[GSN_FSCLOSEREF]   = &SimulatedBlock::execFSCLOSEREF;
  146.   a[GSN_FSWRITEREF]   = &SimulatedBlock::execFSWRITEREF;
  147.   a[GSN_FSREADREF]    = &SimulatedBlock::execFSREADREF;
  148.   a[GSN_FSREMOVEREF]  = &SimulatedBlock::execFSREMOVEREF;
  149.   a[GSN_FSSYNCREF]    = &SimulatedBlock::execFSSYNCREF;
  150.   a[GSN_FSAPPENDREF]  = &SimulatedBlock::execFSAPPENDREF;
  151. }
  153. void
  154. SimulatedBlock::addRecSignalImpl(GlobalSignalNumber gsn, 
  155.  ExecFunction f, bool force){
  156.   if(gsn > MAX_GSN || (!force &&  theExecArray[gsn] != 0)){
  157.     char errorMsg[255];
  158.     BaseString::snprintf(errorMsg, 255, 
  159.        "Illeagal signal (%d %d)", gsn, MAX_GSN); 
  160.     ERROR_SET(fatal, ERR_ERROR_PRGERR, errorMsg, errorMsg);
  161.   }
  162.   theExecArray[gsn] = f;
  163. }
  165. void
  166. SimulatedBlock::signal_error(Uint32 gsn, Uint32 len, Uint32 recBlockNo, 
  167.      const char* filename, int lineno) const 
  168. {
  169.   char objRef[255];
  170.   BaseString::snprintf(objRef, 255, "%s:%d", filename, lineno);
  171.   char probData[255];
  172.   BaseString::snprintf(probData, 255, 
  173.    "Signal (GSN: %d, Length: %d, Rec Block No: %d)", 
  174.    gsn, len, recBlockNo);
  175.   
  176.   ErrorReporter::handleError(ecError, 
  177.      BLOCK_ERROR_BNR_ZERO,
  178.      probData, 
  179.      objRef);
  180. }
  183. extern class SectionSegmentPool g_sectionSegmentPool;
  185. void 
  186. SimulatedBlock::sendSignal(BlockReference ref, 
  187.    GlobalSignalNumber gsn, 
  188.    Signal* signal, 
  189.    Uint32 length, 
  190.    JobBufferLevel jobBuffer) const {
  192.   BlockNumber sendBnr = number();
  193.   BlockReference sendBRef = reference();
  194.   
  195.   Uint32 noOfSections = signal->header.m_noOfSections;
  196.   Uint32 recBlock = refToBlock(ref);
  197.   Uint32 recNode   = refToNode(ref);
  198.   Uint32 ourProcessor         = globalData.ownId;
  199.   
  200.   signal->header.theLength = length;
  201.   signal->header.theVerId_signalNumber = gsn;
  202.   signal->header.theReceiversBlockNumber = recBlock;
  203.   
  204.   Uint32 tSignalId = signal->header.theSignalId;
  205.   
  206.   if ((length == 0) || (length + noOfSections > 25) || (recBlock == 0)) {
  207.     signal_error(gsn, length, recBlock, __FILE__, __LINE__);
  208.     return;
  209.   }//if
  210. #ifdef VM_TRACE
  211.   if(globalData.testOn){
  212.     Uint16 proc = 
  213.       (recNode == 0 ? globalData.ownId : recNode);
  214.     signal->header.theSendersBlockRef = sendBRef;
  215.     globalSignalLoggers.sendSignal(signal->header, 
  216.    jobBuffer, 
  217.    &signal->theData[0],
  218.    proc,
  219.                                    signal->m_sectionPtr,
  220.                                    signal->header.m_noOfSections);
  221.   }
  222. #endif
  223.   
  224.   if(recNode == ourProcessor || recNode == 0) {
  225.     signal->header.theSendersSignalId = tSignalId;
  226.     signal->header.theSendersBlockRef = sendBRef;
  227.     signal->header.theLength = length;
  228.     globalScheduler.execute(signal, jobBuffer, recBlock,
  229.     gsn);
  230.     signal->header.m_noOfSections = 0;
  231.     signal->header.m_fragmentInfo = 0;
  232.     return;
  233.   } else { 
  234.     // send distributed Signal
  235.     SignalHeader sh;
  237.     Uint32 tTrace = signal->getTrace();
  238.     
  239.     sh.theVerId_signalNumber   = gsn;
  240.     sh.theReceiversBlockNumber = recBlock;
  241.     sh.theSendersBlockRef      = sendBnr;
  242.     sh.theLength               = length;
  243.     sh.theTrace                = tTrace;
  244.     sh.theSignalId             = tSignalId;
  245.     sh.m_noOfSections          = noOfSections;
  246.     sh.m_fragmentInfo          = 0;
  247.     
  248. #ifdef TRACE_DISTRIBUTED
  249.     ndbout_c("send: %s(%d) to (%s, %d)",
  250.      getSignalName(gsn), gsn, getBlockName(recBlock),
  251.      recNode);
  252. #endif
  253.     SendStatus ss = globalTransporterRegistry.prepareSend(&sh, jobBuffer, 
  254.   &signal->theData[0],
  255.   recNode, 
  256.   g_sectionSegmentPool,
  257.   signal->m_sectionPtr);
  258.     
  259.     ndbrequire(ss == SEND_OK || ss == SEND_BLOCKED || ss == SEND_DISCONNECTED);
  260.     ::releaseSections(noOfSections, signal->m_sectionPtr);
  261.     signal->header.m_noOfSections = 0;   
  262.   }
  263.   return;
  264. }
  266. void 
  267. SimulatedBlock::sendSignal(NodeReceiverGroup rg, 
  268.    GlobalSignalNumber gsn, 
  269.    Signal* signal, 
  270.    Uint32 length, 
  271.    JobBufferLevel jobBuffer) const {
  273.   Uint32 noOfSections = signal->header.m_noOfSections;
  274.   Uint32 tSignalId = signal->header.theSignalId;
  275.   Uint32 tTrace = signal->getTrace();
  276.   Uint32 tFragInf = signal->header.m_fragmentInfo;
  277.   
  278.   Uint32 ourProcessor = globalData.ownId;
  279.   Uint32 recBlock = rg.m_block;
  280.   
  281.   signal->header.theLength = length;
  282.   signal->header.theVerId_signalNumber = gsn;
  283.   signal->header.theReceiversBlockNumber = recBlock;
  284.   signal->header.theSendersSignalId = tSignalId;
  285.   signal->header.theSendersBlockRef = reference();
  286.   
  287.   if ((length == 0) || (length + noOfSections > 25) || (recBlock == 0)) {
  288.     signal_error(gsn, length, recBlock, __FILE__, __LINE__);
  289.     return;
  290.   }//if
  292.   SignalHeader sh;
  293.   
  294.   sh.theVerId_signalNumber   = gsn;
  295.   sh.theReceiversBlockNumber = recBlock;
  296.   sh.theSendersBlockRef      = number();
  297.   sh.theLength               = length;
  298.   sh.theTrace                = tTrace;
  299.   sh.theSignalId             = tSignalId;
  300.   sh.m_noOfSections          = noOfSections;
  301.   sh.m_fragmentInfo          = tFragInf;
  303.   /**
  304.    * Check own node
  305.    */
  306.   bool release = true;
  307.   if(rg.m_nodes.get(0) || rg.m_nodes.get(ourProcessor)){
  308. #ifdef VM_TRACE
  309.     if(globalData.testOn){
  310.       globalSignalLoggers.sendSignal(signal->header, 
  311.      jobBuffer, 
  312.      &signal->theData[0],
  313.      ourProcessor,
  314.                                      signal->m_sectionPtr,
  315.                                      signal->header.m_noOfSections);
  316.     }
  317. #endif
  318.     globalScheduler.execute(signal, jobBuffer, recBlock, gsn);
  319.     
  320.     rg.m_nodes.clear((Uint32)0);
  321.     rg.m_nodes.clear(ourProcessor);
  322.     release = false;
  323.   }
  325.   /**
  326.    * Do the big loop
  327.    */
  328.   Uint32 recNode = 0;
  329.   while(!rg.m_nodes.isclear()){
  330.     recNode = rg.m_nodes.find(recNode + 1);
  331.     rg.m_nodes.clear(recNode);
  332. #ifdef VM_TRACE
  333.     if(globalData.testOn){
  334.       globalSignalLoggers.sendSignal(signal->header, 
  335.      jobBuffer, 
  336.      &signal->theData[0],
  337.      recNode,
  338.                                      signal->m_sectionPtr,
  339.                                      signal->header.m_noOfSections);
  340.     }
  341. #endif
  343. #ifdef TRACE_DISTRIBUTED
  344.     ndbout_c("send: %s(%d) to (%s, %d)",
  345.      getSignalName(gsn), gsn, getBlockName(recBlock),
  346.      recNode);
  347. #endif
  349.     SendStatus ss = globalTransporterRegistry.prepareSend(&sh, jobBuffer, 
  350.   &signal->theData[0],
  351.   recNode,
  352.   g_sectionSegmentPool,
  353.   signal->m_sectionPtr);
  354.     ndbrequire(ss == SEND_OK || ss == SEND_BLOCKED || ss == SEND_DISCONNECTED);
  355.   }
  356.   
  357.   if(release){
  358.     ::releaseSections(noOfSections, signal->m_sectionPtr);
  359.   }
  360.   
  361.   signal->header.m_noOfSections = 0;
  362.   signal->header.m_fragmentInfo = 0;
  363.   
  364.   return;
  365. }
  367. bool import(Ptr<SectionSegment> & first, const Uint32 * src, Uint32 len);
  369. void 
  370. SimulatedBlock::sendSignal(BlockReference ref, 
  371.    GlobalSignalNumber gsn, 
  372.    Signal* signal, 
  373.    Uint32 length, 
  374.    JobBufferLevel jobBuffer,
  375.    LinearSectionPtr ptr[3],
  376.    Uint32 noOfSections) const {
  377.   
  378.   BlockNumber sendBnr = number();
  379.   BlockReference sendBRef = reference();
  380.   
  381.   Uint32 recBlock = refToBlock(ref);
  382.   Uint32 recNode   = refToNode(ref);
  383.   Uint32 ourProcessor         = globalData.ownId;
  384.   
  385.   ::releaseSections(signal->header.m_noOfSections, signal->m_sectionPtr);
  386.   
  387.   signal->header.theLength = length;
  388.   signal->header.theVerId_signalNumber = gsn;
  389.   signal->header.theReceiversBlockNumber = recBlock;
  390.   signal->header.m_noOfSections = noOfSections;
  392.   Uint32 tSignalId = signal->header.theSignalId;
  393.   Uint32 tFragInfo = signal->header.m_fragmentInfo;
  394.   
  395.   if ((length == 0) || (length + noOfSections > 25) || (recBlock == 0)) {
  396.     signal_error(gsn, length, recBlock, __FILE__, __LINE__);
  397.     return;
  398.   }//if
  399. #ifdef VM_TRACE
  400.   if(globalData.testOn){
  401.     Uint16 proc = 
  402.       (recNode == 0 ? globalData.ownId : recNode);
  403.     signal->header.theSendersBlockRef = sendBRef;
  404.     globalSignalLoggers.sendSignal(signal->header, 
  405.    jobBuffer, 
  406.    &signal->theData[0],
  407.    proc,
  408.                                    ptr, noOfSections);
  409.   }
  410. #endif
  411.   
  412.   if(recNode == ourProcessor || recNode == 0) {
  413.     signal->header.theSendersSignalId = tSignalId;
  414.     signal->header.theSendersBlockRef = sendBRef;
  416.     /**
  417.      * We have to copy the data
  418.      */
  419.     Ptr<SectionSegment> segptr[3];
  420.     for(Uint32 i = 0; i<noOfSections; i++){
  421.       ndbrequire(import(segptr[i], ptr[i].p, ptr[i].sz));
  422.       signal->m_sectionPtr[i].i = segptr[i].i;
  423.     }
  424.     
  425.     globalScheduler.execute(signal, jobBuffer, recBlock,
  426.     gsn);
  427.     signal->header.m_noOfSections = 0;
  428.     return;
  429.   } else { 
  430.     // send distributed Signal
  431.     SignalHeader sh;
  433.     Uint32 tTrace = signal->getTrace();
  434.     Uint32 noOfSections = signal->header.m_noOfSections;
  435.     
  436.     sh.theVerId_signalNumber   = gsn;
  437.     sh.theReceiversBlockNumber = recBlock;
  438.     sh.theSendersBlockRef      = sendBnr;
  439.     sh.theLength               = length;
  440.     sh.theTrace                = tTrace;
  441.     sh.theSignalId             = tSignalId;
  442.     sh.m_noOfSections          = noOfSections;
  443.     sh.m_fragmentInfo          = tFragInfo;
  444.     
  445. #ifdef TRACE_DISTRIBUTED
  446.     ndbout_c("send: %s(%d) to (%s, %d)",
  447.      getSignalName(gsn), gsn, getBlockName(recBlock),
  448.      recNode);
  449. #endif
  451.     SendStatus ss = globalTransporterRegistry.prepareSend(&sh, jobBuffer, 
  452.   &signal->theData[0],
  453.   recNode, 
  454.   ptr);
  455.     ndbrequire(ss == SEND_OK || ss == SEND_BLOCKED || ss == SEND_DISCONNECTED);
  456.   }
  458.   signal->header.m_noOfSections = 0;
  459.   signal->header.m_fragmentInfo = 0;
  460.   return;
  461. }
  463. void 
  464. SimulatedBlock::sendSignal(NodeReceiverGroup rg, 
  465.    GlobalSignalNumber gsn, 
  466.    Signal* signal, 
  467.    Uint32 length, 
  468.    JobBufferLevel jobBuffer,
  469.    LinearSectionPtr ptr[3],
  470.    Uint32 noOfSections) const {
  471.   
  472.   Uint32 tSignalId = signal->header.theSignalId;
  473.   Uint32 tTrace    = signal->getTrace();
  474.   Uint32 tFragInfo = signal->header.m_fragmentInfo;
  475.   
  476.   Uint32 ourProcessor = globalData.ownId;
  477.   Uint32 recBlock = rg.m_block;
  478.   
  479.   ::releaseSections(signal->header.m_noOfSections, signal->m_sectionPtr);
  480.   
  481.   signal->header.theLength = length;
  482.   signal->header.theVerId_signalNumber = gsn;
  483.   signal->header.theReceiversBlockNumber = recBlock;
  484.   signal->header.theSendersSignalId = tSignalId;
  485.   signal->header.theSendersBlockRef = reference();
  486.   signal->header.m_noOfSections = noOfSections;
  487.   
  488.   if ((length == 0) || (length + noOfSections > 25) || (recBlock == 0)) {
  489.     signal_error(gsn, length, recBlock, __FILE__, __LINE__);
  490.     return;
  491.   }//if
  493.   SignalHeader sh;
  494.   sh.theVerId_signalNumber   = gsn;
  495.   sh.theReceiversBlockNumber = recBlock;
  496.   sh.theSendersBlockRef      = number();
  497.   sh.theLength               = length;
  498.   sh.theTrace                = tTrace;
  499.   sh.theSignalId             = tSignalId;
  500.   sh.m_noOfSections          = noOfSections;
  501.   sh.m_fragmentInfo          = tFragInfo;
  503.   /**
  504.    * Check own node
  505.    */
  506.   if(rg.m_nodes.get(0) || rg.m_nodes.get(ourProcessor)){
  507. #ifdef VM_TRACE
  508.     if(globalData.testOn){
  509.       globalSignalLoggers.sendSignal(signal->header, 
  510.      jobBuffer, 
  511.      &signal->theData[0],
  512.      ourProcessor,
  513.                                      ptr, noOfSections);
  514.     }
  515. #endif
  516.     /**
  517.      * We have to copy the data
  518.      */
  519.     Ptr<SectionSegment> segptr[3];
  520.     for(Uint32 i = 0; i<noOfSections; i++){
  521.       ndbrequire(import(segptr[i], ptr[i].p, ptr[i].sz));
  522.       signal->m_sectionPtr[i].i = segptr[i].i;
  523.     }
  524.     globalScheduler.execute(signal, jobBuffer, recBlock, gsn);
  525.     
  526.     rg.m_nodes.clear((Uint32)0);
  527.     rg.m_nodes.clear(ourProcessor);
  528.   }
  529.   
  530.   /**
  531.    * Do the big loop
  532.    */
  533.   Uint32 recNode = 0;
  534.   while(!rg.m_nodes.isclear()){
  535.     recNode = rg.m_nodes.find(recNode + 1);
  536.     rg.m_nodes.clear(recNode);
  537.     
  538. #ifdef VM_TRACE
  539.     if(globalData.testOn){
  540.       globalSignalLoggers.sendSignal(signal->header, 
  541.      jobBuffer, 
  542.      &signal->theData[0],
  543.      recNode,
  544.                                      ptr, noOfSections);
  545.     }
  546. #endif
  547.     
  548. #ifdef TRACE_DISTRIBUTED
  549.     ndbout_c("send: %s(%d) to (%s, %d)",
  550.      getSignalName(gsn), gsn, getBlockName(recBlock),
  551.      recNode);
  552. #endif
  554.     SendStatus ss = globalTransporterRegistry.prepareSend(&sh, jobBuffer, 
  555.   &signal->theData[0],
  556.   recNode,
  557.   ptr);
  558.     ndbrequire(ss == SEND_OK || ss == SEND_BLOCKED || ss == SEND_DISCONNECTED);
  559.   }
  560.   
  561.   signal->header.m_noOfSections = 0;
  562.   signal->header.m_fragmentInfo = 0;
  563.   
  564.   return;
  565. }
  567. void
  568. SimulatedBlock::sendSignalWithDelay(BlockReference ref, 
  569.     GlobalSignalNumber gsn,
  570.     Signal* signal,
  571.     Uint32 delayInMilliSeconds, 
  572.     Uint32 length) const {
  573.   
  574.   BlockNumber bnr = refToBlock(ref);
  575.   
  576.   //BlockNumber sendBnr = number();
  577.   BlockReference sendBRef = reference();
  578.   
  579.   if (bnr == 0) {
  580.     bnr_error();
  581.   }//if
  582.   
  583.   signal->header.theLength = length;
  584.   signal->header.theSendersSignalId = signal->header.theSignalId;
  585.   signal->header.theSendersBlockRef = sendBRef;
  586.   signal->header.theVerId_signalNumber = gsn;
  587.   signal->header.theReceiversBlockNumber = bnr;
  589. #ifdef VM_TRACE
  590.   {
  591.     if(globalData.testOn){
  592.       globalSignalLoggers.sendSignalWithDelay(delayInMilliSeconds,
  593.       signal->header,
  594.       0,
  595.       &signal->theData[0], 
  596.       globalData.ownId,
  597.                                               signal->m_sectionPtr,
  598.                                               signal->header.m_noOfSections);
  599.     }
  600.   }
  601. #endif
  602.   globalTimeQueue.insert(signal, bnr, gsn, delayInMilliSeconds);
  604.   signal->header.m_noOfSections = 0;
  605.   signal->header.m_fragmentInfo = 0;
  606.   
  607.   // befor 2nd parameter to globalTimeQueue.insert
  608.   // (Priority)theSendSig[sigIndex].jobBuffer
  609. }
  611. void
  612. SimulatedBlock::releaseSections(Signal* signal){
  613.   ::releaseSections(signal->header.m_noOfSections, signal->m_sectionPtr);
  614.   signal->header.m_noOfSections = 0;
  615. }
  617. class SectionSegmentPool& 
  618. SimulatedBlock::getSectionSegmentPool(){
  619.   return g_sectionSegmentPool;
  620. }
  622. NewVARIABLE *
  623. SimulatedBlock::allocateBat(int batSize){
  624.   NewVARIABLE* bat = NewVarRef;
  625.   bat = (NewVARIABLE*)realloc(bat, batSize * sizeof(NewVARIABLE));
  626.   NewVarRef = bat;
  627.   theBATSize = batSize;
  628.   return bat;
  629. }
  631. void
  632. SimulatedBlock::freeBat(){
  633.   if(NewVarRef != 0){
  634.     free(NewVarRef);
  635.     NewVarRef = 0;
  636.   }
  637. }
  639. const NewVARIABLE *
  640. SimulatedBlock::getBat(Uint16 blockNo){
  641.   SimulatedBlock * sb = globalData.getBlock(blockNo);
  642.   if(sb == 0)
  643.     return 0;
  644.   return sb->NewVarRef;
  645. }
  647. Uint16
  648. SimulatedBlock::getBatSize(Uint16 blockNo){
  649.   SimulatedBlock * sb = globalData.getBlock(blockNo);
  650.   if(sb == 0)
  651.     return 0;
  652.   return sb->theBATSize;
  653. }
  655. void* 
  656. SimulatedBlock::allocRecord(const char * type, size_t s, size_t n, bool clear) 
  657. {
  659.   void * p = NULL;
  660.   size_t size = n*s;
  661.   refresh_watch_dog(); 
  662.   if (size > 0){
  663. #ifdef VM_TRACE_MEM
  664.     ndbout_c("%s::allocRecord(%s, %u, %u) = %u bytes", 
  665.      getBlockName(number()), 
  666.      type,
  667.      s,
  668.      n,
  669.      size);
  670. #endif
  671.     p = NdbMem_Allocate(size);
  672.     if (p == NULL){
  673.       char buf1[255];
  674.       char buf2[255];
  675.       BaseString::snprintf(buf1, sizeof(buf1), "%s could not allocate memory for %s", 
  676.        getBlockName(number()), type);
  677.       BaseString::snprintf(buf2, sizeof(buf2), "Requested: %ux%u = %u bytes", 
  678.        (Uint32)s, (Uint32)n, (Uint32)size);
  679.       ERROR_SET(fatal, ERR_MEMALLOC, buf1, buf2);
  680.     }
  682.     if(clear){
  683.       char * ptr = (char*)p;
  684.       const Uint32 chunk = 128 * 1024;
  685.       while(size > chunk){
  686. refresh_watch_dog(); 
  687. memset(ptr, 0, chunk);
  688. ptr += chunk;
  689. size -= chunk;
  690.       }
  691.       refresh_watch_dog(); 
  692.       memset(ptr, 0, size);
  693.     }
  694.   }
  695.   return p;
  696. }
  698. void 
  699. SimulatedBlock::deallocRecord(void ** ptr, 
  700.       const char * type, size_t s, size_t n){
  701.   (void)type;
  702.   (void)s;
  703.   (void)n;
  705.   if(* ptr != 0){
  706.     NdbMem_Free(* ptr);
  707.     * ptr = 0;
  708.   }
  709. }
  711. void
  712. SimulatedBlock::refresh_watch_dog()
  713. {
  714.   globalData.incrementWatchDogCounter(1);
  715. }
  717. void
  718. SimulatedBlock::progError(int line, int err_code, const char* extra) const {
  719.   jamLine(line);
  721.   const char *aBlockName = getBlockName(number(), "VM Kernel");
  723.   // Pack status of interesting config variables 
  724.   // so that we can print them in error.log
  725.   int magicStatus = 
  726.     (theConfiguration.stopOnError()<<1) + 
  727.     (theConfiguration.getInitialStart()<<2) + 
  728.     (theConfiguration.getDaemonMode()<<3);
  729.   
  731.   /* Add line number to block name */
  732.   char buf[100];
  733.   BaseString::snprintf(&buf[0], 100, "%s (Line: %d) 0x%.8x", 
  734.    aBlockName, line, magicStatus);
  736.   ErrorReporter::handleError(ecError, err_code, extra, buf);
  738. }
  740. void 
  741. SimulatedBlock::infoEvent(const char * msg, ...) const {
  742.   if(msg == 0)
  743.     return;
  744.   
  745.   Uint32 theData[25];
  746.   theData[0] = EventReport::InfoEvent;
  747.   char * buf = (char *)&(theData[1]);
  748.   
  749.   va_list ap;
  750.   va_start(ap, msg);
  751.   BaseString::vsnprintf(buf, 96, msg, ap); // 96 = 100 - 4
  752.   va_end(ap);
  753.   
  754.   int len = strlen(buf) + 1;
  755.   if(len > 96){
  756.     len = 96;
  757.     buf[95] = 0;
  758.   }
  760.   /**
  761.    * Init and put it into the job buffer
  762.    */
  763.   SignalHeader sh;
  764.   memset(&sh, 0, sizeof(SignalHeader));
  765.   
  766.   const Signal * signal = globalScheduler.getVMSignals();
  767.   Uint32 tTrace = signal->header.theTrace;
  768.   Uint32 tSignalId = signal->header.theSignalId;
  769.   
  770.   sh.theVerId_signalNumber   = GSN_EVENT_REP;
  771.   sh.theReceiversBlockNumber = CMVMI;
  772.   sh.theSendersBlockRef      = reference();
  773.   sh.theTrace                = tTrace;
  774.   sh.theSignalId             = tSignalId;
  775.   sh.theLength               = ((len+3)/4)+1;
  776.   
  777.   Uint32 secPtrI[3]; // Dummy
  778.   globalScheduler.execute(&sh, JBB, theData, secPtrI);
  779. }
  781. void 
  782. SimulatedBlock::warningEvent(const char * msg, ...) const {
  783.   if(msg == 0)
  784.     return;
  785.   
  786.   Uint32 theData[25];
  787.   theData[0] = EventReport::WarningEvent;
  788.   char * buf = (char *)&(theData[1]);
  789.   
  790.   va_list ap;
  791.   va_start(ap, msg);
  792.   BaseString::vsnprintf(buf, 96, msg, ap); // 96 = 100 - 4
  793.   va_end(ap);
  794.   
  795.   int len = strlen(buf) + 1;
  796.   if(len > 96){
  797.     len = 96;
  798.     buf[95] = 0;
  799.   }
  801.   /**
  802.    * Init and put it into the job buffer
  803.    */
  804.   SignalHeader sh;
  805.   memset(&sh, 0, sizeof(SignalHeader));
  806.   
  807.   const Signal * signal = globalScheduler.getVMSignals();
  808.   Uint32 tTrace = signal->header.theTrace;
  809.   Uint32 tSignalId = signal->header.theSignalId;
  810.   
  811.   sh.theVerId_signalNumber   = GSN_EVENT_REP;
  812.   sh.theReceiversBlockNumber = CMVMI;
  813.   sh.theSendersBlockRef      = reference();
  814.   sh.theTrace                = tTrace;
  815.   sh.theSignalId             = tSignalId;
  816.   sh.theLength               = ((len+3)/4)+1;
  818.   Uint32 secPtrI[3]; // Dummy
  819.   globalScheduler.execute(&sh, JBB, theData, secPtrI);
  820. }
  822. void
  823. SimulatedBlock::execNODE_STATE_REP(Signal* signal){
  824.   const NodeStateRep * const  rep = (NodeStateRep *)&signal->theData[0];
  825.   
  826.   this->theNodeState = rep->nodeState;
  827. }
  829. void
  830. SimulatedBlock::execCHANGE_NODE_STATE_REQ(Signal* signal){
  831.   const ChangeNodeStateReq * const  req = 
  832.     (ChangeNodeStateReq *)&signal->theData[0];
  833.   
  834.   this->theNodeState = req->nodeState;
  835.   const Uint32 senderData = req->senderData;
  836.   const BlockReference senderRef = req->senderRef;
  838.   /**
  839.    * Pack return signal
  840.    */
  841.   ChangeNodeStateConf * const  conf = 
  842.     (ChangeNodeStateConf *)&signal->theData[0];
  843.   
  844.   conf->senderData = senderData;
  846.   sendSignal(senderRef, GSN_CHANGE_NODE_STATE_CONF, signal, 
  847.      ChangeNodeStateConf::SignalLength, JBB);
  848. }
  850. void
  851. SimulatedBlock::execNDB_TAMPER(Signal * signal){
  852.   SET_ERROR_INSERT_VALUE(signal->theData[0]);
  853. }
  855. void
  856. SimulatedBlock::execSIGNAL_DROPPED_REP(Signal * signal){
  857.   ErrorReporter::handleError(ecError,
  858.      ERR_OUT_OF_LONG_SIGNAL_MEMORY,
  859.      "Signal lost, out of long signal memory",
  860.      __FILE__,
  861.      NST_ErrorHandler);
  862. }
  864. void
  865. SimulatedBlock::execCONTINUE_FRAGMENTED(Signal * signal){
  866.   ljamEntry();
  867.   
  868.   Ptr<FragmentSendInfo> fragPtr;
  869.   
  870.   c_segmentedFragmentSendList.first(fragPtr);  
  871.   for(; !fragPtr.isNull();){
  872.     ljam();
  873.     Ptr<FragmentSendInfo> copyPtr = fragPtr;
  874.     c_segmentedFragmentSendList.next(fragPtr);
  875.     
  876.     sendNextSegmentedFragment(signal, * copyPtr.p);
  877.     if(copyPtr.p->m_status == FragmentSendInfo::SendComplete){
  878.       ljam();
  879.       if(copyPtr.p->m_callback.m_callbackFunction != 0) {
  880.         ljam();
  881. execute(signal, copyPtr.p->m_callback, 0);
  882.       }//if
  883.       c_segmentedFragmentSendList.release(copyPtr);
  884.     }
  885.   }
  886.   
  887.   c_linearFragmentSendList.first(fragPtr);  
  888.   for(; !fragPtr.isNull();){
  889.     ljam(); 
  890.     Ptr<FragmentSendInfo> copyPtr = fragPtr;
  891.     c_linearFragmentSendList.next(fragPtr);
  892.     
  893.     sendNextLinearFragment(signal, * copyPtr.p);
  894.     if(copyPtr.p->m_status == FragmentSendInfo::SendComplete){
  895.       ljam();
  896.       if(copyPtr.p->m_callback.m_callbackFunction != 0) {
  897.         ljam();
  898. execute(signal, copyPtr.p->m_callback, 0);
  899.       }//if
  900.       c_linearFragmentSendList.release(copyPtr);
  901.     }
  902.   }
  903.   
  904.   if(c_segmentedFragmentSendList.isEmpty() && 
  905.      c_linearFragmentSendList.isEmpty()){
  906.     ljam();
  907.     c_fragSenderRunning = false;
  908.     return;
  909.   }
  910.   
  911.   ContinueFragmented * sig = (ContinueFragmented*)signal->getDataPtrSend();
  912.   sig->line = __LINE__;
  913.   sendSignal(reference(), GSN_CONTINUE_FRAGMENTED, signal, 1, JBB);
  914. }
  916. #ifdef VM_TRACE_TIME
  917. void
  918. SimulatedBlock::clearTimes() {
  919.   for(Uint32 i = 0; i <= MAX_GSN; i++){
  920.     m_timeTrace[i].cnt = 0;
  921.     m_timeTrace[i].sum = 0;
  922.     m_timeTrace[i].sub = 0;
  923.   }
  924. }
  926. void
  927. SimulatedBlock::printTimes(FILE * output){
  928.   fprintf(output, "-- %s --n", getBlockName(number()));
  929.   Uint64 sum = 0;
  930.   for(Uint32 i = 0; i <= MAX_GSN; i++){
  931.     Uint32 n = m_timeTrace[i].cnt;
  932.     if(n != 0){
  933.       double dn = n;
  934.       
  935.       double avg = m_timeTrace[i].sum;
  936.       double avg2 = avg - m_timeTrace[i].sub;
  937.       
  938.       avg /= dn;
  939.       avg2 /= dn;
  940.       
  941.       fprintf(output, 
  942.       //name ; cnt ; loc ; acc
  943.       "%s ; #%d ; %dus ; %dus ; %dmsn",
  944.       getSignalName(i), n, (Uint32)avg, (Uint32)avg2, 
  945.       (Uint32)((m_timeTrace[i].sum - m_timeTrace[i].sub + 500)/ 1000));
  946.       
  947.       sum += (m_timeTrace[i].sum - m_timeTrace[i].sub);
  948.     }
  949.   }
  950.   sum = (sum + 500)/ 1000;
  951.   fprintf(output, "-- %s : %d --n", getBlockName(number()), sum);
  952.   fprintf(output, "n");
  953.   fflush(output);
  954. }
  956. #endif
  958. void release(SegmentedSectionPtr & ptr);
  960. SimulatedBlock::FragmentInfo::FragmentInfo(Uint32 fragId, Uint32 sender){
  961.   m_fragmentId = fragId;
  962.   m_senderRef = sender;
  963.   m_sectionPtrI[0] = RNIL; 
  964.   m_sectionPtrI[1] = RNIL;
  965.   m_sectionPtrI[2] = RNIL;
  966. }
  968. SimulatedBlock::FragmentSendInfo::FragmentSendInfo()
  969. {
  970. }
  972. bool
  973. SimulatedBlock::assembleFragments(Signal * signal){
  974.   Uint32 sigLen = signal->length() - 1;
  975.   Uint32 fragId = signal->theData[sigLen];
  976.   Uint32 fragInfo = signal->header.m_fragmentInfo;
  977.   Uint32 senderRef = signal->getSendersBlockRef();
  978.   
  979.   if(fragInfo == 0){
  980.     return true;
  981.   }
  982.   
  983.   const Uint32 secs = signal->header.m_noOfSections;
  984.   const Uint32 * const secNos = &signal->theData[sigLen - secs];
  985.   
  986.   if(fragInfo == 1){
  987.     /**
  988.      * First in train
  989.      */
  990.     Ptr<FragmentInfo> fragPtr;
  991.     if(!c_fragmentInfoHash.seize(fragPtr)){
  992.       ndbrequire(false);
  993.       return false;
  994.     }
  995.     
  996.     new (fragPtr.p)FragmentInfo(fragId, senderRef);
  997.     c_fragmentInfoHash.add(fragPtr);
  998.     
  999.     for(Uint32 i = 0; i<secs; i++){
  1000.       Uint32 sectionNo = secNos[i];
  1001.       ndbassert(sectionNo < 3);
  1002.       fragPtr.p->m_sectionPtrI[sectionNo] = signal->m_sectionPtr[i].i;
  1003.     }
  1004.     
  1005.     /**
  1006.      * Don't release allocated segments
  1007.      */
  1008.     signal->header.m_noOfSections = 0;
  1009.     return false;
  1010.   }
  1011.   
  1012.   FragmentInfo key(fragId, senderRef);
  1013.   Ptr<FragmentInfo> fragPtr;
  1014.   if(c_fragmentInfoHash.find(fragPtr, key)){
  1015.     
  1016.     /**
  1017.      * FragInfo == 2 or 3
  1018.      */
  1019.     Uint32 i;
  1020.     for(i = 0; i<secs; i++){
  1021.       Uint32 sectionNo = secNos[i];
  1022.       ndbassert(sectionNo < 3);
  1023.       Uint32 sectionPtrI = signal->m_sectionPtr[i].i;
  1024.       if(fragPtr.p->m_sectionPtrI[sectionNo] != RNIL){
  1025. linkSegments(fragPtr.p->m_sectionPtrI[sectionNo], sectionPtrI);
  1026.       } else {
  1027. fragPtr.p->m_sectionPtrI[sectionNo] = sectionPtrI;
  1028.       }
  1029.     }
  1030.     
  1031.     /**
  1032.      * fragInfo = 2
  1033.      */
  1034.     if(fragInfo == 2){
  1035.       signal->header.m_noOfSections = 0;
  1036.       return false;
  1037.     }
  1038.     
  1039.     /**
  1040.      * fragInfo = 3
  1041.      */
  1042.     for(i = 0; i<3; i++){
  1043.       Uint32 ptrI = fragPtr.p->m_sectionPtrI[i];
  1044.       if(ptrI != RNIL){
  1045. signal->m_sectionPtr[i].i = ptrI;
  1046.       } else {
  1047. break;
  1048.       }
  1049.     }
  1050.     signal->setLength(sigLen - i);
  1051.     signal->header.m_noOfSections = i;
  1052.     signal->header.m_fragmentInfo = 0;
  1053.     getSections(i, signal->m_sectionPtr);
  1054.     
  1055.     c_fragmentInfoHash.release(fragPtr);
  1056.     return true;
  1057.   }
  1058.   
  1059.   /**
  1060.    * Unable to find fragment
  1061.    */
  1062.   ndbrequire(false);
  1063.   return false;
  1064. }
  1066. bool
  1067. SimulatedBlock::sendFirstFragment(FragmentSendInfo & info,
  1068.   NodeReceiverGroup rg, 
  1069.   GlobalSignalNumber gsn, 
  1070.   Signal* signal, 
  1071.   Uint32 length, 
  1072.   JobBufferLevel jbuf,
  1073.   Uint32 messageSize){
  1074.   
  1075.   info.m_sectionPtr[0].m_segmented.i = RNIL;
  1076.   info.m_sectionPtr[1].m_segmented.i = RNIL;
  1077.   info.m_sectionPtr[2].m_segmented.i = RNIL;
  1078.   
  1079.   Uint32 totalSize = 0;
  1080.   SectionSegment * p;
  1081.   switch(signal->header.m_noOfSections){
  1082.   case 3:
  1083.     p = signal->m_sectionPtr[2].p;  
  1084.     info.m_sectionPtr[2].m_segmented.p = p;
  1085.     info.m_sectionPtr[2].m_segmented.i = signal->m_sectionPtr[2].i;
  1086.     totalSize += p->m_sz;
  1087.   case 2:
  1088.     p = signal->m_sectionPtr[1].p;  
  1089.     info.m_sectionPtr[1].m_segmented.p = p;
  1090.     info.m_sectionPtr[1].m_segmented.i = signal->m_sectionPtr[1].i;
  1091.     totalSize += p->m_sz;
  1092.   case 1:
  1093.     p = signal->m_sectionPtr[0].p;  
  1094.     info.m_sectionPtr[0].m_segmented.p = p;
  1095.     info.m_sectionPtr[0].m_segmented.i = signal->m_sectionPtr[0].i;
  1096.     totalSize += p->m_sz;
  1097.   }
  1099.   if(totalSize <= messageSize + SectionSegment::DataLength){
  1100.     /**
  1101.      * Send signal directly
  1102.      */
  1103.     sendSignal(rg, gsn, signal, length, jbuf);
  1104.     info.m_status = FragmentSendInfo::SendComplete;
  1105.     return true;
  1106.   }
  1108.   /**
  1109.    * Consume sections
  1110.    */
  1111.   signal->header.m_noOfSections = 0;
  1112.     
  1113.   /**
  1114.    * Setup info object
  1115.    */
  1116.   info.m_status = FragmentSendInfo::SendNotComplete;
  1117.   info.m_prio = (Uint8)jbuf;
  1118.   info.m_gsn = gsn;
  1119.   info.m_fragInfo = 1;
  1120.   info.m_messageSize = messageSize;
  1121.   info.m_fragmentId = c_fragmentIdCounter++;
  1122.   info.m_nodeReceiverGroup = rg;
  1123.   info.m_callback.m_callbackFunction = 0;
  1124.   
  1125.   Ptr<SectionSegment> tmp;
  1126.   if(!import(tmp, &signal->theData[0], length)){
  1127.     ndbrequire(false);
  1128.     return false;
  1129.   }
  1130.   info.m_theDataSection.p = &tmp.p->theData[0];
  1131.   info.m_theDataSection.sz = length;
  1132.   tmp.p->theData[length] = tmp.i;
  1133.   
  1134.   sendNextSegmentedFragment(signal, info);
  1135.   
  1136.   if(c_fragmentIdCounter == 0){
  1137.     /**
  1138.      * Fragment id 0 is invalid
  1139.      */
  1140.     c_fragmentIdCounter = 1;
  1141.   }
  1143.   return true;
  1144. }
  1146. #if 0
  1147. #define lsout(x) x
  1148. #else
  1149. #define lsout(x)
  1150. #endif
  1152. void
  1153. SimulatedBlock::sendNextSegmentedFragment(Signal* signal,
  1154.   FragmentSendInfo & info){
  1155.   
  1156.   /**
  1157.    * Store "theData"
  1158.    */
  1159.   const Uint32 sigLen = info.m_theDataSection.sz;
  1160.   memcpy(&signal->theData[0], info.m_theDataSection.p, 4 * sigLen);
  1161.   
  1162.   Uint32 sz = 0; 
  1163.   Uint32 maxSz = info.m_messageSize;
  1164.   
  1165.   Int32 secNo = 2;
  1166.   Uint32 secCount = 0;
  1167.   Uint32 * secNos = &signal->theData[sigLen];
  1168.   
  1169.   enum { Unknown = 0, Full = 1 } loop = Unknown;
  1170.   for(; secNo >= 0 && secCount < 3; secNo--){
  1171.     Uint32 ptrI = info.m_sectionPtr[secNo].m_segmented.i;
  1172.     if(ptrI == RNIL)
  1173.       continue;
  1174.     
  1175.     info.m_sectionPtr[secNo].m_segmented.i = RNIL;
  1176.     
  1177.     SectionSegment * ptrP = info.m_sectionPtr[secNo].m_segmented.p;
  1178.     const Uint32 size = ptrP->m_sz;
  1179.     
  1180.     signal->m_sectionPtr[secCount].i = ptrI;
  1181.     signal->m_sectionPtr[secCount].p = ptrP;
  1182.     signal->m_sectionPtr[secCount].sz = size;
  1183.     secNos[secCount] = secNo;
  1184.     secCount++;
  1185.     
  1186.     const Uint32 sizeLeft = maxSz - sz;
  1187.     if(size <= sizeLeft){
  1188.       /**
  1189.        * The section fits
  1190.        */
  1191.       sz += size;
  1192.       lsout(ndbout_c("section %d saved as %d", secNo, secCount-1));
  1193.       continue;
  1194.     }
  1195.     
  1196.     const Uint32 overflow = size - sizeLeft; // > 0
  1197.     if(overflow <= SectionSegment::DataLength){
  1198.       /**
  1199.        * Only one segment left to send
  1200.        *   send even if sizeLeft <= size
  1201.        */
  1202.       lsout(ndbout_c("section %d saved as %d but full over: %d", 
  1203.      secNo, secCount-1, overflow));
  1204.       secNo--;
  1205.       break;
  1206.     }
  1208.     // size >= 61
  1209.     if(sizeLeft < SectionSegment::DataLength){
  1210.       /**
  1211.        * Less than one segment left (space)
  1212.        *   dont bother sending
  1213.        */
  1214.       secCount--;
  1215.       info.m_sectionPtr[secNo].m_segmented.i = ptrI;
  1216.       loop = Full;
  1217.       lsout(ndbout_c("section %d not saved", secNo));
  1218.       break;
  1219.     }
  1220.     
  1221.     /**
  1222.      * Split list
  1223.      * 1) Find place to split
  1224.      * 2) Rewrite header (the part that will be sent)
  1225.      * 3) Write new header (for remaining part)
  1226.      * 4) Store new header on FragmentSendInfo - record
  1227.      */
  1228.     // size >= 61 && sizeLeft >= 60
  1229.     Uint32 sum = SectionSegment::DataLength;
  1230.     Uint32 prevPtrI = ptrI;
  1231.     ptrI = ptrP->m_nextSegment;
  1232.     const Uint32 fill = sizeLeft - SectionSegment::DataLength;
  1233.     while(sum < fill){
  1234.       prevPtrI = ptrI;
  1235.       ptrP = g_sectionSegmentPool.getPtr(ptrI);
  1236.       ptrI = ptrP->m_nextSegment;
  1237.       sum += SectionSegment::DataLength;
  1238.     }
  1239.     
  1240.     /**
  1241.      * Rewrite header w.r.t size and last
  1242.      */
  1243.     Uint32 prev = secCount - 1;
  1244.     const Uint32 last = signal->m_sectionPtr[prev].p->m_lastSegment;
  1245.     signal->m_sectionPtr[prev].p->m_lastSegment = prevPtrI;
  1246.     signal->m_sectionPtr[prev].p->m_sz = sum;
  1247.     signal->m_sectionPtr[prev].sz = sum;
  1248.       
  1249.     /**
  1250.      * Write "new" list header
  1251.      */
  1252.     ptrP = g_sectionSegmentPool.getPtr(ptrI);
  1253.     ptrP->m_lastSegment = last;
  1254.     ptrP->m_sz = size - sum;
  1255.     
  1256.     /**
  1257.      * And store it on info-record
  1258.      */
  1259.     info.m_sectionPtr[secNo].m_segmented.i = ptrI;
  1260.     info.m_sectionPtr[secNo].m_segmented.p = ptrP;
  1261.     
  1262.     loop = Full;
  1263.     lsout(ndbout_c("section %d split into %d", secNo, prev));
  1264.     break;
  1265.   }
  1266.   
  1267.   lsout(ndbout_c("loop: %d secNo: %d secCount: %d sz: %d", 
  1268.  loop, secNo, secCount, sz));
  1269.   
  1270.   /**
  1271.    * Store fragment id
  1272.    */
  1273.   secNos[secCount] = info.m_fragmentId;
  1274.   
  1275.   Uint32 fragInfo = info.m_fragInfo;
  1276.   info.m_fragInfo = 2;
  1277.   switch(loop){
  1278.   case Unknown:
  1279.     if(secNo >= 0){
  1280.       lsout(ndbout_c("Unknown - Full"));
  1281.       /**
  1282.        * Not finished
  1283.        */
  1284.       break;
  1285.     }
  1286.     // Fall through
  1287.     lsout(ndbout_c("Unknown - Done"));
  1288.     info.m_status = FragmentSendInfo::SendComplete;
  1289.     ndbassert(fragInfo == 2);
  1290.     fragInfo = 3;
  1291.   case Full:
  1292.     break;
  1293.   }
  1294.   
  1295.   signal->header.m_fragmentInfo = fragInfo;
  1296.   signal->header.m_noOfSections = secCount;
  1297.   
  1298.   sendSignal(info.m_nodeReceiverGroup,
  1299.      info.m_gsn,
  1300.      signal, 
  1301.      sigLen + secCount + 1,
  1302.      (JobBufferLevel)info.m_prio);
  1303.   
  1304.   if(fragInfo == 3){
  1305.     /**
  1306.      * This is the last signal
  1307.      */
  1308.     g_sectionSegmentPool.release(info.m_theDataSection.p[sigLen]);
  1309.   }
  1310. }
  1312. bool
  1313. SimulatedBlock::sendFirstFragment(FragmentSendInfo & info,
  1314.   NodeReceiverGroup rg, 
  1315.   GlobalSignalNumber gsn, 
  1316.   Signal* signal, 
  1317.   Uint32 length, 
  1318.   JobBufferLevel jbuf,
  1319.   LinearSectionPtr ptr[3],
  1320.   Uint32 noOfSections,
  1321.   Uint32 messageSize){
  1322.   
  1323.   ::releaseSections(signal->header.m_noOfSections, signal->m_sectionPtr);
  1324.   signal->header.m_noOfSections = 0;
  1325.   
  1326.   info.m_sectionPtr[0].m_linear.p = NULL;
  1327.   info.m_sectionPtr[1].m_linear.p = NULL;
  1328.   info.m_sectionPtr[2].m_linear.p = NULL;
  1329.   
  1330.   Uint32 totalSize = 0;
  1331.   switch(noOfSections){
  1332.   case 3:
  1333.     info.m_sectionPtr[2].m_linear = ptr[2];
  1334.     totalSize += ptr[2].sz;
  1335.   case 2:
  1336.     info.m_sectionPtr[1].m_linear = ptr[1];
  1337.     totalSize += ptr[1].sz;
  1338.   case 1:
  1339.     info.m_sectionPtr[0].m_linear = ptr[0];
  1340.     totalSize += ptr[0].sz;
  1341.   }
  1343.   if(totalSize <= messageSize + SectionSegment::DataLength){
  1344.     /**
  1345.      * Send signal directly
  1346.      */
  1347.     sendSignal(rg, gsn, signal, length, jbuf, ptr, noOfSections);
  1348.     info.m_status = FragmentSendInfo::SendComplete;
  1349.     
  1350.     /**
  1351.      * Indicate to sendLinearSignalFragment
  1352.      *   that we'r already done
  1353.      */
  1354.     return true;
  1355.   }
  1357.   /**
  1358.    * Setup info object
  1359.    */
  1360.   info.m_status = FragmentSendInfo::SendNotComplete;
  1361.   info.m_prio = (Uint8)jbuf;
  1362.   info.m_gsn = gsn;
  1363.   info.m_messageSize = messageSize;
  1364.   info.m_fragInfo = 1;
  1365.   info.m_fragmentId = c_fragmentIdCounter++;
  1366.   info.m_nodeReceiverGroup = rg;
  1367.   info.m_callback.m_callbackFunction = 0;
  1369.   Ptr<SectionSegment> tmp;
  1370.   if(!import(tmp, &signal->theData[0], length)){
  1371.     ndbrequire(false);
  1372.     return false;
  1373.   }
  1375.   info.m_theDataSection.p = &tmp.p->theData[0];
  1376.   info.m_theDataSection.sz = length;
  1377.   tmp.p->theData[length] = tmp.i;
  1378.   
  1379.   sendNextLinearFragment(signal, info);
  1381.   if(c_fragmentIdCounter == 0){
  1382.     /**
  1383.      * Fragment id 0 is invalid
  1384.      */
  1385.     c_fragmentIdCounter = 1;
  1386.   }
  1387.   
  1388.   return true;
  1389. }
  1391. void
  1392. SimulatedBlock::sendNextLinearFragment(Signal* signal,
  1393.        FragmentSendInfo & info){
  1394.   
  1395.   /**
  1396.    * Store "theData"
  1397.    */
  1398.   const Uint32 sigLen = info.m_theDataSection.sz;
  1399.   memcpy(&signal->theData[0], info.m_theDataSection.p, 4 * sigLen);
  1400.   
  1401.   Uint32 sz = 0; 
  1402.   Uint32 maxSz = info.m_messageSize;
  1403.   
  1404.   Int32 secNo = 2;
  1405.   Uint32 secCount = 0;
  1406.   Uint32 * secNos = &signal->theData[sigLen];
  1407.   LinearSectionPtr signalPtr[3];
  1408.   
  1409.   enum { Unknown = 0, Full = 2 } loop = Unknown;
  1410.   for(; secNo >= 0 && secCount < 3; secNo--){
  1411.     Uint32 * ptrP = info.m_sectionPtr[secNo].m_linear.p;
  1412.     if(ptrP == NULL)
  1413.       continue;
  1414.     
  1415.     info.m_sectionPtr[secNo].m_linear.p = NULL;
  1416.     const Uint32 size = info.m_sectionPtr[secNo].m_linear.sz;
  1417.     
  1418.     signalPtr[secCount].p = ptrP;
  1419.     signalPtr[secCount].sz = size;
  1420.     secNos[secCount] = secNo;
  1421.     secCount++;
  1422.     
  1423.     const Uint32 sizeLeft = maxSz - sz;
  1424.     if(size <= sizeLeft){
  1425.       /**
  1426.        * The section fits
  1427.        */
  1428.       sz += size;
  1429.       lsout(ndbout_c("section %d saved as %d", secNo, secCount-1));
  1430.       continue;
  1431.     }
  1432.     
  1433.     const Uint32 overflow = size - sizeLeft; // > 0
  1434.     if(overflow <= SectionSegment::DataLength){
  1435.       /**
  1436.        * Only one segment left to send
  1437.        *   send even if sizeLeft <= size
  1438.        */
  1439.       lsout(ndbout_c("section %d saved as %d but full over: %d", 
  1440.      secNo, secCount-1, overflow));
  1441.       secNo--;
  1442.       break;
  1443.     }
  1445.     // size >= 61
  1446.     if(sizeLeft < SectionSegment::DataLength){
  1447.       /**
  1448.        * Less than one segment left (space)
  1449.        *   dont bother sending
  1450.        */
  1451.       secCount--;
  1452.       info.m_sectionPtr[secNo].m_linear.p = ptrP;
  1453.       loop = Full;
  1454.       lsout(ndbout_c("section %d not saved", secNo));
  1455.       break;
  1456.     }
  1457.     
  1458.     /**
  1459.      * Split list
  1460.      * 1) Find place to split
  1461.      * 2) Rewrite header (the part that will be sent)
  1462.      * 3) Write new header (for remaining part)
  1463.      * 4) Store new header on FragmentSendInfo - record
  1464.      */
  1465.     Uint32 sum = sizeLeft;
  1466.     sum /= SectionSegment::DataLength;
  1467.     sum *= SectionSegment::DataLength;
  1468.     
  1469.     /**
  1470.      * Rewrite header w.r.t size
  1471.      */
  1472.     Uint32 prev = secCount - 1;
  1473.     signalPtr[prev].sz = sum;
  1474.     
  1475.     /**
  1476.      * Write/store "new" header
  1477.      */
  1478.     info.m_sectionPtr[secNo].m_linear.p = ptrP + sum;
  1479.     info.m_sectionPtr[secNo].m_linear.sz = size - sum;
  1480.     
  1481.     loop = Full;
  1482.     lsout(ndbout_c("section %d split into %d", secNo, prev));
  1483.     break;
  1484.   }
  1485.   
  1486.   lsout(ndbout_c("loop: %d secNo: %d secCount: %d sz: %d", 
  1487.  loop, secNo, secCount, sz));
  1488.   
  1489.   /**
  1490.    * Store fragment id
  1491.    */
  1492.   secNos[secCount] = info.m_fragmentId;
  1493.   
  1494.   Uint32 fragInfo = info.m_fragInfo;
  1495.   info.m_fragInfo = 2;
  1496.   switch(loop){
  1497.   case Unknown:
  1498.     if(secNo >= 0){
  1499.       lsout(ndbout_c("Unknown - Full"));
  1500.       /**
  1501.        * Not finished
  1502.        */
  1503.       break;
  1504.     }
  1505.     // Fall through
  1506.     lsout(ndbout_c("Unknown - Done"));
  1507.     info.m_status = FragmentSendInfo::SendComplete;
  1508.     ndbassert(fragInfo == 2);
  1509.     fragInfo = 3;
  1510.   case Full:
  1511.     break;
  1512.   }
  1513.   
  1514.   signal->header.m_noOfSections = 0;
  1515.   signal->header.m_fragmentInfo = fragInfo;
  1516.   
  1517.   sendSignal(info.m_nodeReceiverGroup,
  1518.      info.m_gsn,
  1519.      signal, 
  1520.      sigLen + secCount + 1,
  1521.      (JobBufferLevel)info.m_prio,
  1522.      signalPtr,
  1523.      secCount);
  1524.   
  1525.   if(fragInfo == 3){
  1526.     /**
  1527.      * This is the last signal
  1528.      */
  1529.     g_sectionSegmentPool.release(info.m_theDataSection.p[sigLen]);
  1530.   }
  1531. }
  1533. void
  1534. SimulatedBlock::sendFragmentedSignal(BlockReference ref, 
  1535.      GlobalSignalNumber gsn, 
  1536.      Signal* signal, 
  1537.      Uint32 length, 
  1538.      JobBufferLevel jbuf,
  1539.      Callback & c,
  1540.      Uint32 messageSize){
  1541.   bool res = true;
  1542.   Ptr<FragmentSendInfo> ptr;
  1543.   res = c_segmentedFragmentSendList.seize(ptr);
  1544.   ndbrequire(res);
  1545.   
  1546.   res = sendFirstFragment(* ptr.p, 
  1547.   NodeReceiverGroup(ref),
  1548.   gsn,
  1549.   signal,
  1550.   length,
  1551.   jbuf,
  1552.   messageSize);
  1553.   ndbrequire(res);
  1554.   
  1555.   if(ptr.p->m_status == FragmentSendInfo::SendComplete){
  1556.     c_segmentedFragmentSendList.release(ptr);
  1557.     if(c.m_callbackFunction != 0)
  1558.       execute(signal, c, 0);
  1559.     return;
  1560.   }
  1561.   ptr.p->m_callback = c;
  1563.   if(!c_fragSenderRunning){
  1564.     c_fragSenderRunning = true;
  1565.     ContinueFragmented * sig = (ContinueFragmented*)signal->getDataPtrSend();
  1566.     sig->line = __LINE__;
  1567.     sendSignal(reference(), GSN_CONTINUE_FRAGMENTED, signal, 1, JBB);
  1568.   }
  1569. }
  1571. void
  1572. SimulatedBlock::sendFragmentedSignal(NodeReceiverGroup rg, 
  1573.      GlobalSignalNumber gsn, 
  1574.      Signal* signal, 
  1575.      Uint32 length, 
  1576.      JobBufferLevel jbuf,
  1577.      Callback & c,
  1578.      Uint32 messageSize){
  1579.   bool res = true;
  1580.   Ptr<FragmentSendInfo> ptr;
  1581.   res = c_segmentedFragmentSendList.seize(ptr);
  1582.   ndbrequire(res);
  1583.   
  1584.   res = sendFirstFragment(* ptr.p, 
  1585.   rg,
  1586.   gsn,
  1587.   signal,
  1588.   length,
  1589.   jbuf,
  1590.   messageSize);
  1591.   ndbrequire(res);
  1592.   
  1593.   if(ptr.p->m_status == FragmentSendInfo::SendComplete){
  1594.     c_segmentedFragmentSendList.release(ptr);
  1595.     if(c.m_callbackFunction != 0)
  1596.       execute(signal, c, 0);
  1597.     return;
  1598.   }
  1599.   ptr.p->m_callback = c;
  1601.   if(!c_fragSenderRunning){
  1602.     c_fragSenderRunning = true;
  1603.     ContinueFragmented * sig = (ContinueFragmented*)signal->getDataPtrSend();
  1604.     sig->line = __LINE__;
  1605.     sendSignal(reference(), GSN_CONTINUE_FRAGMENTED, signal, 1, JBB);
  1606.   }
  1607. }
  1609. SimulatedBlock::Callback SimulatedBlock::TheEmptyCallback = {0, 0};
  1611. void
  1612. SimulatedBlock::sendFragmentedSignal(BlockReference ref, 
  1613.      GlobalSignalNumber gsn, 
  1614.      Signal* signal, 
  1615.      Uint32 length, 
  1616.      JobBufferLevel jbuf,
  1617.      LinearSectionPtr ptr[3],
  1618.      Uint32 noOfSections,
  1619.      Callback & c,
  1620.      Uint32 messageSize){
  1621.   bool res = true;
  1622.   Ptr<FragmentSendInfo> tmp;
  1623.   res = c_linearFragmentSendList.seize(tmp);
  1624.   ndbrequire(res);
  1626.   res = sendFirstFragment(* tmp.p, 
  1627.   NodeReceiverGroup(ref),
  1628.   gsn,
  1629.   signal,
  1630.   length,
  1631.   jbuf,
  1632.   ptr,
  1633.   noOfSections,
  1634.   messageSize);
  1635.   ndbrequire(res);
  1636.   
  1637.   if(tmp.p->m_status == FragmentSendInfo::SendComplete){
  1638.     c_linearFragmentSendList.release(tmp);
  1639.     if(c.m_callbackFunction != 0)
  1640.       execute(signal, c, 0);
  1641.     return;
  1642.   }
  1643.   tmp.p->m_callback = c;
  1644.   
  1645.   if(!c_fragSenderRunning){
  1646.     c_fragSenderRunning = true;
  1647.     ContinueFragmented * sig = (ContinueFragmented*)signal->getDataPtrSend();
  1648.     sig->line = __LINE__;
  1649.     sendSignal(reference(), GSN_CONTINUE_FRAGMENTED, signal, 1, JBB);
  1650.   }
  1651. }
  1653. void
  1654. SimulatedBlock::sendFragmentedSignal(NodeReceiverGroup rg, 
  1655.      GlobalSignalNumber gsn, 
  1656.      Signal* signal, 
  1657.      Uint32 length, 
  1658.      JobBufferLevel jbuf,
  1659.      LinearSectionPtr ptr[3],
  1660.      Uint32 noOfSections,
  1661.      Callback & c,
  1662.      Uint32 messageSize){
  1663.   bool res = true;
  1664.   Ptr<FragmentSendInfo> tmp;
  1665.   res = c_linearFragmentSendList.seize(tmp);
  1666.   ndbrequire(res);
  1668.   res = sendFirstFragment(* tmp.p, 
  1669.   rg,
  1670.   gsn,
  1671.   signal,
  1672.   length,
  1673.   jbuf,
  1674.   ptr,
  1675.   noOfSections,
  1676.   messageSize);
  1677.   ndbrequire(res);
  1678.   
  1679.   if(tmp.p->m_status == FragmentSendInfo::SendComplete){
  1680.     c_linearFragmentSendList.release(tmp);
  1681.     if(c.m_callbackFunction != 0)
  1682.       execute(signal, c, 0);
  1683.     return;
  1684.   }
  1685.   tmp.p->m_callback = c;
  1686.   
  1687.   if(!c_fragSenderRunning){
  1688.     c_fragSenderRunning = true;
  1689.     ContinueFragmented * sig = (ContinueFragmented*)signal->getDataPtrSend();
  1690.     sig->line = __LINE__;
  1691.     sendSignal(reference(), GSN_CONTINUE_FRAGMENTED, signal, 1, JBB);
  1692.   }
  1693. }
  1695. NodeInfo &
  1696. SimulatedBlock::setNodeInfo(NodeId nodeId) {
  1697.   ndbrequire(nodeId > 0 && nodeId < MAX_NODES);
  1698.   return globalData.m_nodeInfo[nodeId];
  1699. }
  1701. void 
  1702. SimulatedBlock::execUTIL_CREATE_LOCK_REF(Signal* signal){
  1703.   ljamEntry();
  1704.   c_mutexMgr.execUTIL_CREATE_LOCK_REF(signal);
  1705. }
  1707. void SimulatedBlock::execUTIL_CREATE_LOCK_CONF(Signal* signal){
  1708.   ljamEntry();
  1709.   c_mutexMgr.execUTIL_CREATE_LOCK_CONF(signal);
  1710. }
  1712. void SimulatedBlock::execUTIL_DESTORY_LOCK_REF(Signal* signal){
  1713.   ljamEntry();
  1714.   c_mutexMgr.execUTIL_DESTORY_LOCK_REF(signal);
  1715. }
  1717. void SimulatedBlock::execUTIL_DESTORY_LOCK_CONF(Signal* signal){
  1718.   ljamEntry();
  1719.   c_mutexMgr.execUTIL_DESTORY_LOCK_CONF(signal);
  1720. }
  1722. void SimulatedBlock::execUTIL_LOCK_REF(Signal* signal){
  1723.   ljamEntry();
  1724.   c_mutexMgr.execUTIL_LOCK_REF(signal);
  1725. }
  1727. void SimulatedBlock::execUTIL_LOCK_CONF(Signal* signal){
  1728.   ljamEntry();
  1729.   c_mutexMgr.execUTIL_LOCK_CONF(signal);
  1730. }
  1732. void SimulatedBlock::execUTIL_UNLOCK_REF(Signal* signal){
  1733.   ljamEntry();
  1734.   c_mutexMgr.execUTIL_UNLOCK_REF(signal);
  1735. }
  1737. void SimulatedBlock::execUTIL_UNLOCK_CONF(Signal* signal){
  1738.   ljamEntry();
  1739.   c_mutexMgr.execUTIL_UNLOCK_CONF(signal);
  1740. }
  1742. void 
  1743. SimulatedBlock::execREAD_CONFIG_REQ(Signal* signal){
  1744.   const ReadConfigReq * req = (ReadConfigReq*)signal->getDataPtr();
  1746.   Uint32 ref = req->senderRef;
  1747.   Uint32 senderData = req->senderData;
  1749.   ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend();
  1750.   conf->senderRef = reference();
  1751.   conf->senderData = senderData;
  1752.   sendSignal(ref, GSN_READ_CONFIG_CONF, signal, 
  1753.      ReadConfigConf::SignalLength, JBB);
  1754. }
  1756. void
  1757. SimulatedBlock::ignoreMutexUnlockCallback(Signal* signal, 
  1758.   Uint32 ptrI, Uint32 retVal){
  1759.   c_mutexMgr.release(ptrI);
  1760. }
  1762. void 
  1763. UpgradeStartup::installEXEC(SimulatedBlock* block){
  1764.   SimulatedBlock::ExecFunction * a = block->theExecArray;
  1765.   switch(block->number()){
  1766.   case QMGR:
  1767.     a[UpgradeStartup::GSN_CM_APPCHG] = &SimulatedBlock::execUPGRADE;
  1768.     break;
  1769.   case CNTR:
  1770.     a[UpgradeStartup::GSN_CNTR_MASTERREF] = &SimulatedBlock::execUPGRADE;
  1771.     a[UpgradeStartup::GSN_CNTR_MASTERCONF] = &SimulatedBlock::execUPGRADE;
  1772.     break;
  1773.   }
  1774. }
  1776. void
  1777. SimulatedBlock::execUPGRADE(Signal* signal){
  1778.   Uint32 gsn = signal->header.theVerId_signalNumber;
  1779.   switch(gsn){
  1780.   case UpgradeStartup::GSN_CM_APPCHG:
  1781.     UpgradeStartup::execCM_APPCHG(* this, signal);
  1782.     break;
  1783.   case UpgradeStartup::GSN_CNTR_MASTERREF:
  1784.     UpgradeStartup::execCNTR_MASTER_REPLY(* this, signal);
  1785.     break;
  1786.   case UpgradeStartup::GSN_CNTR_MASTERCONF:
  1787.     UpgradeStartup::execCNTR_MASTER_REPLY(* this, signal);
  1788.     break;
  1789.   }
  1790. }
  1792. void
  1793. SimulatedBlock::fsRefError(Signal* signal, Uint32 line, const char *msg) 
  1794. {
  1795.   const FsRef *fsRef = (FsRef*)signal->getDataPtr();
  1796.   Uint32 errorCode = fsRef->errorCode;
  1797.   Uint32 osErrorCode = fsRef->osErrorCode;
  1798.   char msg2[100];
  1800.   sprintf(msg2, "%s: %s. OS errno: %u", getBlockName(number()), msg, osErrorCode);
  1802.   progError(line, errorCode, msg2);
  1803. }
  1805. void
  1806. SimulatedBlock::execFSWRITEREF(Signal* signal) 
  1807. {
  1808.   fsRefError(signal, __LINE__, "File system write failed");
  1809. }
  1811. void
  1812. SimulatedBlock::execFSREADREF(Signal* signal) 
  1813. {
  1814.   fsRefError(signal, __LINE__, "File system read failed");
  1815. }
  1817. void
  1818. SimulatedBlock::execFSCLOSEREF(Signal* signal) 
  1819. {
  1820.   fsRefError(signal, __LINE__, "File system close failed");
  1821. }
  1823. void
  1824. SimulatedBlock::execFSOPENREF(Signal* signal) 
  1825. {
  1826.   fsRefError(signal, __LINE__, "File system open failed");
  1827. }
  1829. void
  1830. SimulatedBlock::execFSREMOVEREF(Signal* signal) 
  1831. {
  1832.   fsRefError(signal, __LINE__, "File system remove failed");
  1833. }
  1835. void
  1836. SimulatedBlock::execFSSYNCREF(Signal* signal) 
  1837. {
  1838.   fsRefError(signal, __LINE__, "File system sync failed");
  1839. }
  1841. void
  1842. SimulatedBlock::execFSAPPENDREF(Signal* signal) 
  1843. {
  1844.   fsRefError(signal, __LINE__, "File system append failed");
  1845. }
  1847. #ifdef VM_TRACE
  1848. void
  1849. SimulatedBlock::clear_global_variables(){
  1850.   Ptr<void> ** tmp = m_global_variables;
  1851.   while(* tmp != 0){
  1852.     (* tmp)->i = RNIL;
  1853.     (* tmp)->p = 0;
  1854.     tmp++;
  1855.   }
  1856. }
  1858. void
  1859. SimulatedBlock::init_globals_list(void ** tmp, size_t cnt){
  1860.   m_global_variables = new Ptr<void> * [cnt+1];
  1861.   for(size_t i = 0; i<cnt; i++){
  1862.     m_global_variables[i] = (Ptr<void>*)tmp[i];
  1863.   }
  1864.   m_global_variables[cnt] = 0;
  1865. }
  1867. #endif