dbtupsystemrestart.cpp

mysql-5.0.22.tar.gz源码包

  clqhBlockref = signal->theData[1];

  for (int i = 0; i < ZNO_CHECKPOINT_RECORDS; i++){
    cSrUndoRecords[i] = 0;
  }//for

  if (cnoOfLocalLogInfo == 0) {
    ljam();
/* ---------------------------------------------------------------- */
/*       THERE WERE NO LOCAL LOGS TO EXECUTE IN THIS SYSTEM RESTART */
/* ---------------------------------------------------------------- */
    xlcRestartCompletedLab(signal);
    return;
  }//if
  LocalLogInfoPtr lliPtr;
  for (lliPtr.i = 0; lliPtr.i < 16; lliPtr.i++) {
    ljam();
    ptrAss(lliPtr, localLogInfo);
    if (lliPtr.p->lliActiveLcp == 1) {
      ljam();
      signal->theData[0] = ZSTART_EXEC_UNDO_LOG;
      signal->theData[1] = lliPtr.i;
      sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);
    }//if
  }//for
  return;
}//Dbtup::execSTART_RECREQ()

void Dbtup::closeExecUndoLogLab(Signal* signal, LocalLogInfoPtr lliPtr) 
{
  PendingFileOpenInfoPtr pfoPtr;
/* ---------------------------------------------------------------------- */
/*       CLOSE THE UNDO LOG BEFORE COMPLETION OF THE SYSTEM RESTART       */
/* ---------------------------------------------------------------------- */
  seizePendingFileOpenInfoRecord(pfoPtr);
  pfoPtr.p->pfoOpenType = LCP_UNDO_FILE_READ;
  pfoPtr.p->pfoCheckpointInfoP = lliPtr.i;

  signal->theData[0] = lliPtr.p->lliUndoFileHandle;
  signal->theData[1] = cownref;
  signal->theData[2] = pfoPtr.i;
  signal->theData[3] = 0;
  sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA);
  return;
}//Dbtup::closeExecUndoLogLab()

void Dbtup::endExecUndoLogLab(Signal* signal, Uint32 lliIndex) 
{
  DiskBufferSegmentInfoPtr dbsiPtr;
  LocalLogInfoPtr lliPtr;

  lliPtr.i = lliIndex;
  ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  lliPtr.p->lliUndoFileHandle = RNIL;
  lliPtr.p->lliActiveLcp = 0;
/* ---------------------------------------------------------------------- */
/*       WE HAVE NOW CLOSED THE LOG. WE WAIT FOR ALL LOCAL LOGS TO        */
/*       COMPLETE LOG EXECUTION BEFORE SENDING THE RESPONSE TO LQH.       */
/* ---------------------------------------------------------------------- */
  dbsiPtr.i = lliPtr.p->lliUndoBufferSegmentP;
  ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
  freeDiskBufferSegmentRecord(signal, dbsiPtr);
  lliPtr.p->lliUndoBufferSegmentP = RNIL;
  for (lliPtr.i = 0; lliPtr.i < 16; lliPtr.i++) {
    ljam();
    ptrAss(lliPtr, localLogInfo);
    if (lliPtr.p->lliActiveLcp == 1) {
      ljam();
      return;
    }//if
  }//for
  xlcRestartCompletedLab(signal);
  return;
}//Dbtup::endExecUndoLogLab()

void Dbtup::xlcRestartCompletedLab(Signal* signal) 
{
  cnoOfLocalLogInfo = 0;

  signal->theData[0] = NDB_LE_UNDORecordsExecuted;
  signal->theData[1] = DBTUP; // From block
  signal->theData[2] = 0;     // Total records executed
  for (int i = 0; i < 10; i++) {
    if (i < ZNO_CHECKPOINT_RECORDS){
      signal->theData[i+3] = cSrUndoRecords[i];
      signal->theData[2] += cSrUndoRecords[i]; 
    } else {
      signal->theData[i+3] = 0; // Unsused data
    }//if
  }//for
  sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 12, JBB);

/* ---------------------------------------------------------------------- */
/*       ALL LOCAL LOGS HAVE COMPLETED. WE HAVE COMPLETED OUR PART OF THE */
/*       SYSTEM RESTART.                                                  */
/* ---------------------------------------------------------------------- */
  signal->theData[0] = clqhUserpointer;
  sendSignal(clqhBlockref, GSN_START_RECCONF, signal, 1, JBB);
  return;
}//Dbtup::xlcRestartCompletedLab()

