dbaccmain.cpp

mysql-5.0.22.tar.gz源码包

  /* FS_OPERATION  PTR               */
  tresult = 0;	/* RESULT CHECK VALUE              */
  fsConnectptr.i = fsOpptr.p->fsConptr;
  ptrCheckGuard(fsConnectptr, cfsConnectsize, fsConnectrec);
  fragrecptr.i = fsOpptr.p->fsOpfragrecPtr;
  ptrCheckGuard(fragrecptr, cfragmentsize, fragmentrec);
  switch (fsOpptr.p->fsOpstate) {
  case WAIT_WRITE_UNDO:
    jam();
    updateLastUndoPageIdWritten(signal, fsOpptr.p->fsOpMemPage);
    releaseFsOpRec(signal);
    if (fragrecptr.p->nrWaitWriteUndoExit == 0) {
      jam();
      checkSendLcpConfLab(signal);
      return;
    } else {
      jam();
      fragrecptr.p->lastUndoIsStored = ZTRUE;
    }//if
    return;
    break;
  case WAIT_WRITE_UNDO_EXIT:
    jam();
    updateLastUndoPageIdWritten(signal, fsOpptr.p->fsOpMemPage);
    releaseFsOpRec(signal);
    if (fragrecptr.p->nrWaitWriteUndoExit > 0) {
      jam();
      fragrecptr.p->nrWaitWriteUndoExit--;
    }//if
    if (fsConnectptr.p->fsState == WAIT_CLOSE_UNDO) {
      jam();
      /* ************************ */
      /* FSCLOSEREQ               */
      /* ************************ */
      signal->theData[0] = fsConnectptr.p->fsPtr;
      signal->theData[1] = cownBlockref;
      signal->theData[2] = fsConnectptr.i;
      signal->theData[3] = ZFALSE;
      sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA);
    }//if
    if (fragrecptr.p->nrWaitWriteUndoExit == 0) {
      if (fragrecptr.p->lastUndoIsStored == ZTRUE) {
        jam();
        fragrecptr.p->lastUndoIsStored = ZFALSE;
        checkSendLcpConfLab(signal);
        return;
      }//if
    }//if
    return;
    break;
  case WAIT_WRITE_DATA:
    jam();
    releaseFsOpRec(signal);
    fragrecptr.p->activeDataFilePage += ZWRITEPAGESIZE;
    fragrecptr.p->activeDataPage = 0;
    rootfragrecptr.i = fragrecptr.p->myroot;
    ptrCheckGuard(rootfragrecptr, crootfragmentsize, rootfragmentrec);
    lcpConnectptr.i = rootfragrecptr.p->lcpPtr;
    ptrCheckGuard(lcpConnectptr, clcpConnectsize, lcpConnectrec);
    switch (fragrecptr.p->fragState) {
    case LCP_SEND_PAGES:
      jam();
      savepagesLab(signal);
      return;
      break;
    case LCP_SEND_OVER_PAGES:
      jam();
      saveOverPagesLab(signal);
      return;
      break;
    case LCP_SEND_ZERO_PAGE:
      jam();
      saveZeroPageLab(signal);
      return;
      break;
    case WAIT_ZERO_PAGE_STORED:
      jam();
      lcpCloseDataFileLab(signal);
      return;
      break;
    default:
      ndbrequire(false);
      return;
      break;
    }//switch
    break;
  default:
    ndbrequire(false);
    break;
  }//switch
  return;
}//Dbacc::execFSWRITECONF()


