dbaccmain.cpp

mysql-5.0.22.tar.gz源码包

      addFragRefuse(signal, ZFULL_FRAGRECORD_ERROR);
      return;
    }//if
    seizeFragrec(signal);
    initFragGeneral(fragrecptr);
    initFragAdd(signal, i, rootfragrecptr.i, fragrecptr);
    rootfragrecptr.p->fragmentptr[i] = fragrecptr.i;
    rootfragrecptr.p->fragmentid[i] = fragrecptr.p->myfid;
    if (cfirstfreeDirrange == RNIL) {
      jam();
      addFragRefuse(signal, ZDIR_RANGE_ERROR);
      return;
    } else {
      jam();
      seizeDirrange(signal);
    }//if
    fragrecptr.p->directory = newDirRangePtr.i;
    seizeDirectory(signal);
    if (tresult < ZLIMIT_OF_ERROR) {
      jam();
      newDirRangePtr.p->dirArray[0] = sdDirptr.i;
    } else {
      jam();
      addFragRefuse(signal, tresult);
      return;
    }//if
    seizePage(signal);
    if (tresult > ZLIMIT_OF_ERROR) {
      jam();
      addFragRefuse(signal, tresult);
      return;
    }//if
    sdDirptr.p->pagep[0] = spPageptr.i;
    tipPageId = 0;
    inpPageptr = spPageptr;
    initPage(signal);
    if (cfirstfreeDirrange == RNIL) {
      jam();
      addFragRefuse(signal, ZDIR_RANGE_ERROR);
      return;
    } else {
      jam();
      seizeDirrange(signal);
    }//if
    fragrecptr.p->overflowdir = newDirRangePtr.i;
    seizeDirectory(signal);
    if (tresult < ZLIMIT_OF_ERROR) {
      jam();
      newDirRangePtr.p->dirArray[0] = sdDirptr.i;
    } else {
      jam();
      addFragRefuse(signal, tresult);
      return;
    }//if
  }//for
  Uint32 userPtr = req->userPtr;
  BlockReference retRef = req->userRef;
  rootfragrecptr.p->rootState = ACTIVEROOT;

  AccFragConf * const conf = (AccFragConf*)&signal->theData[0];
  conf->userPtr = userPtr;
  conf->rootFragPtr = rootfragrecptr.i;
  conf->fragId[0] = rootfragrecptr.p->fragmentid[0];
  conf->fragId[1] = rootfragrecptr.p->fragmentid[1];
  conf->fragPtr[0] = rootfragrecptr.p->fragmentptr[0];
  conf->fragPtr[1] = rootfragrecptr.p->fragmentptr[1];
  conf->rootHashCheck = rootfragrecptr.p->roothashcheck;
  sendSignal(retRef, GSN_ACCFRAGCONF, signal, AccFragConf::SignalLength, JBB);
}//Dbacc::execACCFRAGREQ()

void Dbacc::addFragRefuse(Signal* signal, Uint32 errorCode) 
{
  const AccFragReq * const req = (AccFragReq*)&signal->theData[0];  
  AccFragRef * const ref = (AccFragRef*)&signal->theData[0];  
  Uint32 userPtr = req->userPtr;
  BlockReference retRef = req->userRef;

  ref->userPtr = userPtr;
  ref->errorCode = errorCode;
  sendSignal(retRef, GSN_ACCFRAGREF, signal, AccFragRef::SignalLength, JBB);
  return;
}//Dbacc::addFragRefuseEarly()


void
Dbacc::execDROP_TAB_REQ(Signal* signal){
  jamEntry();
  DropTabReq* req = (DropTabReq*)signal->getDataPtr();

  TabrecPtr tabPtr;
  tabPtr.i = req->tableId;
  ptrCheckGuard(tabPtr, ctablesize, tabrec);
  
  tabPtr.p->tabUserRef = req->senderRef;
  tabPtr.p->tabUserPtr = req->senderData;
  
  signal->theData[0] = ZREL_ROOT_FRAG;
  signal->theData[1] = tabPtr.i;
  sendSignal(cownBlockref, GSN_CONTINUEB, signal, 2, JBB);
}