void Dbtup::startExecUndoLogLab(Signal* signal, Uint32 lliIndex) 
{
  DiskBufferSegmentInfoPtr dbsiPtr;
  LocalLogInfoPtr lliPtr;

/* ---------------------------------------------------------------------- */
/*       START EXECUTING THE LOG FOR THIS PART. WE BEGIN BY READING THE   */
/*       LAST 16 PAGES.                                                   */
/* ---------------------------------------------------------------------- */
   /* SET THE PREVIOS RECORD TO THE LAST ONE BECAUSE THAT'S WHERE TO START */
  lliPtr.i = lliIndex;
  ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);

  allocRestartUndoBufferSegment(signal, dbsiPtr, lliPtr);
  lliPtr.p->lliUndoBufferSegmentP = dbsiPtr.i;
  dbsiPtr.p->pdxCheckpointInfoP = lliPtr.i;
  if (lliPtr.p->lliEndPageId > ((2 * ZUB_SEGMENT_SIZE) - 1)) {
    ljam();
    dbsiPtr.p->pdxNumDataPages = ZUB_SEGMENT_SIZE;
    dbsiPtr.p->pdxFilePage = lliPtr.p->lliEndPageId - (ZUB_SEGMENT_SIZE - 1);
  } else if (lliPtr.p->lliEndPageId > (ZUB_SEGMENT_SIZE - 1)) {
    ljam();
    dbsiPtr.p->pdxNumDataPages = lliPtr.p->lliEndPageId - (ZUB_SEGMENT_SIZE - 1);
    dbsiPtr.p->pdxFilePage = ZUB_SEGMENT_SIZE;
  } else {
    ljam();
    dbsiPtr.p->pdxNumDataPages = lliPtr.p->lliEndPageId + 1;
    dbsiPtr.p->pdxFilePage = 0;
    rfrReadNextUndoSegment(signal, dbsiPtr, lliPtr);
    return;
  }//if
  rfrReadFirstUndoSegment(signal, dbsiPtr, lliPtr);
  return;
}//Dbtup::startExecUndoLogLab()

void Dbtup::rfrReadSecondUndoLogLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr) 
{
  LocalLogInfoPtr lliPtr;
  lliPtr.i = dbsiPtr.p->pdxCheckpointInfoP;
  ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);

  dbsiPtr.p->pdxNumDataPages = ZUB_SEGMENT_SIZE;
  dbsiPtr.p->pdxFilePage -= ZUB_SEGMENT_SIZE;
  rfrReadNextUndoSegment(signal, dbsiPtr, lliPtr);
  return;
}//Dbtup::rfrReadSecondUndoLogLab()

void Dbtup::readExecUndoLogLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr) 
{
/* ---------------------------------------------------------------------- */
/*       THE NEXT UNDO LOG RECORD HAS NOT BEEN READ FROM DISK YET. WE WILL*/
/*       READ UPTO 8 PAGES BACKWARDS OF THE UNDO LOG FILE. WE WILL KEEP   */
/*       THE LAST 8 PAGES TO ENSURE THAT WE WILL BE ABLE TO READ THE NEXT */
/*       LOG RECORD EVEN IF IT SPANS UPTO 8 PAGES.                        */
/* ---------------------------------------------------------------------- */
  if (dbsiPtr.p->pdxFilePage >= ZUB_SEGMENT_SIZE) {
    ljam();
    for (Uint32 i = 0; i < ZUB_SEGMENT_SIZE; i++) {
      ljam();
      Uint32 savePageId = dbsiPtr.p->pdxDataPage[i + ZUB_SEGMENT_SIZE];
      dbsiPtr.p->pdxDataPage[i + ZUB_SEGMENT_SIZE] = dbsiPtr.p->pdxDataPage[i];
      dbsiPtr.p->pdxDataPage[i] = savePageId;
    }//for
    dbsiPtr.p->pdxNumDataPages = ZUB_SEGMENT_SIZE;
    dbsiPtr.p->pdxFilePage = dbsiPtr.p->pdxFilePage - ZUB_SEGMENT_SIZE;
  } else {
    ljam();
    Uint32 dataPages[16];
    ndbrequire(dbsiPtr.p->pdxFilePage > 0);
    ndbrequire(dbsiPtr.p->pdxFilePage <= ZUB_SEGMENT_SIZE);
    Uint32 i;
    for (i = 0; i < dbsiPtr.p->pdxFilePage; i++) {
      ljam();
      dataPages[i] = dbsiPtr.p->pdxDataPage[i + ZUB_SEGMENT_SIZE];
    }//for
    for (i = 0; i < ZUB_SEGMENT_SIZE; i++) {
      ljam();
      dataPages[i + dbsiPtr.p->pdxFilePage] = dbsiPtr.p->pdxDataPage[i];
    }//for
    Uint32 limitLoop = ZUB_SEGMENT_SIZE + dbsiPtr.p->pdxFilePage;
    for (i = 0; i < limitLoop; i++) {
      ljam();
      dbsiPtr.p->pdxDataPage[i] = dataPages[i];
    }//for
    dbsiPtr.p->pdxNumDataPages = dbsiPtr.p->pdxFilePage;
    dbsiPtr.p->pdxFilePage = 0;
  }//if
  rfrReadNextUndoSegment(signal, dbsiPtr, lliPtr);
  return;
}//Dbtup::readExecUndoLogLab()