/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
/*                                                                           */
/*       END OF COMMON SIGNAL RECEPTION MODULE                               */
/*                                                                           */
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
/*                                                                           */
/*       SYSTEM RESTART MODULE                                               */
/*                                                                           */
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
void Dbacc::execNDB_STTOR(Signal* signal) 
{
  Uint32 tstartphase;
  Uint32 tStartType;

  jamEntry();
  cndbcntrRef = signal->theData[0];
  cmynodeid = signal->theData[1];
  tstartphase = signal->theData[2];
  tStartType = signal->theData[3];
  switch (tstartphase) {
  case ZSPH1:
    jam();
    ndbsttorryLab(signal);
    return;
    break;
  case ZSPH2:
    cnoLcpPages = 2 * (ZWRITEPAGESIZE + 1);
    initialiseLcpPages(signal);
    ndbsttorryLab(signal);
    return;
    break;
  case ZSPH3:
    if ((tStartType == NodeState::ST_NODE_RESTART) ||
        (tStartType == NodeState::ST_INITIAL_NODE_RESTART)) {
      jam();
      //---------------------------------------------
      // csystemRestart is used to check what is needed
      // during log execution. When starting a node it
      // is not a log execution and rather a normal
      // execution. Thus we reset the variable here to
      // avoid unnecessary system crashes.
      //---------------------------------------------
      csystemRestart = ZFALSE;
    }//if
    
    signal->theData[0] = ZLOAD_BAL_LCP_TIMER;
    sendSignalWithDelay(cownBlockref, GSN_CONTINUEB, signal, 100, 1);
    break;
  case ZSPH6:
    jam();
    clblPagesPerTick = clblPagesPerTickAfterSr;
    csystemRestart = ZFALSE;

    signal->theData[0] = ZREPORT_MEMORY_USAGE;
    sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 2000, 1);    
    break;
  default:
    jam();
    /*empty*/;
    break;
  }//switch
  ndbsttorryLab(signal);
  return;
}//Dbacc::execNDB_STTOR()

/* ******************--------------------------------------------------------------- */
/* STTOR                                              START /  RESTART               */
/* ******************------------------------------+                                 */
/*   SENDER: ANY,    LEVEL B       */
void Dbacc::execSTTOR(Signal* signal) 
{
  jamEntry();
  Uint32 tstartphase = signal->theData[1];
  switch (tstartphase) {
  case 1:
    jam();
    c_tup = (Dbtup*)globalData.getBlock(DBTUP);
    ndbrequire(c_tup != 0);
    break;
  }
  tuserblockref = signal->theData[3];
  csignalkey = signal->theData[6];
  sttorrysignalLab(signal);
  return;
}//Dbacc::execSTTOR()

/* --------------------------------------------------------------------------------- */
/* ZSPH1                                                                             */
/* --------------------------------------------------------------------------------- */
void Dbacc::ndbrestart1Lab(Signal* signal) 
{
  cmynodeid = globalData.ownId;
  cownBlockref = numberToRef(DBACC, cmynodeid);
  czero = 0;
  cminusOne = czero - 1;
  ctest = 0;
  cundoLogActive = ZFALSE;
  csystemRestart = ZTRUE;
  clblPageOver = 0;
  clblPageCounter = 0;
  cactiveUndoFilePage = 0;
  cprevUndoaddress = cminusOne;
  cundoposition = 0;
  clastUndoPageIdWritten = 0;
  cactiveUndoFileVersion = RNIL;
  cactiveOpenUndoFsPtr = RNIL;
  for (Uint32 tmp = 0; tmp < ZMAX_UNDO_VERSION; tmp++) {
    csrVersList[tmp] = RNIL;
  }//for
  return;
}//Dbacc::ndbrestart1Lab()

void Dbacc::initialiseRecordsLab(Signal* signal, Uint32 ref, Uint32 data) 
{
  switch (tdata0) {
  case 0:
    jam();
    initialiseTableRec(signal);
    break;
  case 1:
    jam();
    initialiseFsConnectionRec(signal);
    break;
  case 2:
    jam();
    initialiseFsOpRec(signal);
    break;
  case 3:
    jam();
    initialiseLcpConnectionRec(signal);
    break;
  case 4:
    jam();
    initialiseDirRec(signal);
    break;
  case 5:
    jam();
    initialiseDirRangeRec(signal);
    break;
  case 6:
    jam();
    initialiseFragRec(signal);
    break;
  case 7:
    jam();
    initialiseOverflowRec(signal);
    break;
  case 8:
    jam();
    initialiseOperationRec(signal);
    break;
  case 9:
    jam();
    initialisePageRec(signal);
    break;
  case 10:
    jam();
    initialiseRootfragRec(signal);
    break;
  case 11:
    jam();
    initialiseScanRec(signal);
    break;
  case 12:
    jam();
    initialiseSrVerRec(signal);

    {
      ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend();
      conf->senderRef = reference();
      conf->senderData = data;
      sendSignal(ref, GSN_READ_CONFIG_CONF, signal, 
		 ReadConfigConf::SignalLength, JBB);
    }
    return;
    break;
  default:
    ndbrequire(false);
    break;
  }//switch

  signal->theData[0] = ZINITIALISE_RECORDS;
  signal->theData[1] = tdata0 + 1;
  signal->theData[2] = 0;
  signal->theData[3] = ref;
  signal->theData[4] = data;
  sendSignal(reference(), GSN_CONTINUEB, signal, 5, JBB);
  return;
}//Dbacc::initialiseRecordsLab()

/* *********************************<< */
/* NDB_STTORRY                         */
/* *********************************<< */
void Dbacc::ndbsttorryLab(Signal* signal) 
{
  signal->theData[0] = cownBlockref;
  sendSignal(cndbcntrRef, GSN_NDB_STTORRY, signal, 1, JBB);
  return;
}//Dbacc::ndbsttorryLab()

/* *********************************<< */
/* SIZEALT_REP         SIZE ALTERATION */
/* *********************************<< */
void Dbacc::execREAD_CONFIG_REQ(Signal* signal) 
{
  const ReadConfigReq * req = (ReadConfigReq*)signal->getDataPtr();
  Uint32 ref = req->senderRef;
  Uint32 senderData = req->senderData;
  ndbrequire(req->noOfParameters == 0);
  
  jamEntry();

  const ndb_mgm_configuration_iterator * p = 
    theConfiguration.getOwnConfigIterator();
  ndbrequire(p != 0);
  
  Uint32 log_page_size= 0;
  ndb_mgm_get_int_parameter(p, CFG_DB_UNDO_INDEX_BUFFER,  
			    &log_page_size);

  /**
   * Always set page size in half MBytes
   */
  cundopagesize= (log_page_size / sizeof(Undopage));
  Uint32 mega_byte_part= cundopagesize & 15;
  if (mega_byte_part != 0) {
    jam();
    cundopagesize+= (16 - mega_byte_part);
  }

  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_ACC_DIR_RANGE, &cdirrangesize));
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_ACC_DIR_ARRAY, &cdirarraysize));
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_ACC_FRAGMENT, &cfragmentsize));
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_ACC_OP_RECS, &coprecsize));
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_ACC_OVERFLOW_RECS, 
					&coverflowrecsize));
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_ACC_PAGE8, &cpagesize));
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_ACC_ROOT_FRAG, 
					&crootfragmentsize));
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_ACC_TABLE, &ctablesize));
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_ACC_SCAN, &cscanRecSize));
  initRecords();
  ndbrestart1Lab(signal);

  clblPagesPerTick = 50;
  ndb_mgm_get_int_parameter(p, CFG_DB_LCP_DISC_PAGES_ACC_SR, 
			    &clblPagesPerTick);

  clblPagesPerTickAfterSr = 50;
  ndb_mgm_get_int_parameter(p, CFG_DB_LCP_DISC_PAGES_ACC, 
			    &clblPagesPerTickAfterSr);

  tdata0 = 0;
  initialiseRecordsLab(signal, ref, senderData);
  return;
}//Dbacc::execSIZEALT_REP()

/* *********************************<< */
/* STTORRY                             */
/* *********************************<< */