void Dbacc::releaseRootFragResources(Signal* signal, Uint32 tableId)
{
  RootfragmentrecPtr rootPtr;
  TabrecPtr tabPtr;
  tabPtr.i = tableId;
  ptrCheckGuard(tabPtr, ctablesize, tabrec);
  for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) {
    jam();
    if (tabPtr.p->fragholder[i] != RNIL) {
      jam();
      Uint32 fragIndex;
      rootPtr.i = tabPtr.p->fragptrholder[i];
      ptrCheckGuard(rootPtr, crootfragmentsize, rootfragmentrec);
      if (rootPtr.p->fragmentptr[0] != RNIL) {
        jam();
        fragIndex = rootPtr.p->fragmentptr[0];
        rootPtr.p->fragmentptr[0] = RNIL;
      } else if (rootPtr.p->fragmentptr[1] != RNIL) {
        jam();
        fragIndex = rootPtr.p->fragmentptr[1];
        rootPtr.p->fragmentptr[1] = RNIL;
      } else {
        jam();
        releaseRootFragRecord(signal, rootPtr);
        tabPtr.p->fragholder[i] = RNIL;
        tabPtr.p->fragptrholder[i] = RNIL;
        continue;
      }//if
      releaseFragResources(signal, fragIndex);
      return;
    }//if
  }//for

  /**
   * Finished...
   */
  sendFSREMOVEREQ(signal, tableId);  
}//Dbacc::releaseRootFragResources()

void Dbacc::releaseRootFragRecord(Signal* signal, RootfragmentrecPtr rootPtr)
{
  rootPtr.p->nextroot = cfirstfreerootfrag;
  cfirstfreerootfrag = rootPtr.i;
}//Dbacc::releaseRootFragRecord()

void Dbacc::releaseFragResources(Signal* signal, Uint32 fragIndex)
{
  FragmentrecPtr regFragPtr;
  regFragPtr.i = fragIndex;
  ptrCheckGuard(regFragPtr, cfragmentsize, fragmentrec);
  verifyFragCorrect(regFragPtr);
  if (regFragPtr.p->directory != RNIL) {
    jam();
    releaseDirResources(signal, regFragPtr.i, regFragPtr.p->directory, 0);
    regFragPtr.p->directory = RNIL;
  } else if (regFragPtr.p->overflowdir != RNIL) {
    jam();
    releaseDirResources(signal, regFragPtr.i, regFragPtr.p->overflowdir, 0);
    regFragPtr.p->overflowdir = RNIL;
  } else if (regFragPtr.p->firstOverflowRec != RNIL) {
    jam();
    releaseOverflowResources(signal, regFragPtr);
  } else if (regFragPtr.p->firstFreeDirindexRec != RNIL) {
    jam();
    releaseDirIndexResources(signal, regFragPtr);
  } else {
    RootfragmentrecPtr rootPtr;
    jam();
    rootPtr.i = regFragPtr.p->myroot;
    ptrCheckGuard(rootPtr, crootfragmentsize, rootfragmentrec);    
    releaseFragRecord(signal, regFragPtr);
    signal->theData[0] = ZREL_ROOT_FRAG;
    signal->theData[1] = rootPtr.p->mytabptr;
    sendSignal(cownBlockref, GSN_CONTINUEB, signal, 2, JBB);
  }//if
}//Dbacc::releaseFragResources()

void Dbacc::verifyFragCorrect(FragmentrecPtr regFragPtr)
{
  for (Uint32 i = 0; i < ZWRITEPAGESIZE; i++) {
    jam();
    ndbrequire(regFragPtr.p->datapages[i] == RNIL);
  }//for
  ndbrequire(regFragPtr.p->lockOwnersList == RNIL);
  ndbrequire(regFragPtr.p->firstWaitInQueOp == RNIL);
  ndbrequire(regFragPtr.p->lastWaitInQueOp == RNIL);
  ndbrequire(regFragPtr.p->sentWaitInQueOp == RNIL);
  //ndbrequire(regFragPtr.p->fsConnPtr == RNIL);
  ndbrequire(regFragPtr.p->zeroPagePtr == RNIL);
  ndbrequire(regFragPtr.p->nrWaitWriteUndoExit == 0);
  ndbrequire(regFragPtr.p->sentWaitInQueOp == RNIL);
}//Dbacc::verifyFragCorrect()

void Dbacc::releaseDirResources(Signal* signal, 
				Uint32 fragIndex, 
				Uint32 dirIndex, 
				Uint32 startIndex)
{
  DirRangePtr regDirRangePtr;
  regDirRangePtr.i = dirIndex;
  ptrCheckGuard(regDirRangePtr, cdirrangesize, dirRange);
  for (Uint32 i = startIndex; i < 256; i++) {
    jam();
    if (regDirRangePtr.p->dirArray[i] != RNIL) {
      jam();
      Uint32 directoryIndex = regDirRangePtr.p->dirArray[i];
      regDirRangePtr.p->dirArray[i] = RNIL;
      releaseDirectoryResources(signal, fragIndex, dirIndex, (i + 1), directoryIndex);
      return;
    }//if
  }//for
  rdDirRangePtr = regDirRangePtr;
  releaseDirrange(signal);
  signal->theData[0] = ZREL_FRAG;
  signal->theData[1] = fragIndex;
  sendSignal(cownBlockref, GSN_CONTINUEB, signal, 2, JBB);
}//Dbacc::releaseDirResources()

void Dbacc::releaseDirectoryResources(Signal* signal,
                                      Uint32 fragIndex,
                                      Uint32 dirIndex,
                                      Uint32 startIndex,
                                      Uint32 directoryIndex)
{
  DirectoryarrayPtr regDirPtr;
  regDirPtr.i = directoryIndex;
  ptrCheckGuard(regDirPtr, cdirarraysize, directoryarray);
  for (Uint32 i = 0; i < 256; i++) {
    jam();
    if (regDirPtr.p->pagep[i] != RNIL) {
      jam();
      rpPageptr.i = regDirPtr.p->pagep[i];
      ptrCheckGuard(rpPageptr, cpagesize, page8);
      releasePage(signal);
      regDirPtr.p->pagep[i] = RNIL;
    }//if
  }//for
  rdDirptr = regDirPtr;
  releaseDirectory(signal);
  signal->theData[0] = ZREL_DIR;
  signal->theData[1] = fragIndex;
  signal->theData[2] = dirIndex;
  signal->theData[3] = startIndex;
  sendSignal(cownBlockref, GSN_CONTINUEB, signal, 4, JBB);
}//Dbacc::releaseDirectoryResources()

void Dbacc::releaseOverflowResources(Signal* signal, FragmentrecPtr regFragPtr)
{
  Uint32 loopCount = 0;
  OverflowRecordPtr regOverflowRecPtr;
  while ((regFragPtr.p->firstOverflowRec != RNIL) &&
         (loopCount < 1)) {
    jam();
    regOverflowRecPtr.i = regFragPtr.p->firstOverflowRec;
    ptrCheckGuard(regOverflowRecPtr, coverflowrecsize, overflowRecord);
    regFragPtr.p->firstOverflowRec = regOverflowRecPtr.p->nextOverRec;
    rorOverflowRecPtr = regOverflowRecPtr;
    releaseOverflowRec(signal);
    loopCount++;
  }//while
  signal->theData[0] = ZREL_FRAG;
  signal->theData[1] = regFragPtr.i;
  sendSignal(cownBlockref, GSN_CONTINUEB, signal, 2, JBB);
}//Dbacc::releaseOverflowResources()

void Dbacc::releaseDirIndexResources(Signal* signal, FragmentrecPtr regFragPtr)
{
  Uint32 loopCount = 0;
  OverflowRecordPtr regOverflowRecPtr;
  while ((regFragPtr.p->firstFreeDirindexRec != RNIL) &&
         (loopCount < 1)) {
    jam();
    regOverflowRecPtr.i = regFragPtr.p->firstFreeDirindexRec;
    ptrCheckGuard(regOverflowRecPtr, coverflowrecsize, overflowRecord);
    regFragPtr.p->firstFreeDirindexRec = regOverflowRecPtr.p->nextOverList;
    rorOverflowRecPtr = regOverflowRecPtr;
    releaseOverflowRec(signal);
    loopCount++;
  }//while
  signal->theData[0] = ZREL_FRAG;
  signal->theData[1] = regFragPtr.i;
  sendSignal(cownBlockref, GSN_CONTINUEB, signal, 2, JBB);
}//Dbacc::releaseDirIndexResources()

void Dbacc::releaseFragRecord(Signal* signal, FragmentrecPtr regFragPtr) 
{
  regFragPtr.p->nextfreefrag = cfirstfreefrag;
  cfirstfreefrag = regFragPtr.i;
  initFragGeneral(regFragPtr);
}//Dbacc::releaseFragRecord()

void Dbacc::sendFSREMOVEREQ(Signal* signal, Uint32 tableId)
{
  FsRemoveReq * const fsReq = (FsRemoveReq *)signal->getDataPtrSend();
  fsReq->userReference = cownBlockref;
  fsReq->userPointer = tableId;
  fsReq->fileNumber[0] = tableId;
  fsReq->fileNumber[1] = (Uint32)-1; // Remove all fragments
  fsReq->fileNumber[2] = (Uint32)-1; // Remove all data files within fragment
  fsReq->fileNumber[3] = 255 |       // No P-value used here
    (3 << 8) |  // Data-files in D3
    (0 << 16) | // Data-files
    (1 << 24);  // Version 1 of fileNumber
  fsReq->directory = 1;
  fsReq->ownDirectory = 1;
  sendSignal(NDBFS_REF, GSN_FSREMOVEREQ, signal, FsRemoveReq::SignalLength, JBA);  
}//Dbacc::sendFSREMOVEREQ()

void Dbacc::execFSREMOVECONF(Signal* signal)
{
  FsConf * const fsConf = (FsConf *)signal->getDataPtrSend();
  TabrecPtr tabPtr;
  tabPtr.i = fsConf->userPointer;
  ptrCheckGuard(tabPtr, ctablesize, tabrec);

  DropTabConf * const dropConf = (DropTabConf *)signal->getDataPtrSend();
  dropConf->senderRef = reference();
  dropConf->senderData = tabPtr.p->tabUserPtr;
  dropConf->tableId = tabPtr.i;
  sendSignal(tabPtr.p->tabUserRef, GSN_DROP_TAB_CONF,
             signal, DropTabConf::SignalLength, JBB);
  
  tabPtr.p->tabUserPtr = RNIL;
  tabPtr.p->tabUserRef = 0;
}//Dbacc::execFSREMOVECONF()


/* -------------------------------------------------------------------------- */
/* ADDFRAGTOTAB                                                               */
/*       DESCRIPTION: PUTS A FRAGMENT ID AND A POINTER TO ITS RECORD INTO     */
/*                                TABLE ARRRAY OF THE TABLE RECORD.           */
/* -------------------------------------------------------------------------- */
bool Dbacc::addfragtotab(Signal* signal, Uint32 rootIndex, Uint32 fid) 
{
  for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) {
    jam();
    if (tabptr.p->fragholder[i] == RNIL) {
      jam();
      tabptr.p->fragholder[i] = fid;
      tabptr.p->fragptrholder[i] = rootIndex;
      return true;
    }//if
  }//for
  return false;
}//Dbacc::addfragtotab()

/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */
/*                                                                                   */
/*       END OF ADD/DELETE FRAGMENT MODULE                                           */
/*                                                                                   */
/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */
/*                                                                                   */
/*       CONNECTION MODULE                                                           */
/*                                                                                   */
/* --------------------------------------------------------------------------------- */