void Dbtup::rfrReadNextDataSegment(Signal* signal, RestartInfoRecordPtr riPtr, DiskBufferSegmentInfoPtr dbsiPtr) 
{
  dbsiPtr.p->pdxRestartInfoP = riPtr.i;
  dbsiPtr.p->pdxOperation = CHECKPOINT_DATA_READ;
  ndbrequire(dbsiPtr.p->pdxNumDataPages <= 8);

  signal->theData[0] = riPtr.p->sriDataFileHandle;
  signal->theData[1] = cownref;
  signal->theData[2] = dbsiPtr.i;
  signal->theData[3] = 2;
  signal->theData[4] = ZBASE_ADDR_PAGE_WORD;
  signal->theData[5] = dbsiPtr.p->pdxNumDataPages;
  for (Uint32 i = 0; i < dbsiPtr.p->pdxNumDataPages; i++) {
    ljam();
    signal->theData[6 + i] = dbsiPtr.p->pdxDataPage[i];
  }//for
  signal->theData[6 + dbsiPtr.p->pdxNumDataPages] = dbsiPtr.p->pdxFilePage;
  sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 15, JBA);
}//Dbtup::rfrReadNextDataSegment()

/* ---------------------------------------------------------------- */
/* ------------------- RFR_READ_FIRST_UNDO_SEGMENT ---------------- */
/* ---------------------------------------------------------------- */
/* THIS ROUTINE READS IN THE FIRST UNDO SEGMENT INTO THE CURRENTLY  */
/* ACTIVE UNDO BUFFER SEGMENT                                       */
/* -----------------------------------------------------------------*/
void Dbtup::rfrReadFirstUndoSegment(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr) 
{
  dbsiPtr.p->pdxOperation = CHECKPOINT_UNDO_READ_FIRST;

  signal->theData[0] = lliPtr.p->lliUndoFileHandle;
  signal->theData[1] = cownref;
  signal->theData[2] = dbsiPtr.i;
  signal->theData[3] = 1;
  signal->theData[4] = ZBASE_ADDR_UNDO_WORD;
  signal->theData[5] = dbsiPtr.p->pdxNumDataPages;
  signal->theData[6] = dbsiPtr.p->pdxDataPage[ZUB_SEGMENT_SIZE];
  signal->theData[7] = dbsiPtr.p->pdxFilePage;
  sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 8, JBA);
}//Dbtup::rfrReadFirstUndoSegment()

/* ---------------------------------------------------------------- */
/* ------------------- RFR_READ_NEXT_UNDO_SEGMENT ----------------- */
/* ---------------------------------------------------------------- */
/* THIS ROUTINE READS IN THE NEXT UNDO SEGMENT INTO THE CURRENTLY   */
/* ACTIVE UNDO BUFFER SEGMENT AND SWITCH TO THE UNACTIVE, READY ONE */
/* -----------------------------------------------------------------*/
void Dbtup::rfrReadNextUndoSegment(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr) 
{
  dbsiPtr.p->pdxOperation = CHECKPOINT_UNDO_READ;

  signal->theData[0] = lliPtr.p->lliUndoFileHandle;
  signal->theData[1] = cownref;
  signal->theData[2] = dbsiPtr.i;
  signal->theData[3] = 1;
  signal->theData[4] = ZBASE_ADDR_UNDO_WORD;
  signal->theData[5] = dbsiPtr.p->pdxNumDataPages;
  signal->theData[6] = dbsiPtr.p->pdxDataPage[0];
  signal->theData[7] = dbsiPtr.p->pdxFilePage;
  sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 8, JBA);
}//Dbtup::rfrReadNextUndoSegment()

