dbaccmain.cpp

mysql-5.0.22.tar.gz源码包

void Dbacc::sttorrysignalLab(Signal* signal) 
{
  signal->theData[0] = csignalkey;
  signal->theData[1] = 3;
  /* BLOCK CATEGORY */
  signal->theData[2] = 2;
  /* SIGNAL VERSION NUMBER */
  signal->theData[3] = ZSPH1;
  signal->theData[4] = 255;
  sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 5, JBB);
  /* END OF START PHASES */
  return;
}//Dbacc::sttorrysignalLab()

/* --------------------------------------------------------------------------------- */
/* INITIALISE_DIR_REC                                                                */
/*              INITIALATES THE DIRECTORY RECORDS.                                   */
/* --------------------------------------------------------------------------------- */
void Dbacc::initialiseDirRec(Signal* signal) 
{
  DirectoryarrayPtr idrDirptr;
  ndbrequire(cdirarraysize > 0);
  for (idrDirptr.i = 0; idrDirptr.i < cdirarraysize; idrDirptr.i++) {
    refresh_watch_dog();
    ptrAss(idrDirptr, directoryarray);
    for (Uint32 i = 0; i <= 255; i++) {
      idrDirptr.p->pagep[i] = RNIL;
    }//for
  }//for
  cdirmemory = 0;
  cfirstfreedir = RNIL;
}//Dbacc::initialiseDirRec()

/* --------------------------------------------------------------------------------- */
/* INITIALISE_DIR_RANGE_REC                                                          */
/*              INITIALATES THE DIR_RANGE RECORDS.                                   */
/* --------------------------------------------------------------------------------- */
void Dbacc::initialiseDirRangeRec(Signal* signal) 
{
  DirRangePtr idrDirRangePtr;

  ndbrequire(cdirrangesize > 0);
  for (idrDirRangePtr.i = 0; idrDirRangePtr.i < cdirrangesize; idrDirRangePtr.i++) {
    refresh_watch_dog();
    ptrAss(idrDirRangePtr, dirRange);
    idrDirRangePtr.p->dirArray[0] = idrDirRangePtr.i + 1;
    for (Uint32 i = 1; i < 256; i++) {
      idrDirRangePtr.p->dirArray[i] = RNIL;
    }//for
  }//for
  idrDirRangePtr.i = cdirrangesize - 1;
  ptrAss(idrDirRangePtr, dirRange);
  idrDirRangePtr.p->dirArray[0] = RNIL;
  cfirstfreeDirrange = 0;
}//Dbacc::initialiseDirRangeRec()

/* --------------------------------------------------------------------------------- */
/* INITIALISE_FRAG_REC                                                               */
/*              INITIALATES THE FRAGMENT RECORDS.                                    */
/* --------------------------------------------------------------------------------- */
void Dbacc::initialiseFragRec(Signal* signal) 
{
  FragmentrecPtr regFragPtr;
  ndbrequire(cfragmentsize > 0);
  for (regFragPtr.i = 0; regFragPtr.i < cfragmentsize; regFragPtr.i++) {
    jam();
    refresh_watch_dog();
    ptrAss(regFragPtr, fragmentrec);
    initFragGeneral(regFragPtr);
    regFragPtr.p->nextfreefrag = regFragPtr.i + 1;
  }//for
  regFragPtr.i = cfragmentsize - 1;
  ptrAss(regFragPtr, fragmentrec);
  regFragPtr.p->nextfreefrag = RNIL;
  cfirstfreefrag = 0;
}//Dbacc::initialiseFragRec()

/* --------------------------------------------------------------------------------- */
/* INITIALISE_FS_CONNECTION_REC                                                      */
/*              INITIALATES THE FS_CONNECTION RECORDS                                */
/* --------------------------------------------------------------------------------- */
void Dbacc::initialiseFsConnectionRec(Signal* signal) 
{
  ndbrequire(cfsConnectsize > 0);
  for (fsConnectptr.i = 0; fsConnectptr.i < cfsConnectsize; fsConnectptr.i++) {
    ptrAss(fsConnectptr, fsConnectrec);
    fsConnectptr.p->fsNext = fsConnectptr.i + 1;
    fsConnectptr.p->fsPrev = RNIL;
    fsConnectptr.p->fragrecPtr = RNIL;
    fsConnectptr.p->fsState = WAIT_NOTHING;
  }//for
  fsConnectptr.i = cfsConnectsize - 1;
  ptrAss(fsConnectptr, fsConnectrec);
  fsConnectptr.p->fsNext = RNIL;	/* INITIALITES THE LAST CONNECTRECORD */
  cfsFirstfreeconnect = 0;	/* INITIATES THE FIRST FREE CONNECT RECORD */
}//Dbacc::initialiseFsConnectionRec()

/* --------------------------------------------------------------------------------- */
/* INITIALISE_FS_OP_REC                                                              */
/*              INITIALATES THE FS_OP RECORDS                                        */
/* --------------------------------------------------------------------------------- */
void Dbacc::initialiseFsOpRec(Signal* signal) 
{
  ndbrequire(cfsOpsize > 0);
  for (fsOpptr.i = 0; fsOpptr.i < cfsOpsize; fsOpptr.i++) {
    ptrAss(fsOpptr, fsOprec);
    fsOpptr.p->fsOpnext = fsOpptr.i + 1;
    fsOpptr.p->fsOpfragrecPtr = RNIL;
    fsOpptr.p->fsConptr = RNIL;
    fsOpptr.p->fsOpstate = WAIT_NOTHING;
  }//for
  fsOpptr.i = cfsOpsize - 1;
  ptrAss(fsOpptr, fsOprec);
  fsOpptr.p->fsOpnext = RNIL;
  cfsFirstfreeop = 0;
}//Dbacc::initialiseFsOpRec()

/* --------------------------------------------------------------------------------- */
/* INITIALISE_LCP_CONNECTION_REC                                                     */
/*              INITIALATES THE LCP_CONNECTION RECORDS                               */
/* --------------------------------------------------------------------------------- */
void Dbacc::initialiseLcpConnectionRec(Signal* signal) 
{
  ndbrequire(clcpConnectsize > 0);
  for (lcpConnectptr.i = 0; lcpConnectptr.i < clcpConnectsize; lcpConnectptr.i++) {
    ptrAss(lcpConnectptr, lcpConnectrec);
    lcpConnectptr.p->nextLcpConn = lcpConnectptr.i + 1;
    lcpConnectptr.p->lcpUserptr = RNIL;
    lcpConnectptr.p->rootrecptr = RNIL;
    lcpConnectptr.p->lcpstate = LCP_FREE;
  }//for
  lcpConnectptr.i = clcpConnectsize - 1;
  ptrAss(lcpConnectptr, lcpConnectrec);
  lcpConnectptr.p->nextLcpConn = RNIL;
  cfirstfreelcpConnect = 0;
}//Dbacc::initialiseLcpConnectionRec()

/* --------------------------------------------------------------------------------- */
/* INITIALISE_OPERATION_REC                                                          */
/*              INITIALATES THE OPERATION RECORDS.                                   */
/* --------------------------------------------------------------------------------- */
void Dbacc::initialiseOperationRec(Signal* signal) 
{
  ndbrequire(coprecsize > 0);
  for (operationRecPtr.i = 0; operationRecPtr.i < coprecsize; operationRecPtr.i++) {
    refresh_watch_dog();
    ptrAss(operationRecPtr, operationrec);
    operationRecPtr.p->transactionstate = IDLE;
    operationRecPtr.p->operation = ZUNDEFINED_OP;
    operationRecPtr.p->opState = FREE_OP;
    operationRecPtr.p->nextOp = operationRecPtr.i + 1;
  }//for
  operationRecPtr.i = coprecsize - 1;
  ptrAss(operationRecPtr, operationrec);
  operationRecPtr.p->nextOp = RNIL;
  cfreeopRec = 0;
}//Dbacc::initialiseOperationRec()

/* --------------------------------------------------------------------------------- */
/* INITIALISE_OVERFLOW_REC                                                           */
/*              INITIALATES THE OVERFLOW RECORDS                                     */
/* --------------------------------------------------------------------------------- */
void Dbacc::initialiseOverflowRec(Signal* signal) 
{
  OverflowRecordPtr iorOverflowRecPtr;

  ndbrequire(coverflowrecsize > 0);
  for (iorOverflowRecPtr.i = 0; iorOverflowRecPtr.i < coverflowrecsize; iorOverflowRecPtr.i++) {
    refresh_watch_dog();
    ptrAss(iorOverflowRecPtr, overflowRecord);
    iorOverflowRecPtr.p->nextfreeoverrec = iorOverflowRecPtr.i + 1;
  }//for
  iorOverflowRecPtr.i = coverflowrecsize - 1;
  ptrAss(iorOverflowRecPtr, overflowRecord);
  iorOverflowRecPtr.p->nextfreeoverrec = RNIL;
  cfirstfreeoverrec = 0;
}//Dbacc::initialiseOverflowRec()

/* --------------------------------------------------------------------------------- */
/* INITIALISE_PAGE_REC                                                               */
/*              INITIALATES THE PAGE RECORDS.                                        */
/* --------------------------------------------------------------------------------- */
void Dbacc::initialisePageRec(Signal* signal) 
{
  ndbrequire(cpagesize > 0);
  cfreepage = 0;
  cfirstfreepage = RNIL;
  cnoOfAllocatedPages = 0;
}//Dbacc::initialisePageRec()

/* --------------------------------------------------------------------------------- */
/* INITIALISE_LCP_PAGES                                                              */
/*              INITIALATES THE LCP PAGE RECORDS.                                    */
/* --------------------------------------------------------------------------------- */
void Dbacc::initialiseLcpPages(Signal* signal) 
{
  Uint32 tilpIndex;

  ndbrequire(cnoLcpPages >= (2 * (ZWRITEPAGESIZE + 1)));
  /* --------------------------------------------------------------------------------- */
  /*       AN ABSOLUTE MINIMUM IS THAT WE HAVE 16 LCP PAGES TO HANDLE TWO CONCURRENT   */
  /*       LCP'S ON LOCAL FRAGMENTS.                                                   */
  /* --------------------------------------------------------------------------------- */
  ndbrequire(cpagesize >= (cnoLcpPages + 8));
  /* --------------------------------------------------------------------------------- */
  /*       THE NUMBER OF PAGES MUST BE AT LEAST 8 PLUS THE NUMBER OF PAGES REQUIRED BY */
  /*       THE LOCAL CHECKPOINT PROCESS. THIS NUMBER IS 8 TIMES THE PARALLELISM OF     */
  /*       LOCAL CHECKPOINTS.                                                          */
  /* --------------------------------------------------------------------------------- */
  /* --------------------------------------------------------------------------------- */
  /*       WE SET UP A LINKED LIST OF PAGES FOR EXCLUSIVE USE BY LOCAL CHECKPOINTS.    */
  /* --------------------------------------------------------------------------------- */
  cfirstfreeLcpPage = RNIL;
  for (tilpIndex = 0; tilpIndex < cnoLcpPages; tilpIndex++) {
    jam();
    seizePage(signal);
    rlpPageptr = spPageptr;
    releaseLcpPage(signal);
  }//for
}//Dbacc::initialiseLcpPages()

/* --------------------------------------------------------------------------------- */
/* INITIALISE_ROOTFRAG_REC                                                           */
/*              INITIALATES THE ROOTFRAG  RECORDS.                                   */
/* --------------------------------------------------------------------------------- */
void Dbacc::initialiseRootfragRec(Signal* signal) 
{
  ndbrequire(crootfragmentsize > 0);
  for (rootfragrecptr.i = 0; rootfragrecptr.i < crootfragmentsize; rootfragrecptr.i++) {
    refresh_watch_dog();
    ptrAss(rootfragrecptr, rootfragmentrec);
    rootfragrecptr.p->nextroot = rootfragrecptr.i + 1;
    rootfragrecptr.p->fragmentptr[0] = RNIL;
    rootfragrecptr.p->fragmentptr[1] = RNIL;
  }//for
  rootfragrecptr.i = crootfragmentsize - 1;
  ptrAss(rootfragrecptr, rootfragmentrec);
  rootfragrecptr.p->nextroot = RNIL;
  cfirstfreerootfrag = 0;
}//Dbacc::initialiseRootfragRec()

/* --------------------------------------------------------------------------------- */
/* INITIALISE_SCAN_REC                                                               */
/*              INITIALATES THE QUE_SCAN RECORDS.                                    */
/* --------------------------------------------------------------------------------- */
void Dbacc::initialiseScanRec(Signal* signal) 
{
  ndbrequire(cscanRecSize > 0);
  for (scanPtr.i = 0; scanPtr.i < cscanRecSize; scanPtr.i++) {
    ptrAss(scanPtr, scanRec);
    scanPtr.p->scanNextfreerec = scanPtr.i + 1;
    scanPtr.p->scanState = ScanRec::SCAN_DISCONNECT;
    scanPtr.p->scanTimer = 0;
    scanPtr.p->scanContinuebCounter = 0;
  }//for
  scanPtr.i = cscanRecSize - 1;
  ptrAss(scanPtr, scanRec);
  scanPtr.p->scanNextfreerec = RNIL;
  cfirstFreeScanRec = 0;
}//Dbacc::initialiseScanRec()

/* --------------------------------------------------------------------------------- */
/* INITIALISE_SR_VER_REC                                                             */
/* --------------------------------------------------------------------------------- */
void Dbacc::initialiseSrVerRec(Signal* signal) 
{
  ndbrequire(csrVersionRecSize > 0);
  for (srVersionPtr.i = 0; srVersionPtr.i < csrVersionRecSize; srVersionPtr.i++) {
    ptrAss(srVersionPtr, srVersionRec);
    srVersionPtr.p->nextFreeSr = srVersionPtr.i + 1;
  }//for
  srVersionPtr.i = csrVersionRecSize - 1;
  ptrAss(srVersionPtr, srVersionRec);
  srVersionPtr.p->nextFreeSr = RNIL;
  cfirstFreeSrVersionRec = 0;
}//Dbacc::initialiseSrVerRec()

/* --------------------------------------------------------------------------------- */
/* INITIALISE_TABLE_REC                                                              */
/*              INITIALATES THE TABLE RECORDS.                                       */
/* --------------------------------------------------------------------------------- */
void Dbacc::initialiseTableRec(Signal* signal) 
{
  ndbrequire(ctablesize > 0);
  for (tabptr.i = 0; tabptr.i < ctablesize; tabptr.i++) {
    refresh_watch_dog();
    ptrAss(tabptr, tabrec);
    for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) {
      tabptr.p->fragholder[i] = RNIL;
      tabptr.p->fragptrholder[i] = RNIL;
    }//for
  }//for
}//Dbacc::initialiseTableRec()

/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */
/*                                                                                   */
/*       END OF SYSTEM RESTART MODULE                                                */
/*                                                                                   */
/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */
/*                                                                                   */
/*       ADD/DELETE FRAGMENT MODULE                                                  */
/*                                                                                   */
/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */

void Dbacc::initRootfragrec(Signal* signal)
{
  const AccFragReq * const req = (AccFragReq*)&signal->theData[0];  
  rootfragrecptr.p->mytabptr = req->tableId;
  rootfragrecptr.p->roothashcheck = req->kValue + req->lhFragBits;
  rootfragrecptr.p->noOfElements = 0;
  rootfragrecptr.p->m_commit_count = 0;
  for (Uint32 i = 0; i < MAX_PARALLEL_SCANS_PER_FRAG; i++) {
    rootfragrecptr.p->scan[i] = RNIL;
  }//for
}//Dbacc::initRootfragrec()

void Dbacc::execACCFRAGREQ(Signal* signal) 
{
  const AccFragReq * const req = (AccFragReq*)&signal->theData[0];
  jamEntry();
  if (ERROR_INSERTED(3001)) {
    jam();
    addFragRefuse(signal, 1);
    CLEAR_ERROR_INSERT_VALUE;
    return;
  }
  tabptr.i = req->tableId;
#ifndef VM_TRACE
  // config mismatch - do not crash if release compiled
  if (tabptr.i >= ctablesize) {
    jam();
    addFragRefuse(signal, 640);
    return;
  }
#endif
  ptrCheckGuard(tabptr, ctablesize, tabrec);
  ndbrequire((req->reqInfo & 0xF) == ZADDFRAG);
  ndbrequire(!getrootfragmentrec(signal, rootfragrecptr, req->fragId));
  if (cfirstfreerootfrag == RNIL) {
    jam();
    addFragRefuse(signal, ZFULL_ROOTFRAGRECORD_ERROR);
    return;
  }//if
  seizeRootfragrec(signal);
  if (!addfragtotab(signal, rootfragrecptr.i, req->fragId)) {
    jam();
    releaseRootFragRecord(signal, rootfragrecptr);
    addFragRefuse(signal, ZFULL_ROOTFRAGRECORD_ERROR);
    return;
  }//if
  initRootfragrec(signal);
  for (Uint32 i = 0; i < 2; i++) {
    jam();
    if (cfirstfreefrag == RNIL) {
      jam();