void Dbtup::xlcGetNextRecordLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr) 
{
  Uint32 loopCount = 0;
/* ---------------------------------------------------------------------- */
/*       EXECUTE A NEW SET OF UNDO LOG RECORDS.                           */
/* ---------------------------------------------------------------------- */
  XlcStruct xlcStruct;

  xlcStruct.LliPtr = lliPtr;
  xlcStruct.DbsiPtr = dbsiPtr;

  do {
    ljam();
    loopCount++;
    if (loopCount == 20) {
      ljam();
      signal->theData[0] = ZCONT_EXECUTE_LC;
      signal->theData[1] = xlcStruct.LliPtr.i;
      sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);
      return;
    }//if
    if (xlcStruct.LliPtr.p->lliPrevRecordId == 0) {
      ljam();
      closeExecUndoLogLab(signal, xlcStruct.LliPtr);
      return;
    }//if
    xlcStruct.PageId = xlcStruct.LliPtr.p->lliPrevRecordId >> ZUNDO_RECORD_ID_PAGE_INDEX;
    xlcStruct.PageIndex = xlcStruct.LliPtr.p->lliPrevRecordId & ZUNDO_RECORD_ID_PAGE_INDEX_MASK;
    if (xlcStruct.PageId < xlcStruct.DbsiPtr.p->pdxFilePage) {
      ljam();
      readExecUndoLogLab(signal, xlcStruct.DbsiPtr, xlcStruct.LliPtr);
      return;
    }//if
    ndbrequire((xlcStruct.PageId - xlcStruct.DbsiPtr.p->pdxFilePage) < 16);
    xlcStruct.UPPtr.i = xlcStruct.DbsiPtr.p->pdxDataPage[xlcStruct.PageId - xlcStruct.DbsiPtr.p->pdxFilePage];
    ptrCheckGuard(xlcStruct.UPPtr, cnoOfUndoPage, undoPage);
    xlcGetLogHeader(xlcStruct);
    getFragmentrec(xlcStruct.FragPtr, xlcStruct.FragId, xlcStruct.TabPtr.p);
    if (xlcStruct.FragPtr.i == RNIL) {
      ljam();
      continue;
    }//if
    if (xlcStruct.FragPtr.p->fragStatus != SYSTEM_RESTART) {
      ljam();
      continue;
    }//if
    ndbrequire(xlcStruct.LogRecordType < ZNO_CHECKPOINT_RECORDS);
    cSrUndoRecords[xlcStruct.LogRecordType]++;
    switch (xlcStruct.LogRecordType) {
    case ZLCPR_TYPE_INSERT_TH:
      ljam();
      xlcInsertTh(xlcStruct);
      break;
    case ZLCPR_TYPE_DELETE_TH:
      ljam();
      xlcDeleteTh(xlcStruct);
      break;
    case ZLCPR_TYPE_UPDATE_TH:
      ljam();
      xlcUpdateTh(xlcStruct);
      break;
    case ZLCPR_TYPE_INSERT_TH_NO_DATA:
      ljam();
      xlcInsertTh(xlcStruct);
      break;
    case ZLCPR_ABORT_UPDATE:
      ljam();
      xlcAbortUpdate(signal, xlcStruct);
      break;
    case ZLCPR_ABORT_INSERT:
      ljam();
      xlcAbortInsert(signal, xlcStruct);
      break;
    case ZTABLE_DESCRIPTOR:
      ljam();
      xlcTableDescriptor(xlcStruct);
      if (xlcStruct.LliPtr.p->lliNumFragments == 0) {
        ljam();
        closeExecUndoLogLab(signal, xlcStruct.LliPtr);
        return;
      }//if
      break;
    case ZLCPR_UNDO_LOG_PAGE_HEADER:
      ljam();
      xlcUndoLogPageHeader(xlcStruct);
      break;
    case ZINDICATE_NO_OP_ACTIVE: