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

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

MySQL数据库

开发平台：

Visual C++

Ndbfs.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 "Ndbfs.hpp"
  20. #include "AsyncFile.hpp"
  21. #include "Filename.hpp"
  22. #include "Error.hpp"
  24. #include <signaldata/FsOpenReq.hpp>
  25. #include <signaldata/FsCloseReq.hpp>
  26. #include <signaldata/FsReadWriteReq.hpp>
  27. #include <signaldata/FsAppendReq.hpp>
  28. #include <signaldata/FsRemoveReq.hpp>
  29. #include <signaldata/FsConf.hpp>
  30. #include <signaldata/FsRef.hpp>
  31. #include <signaldata/NdbfsContinueB.hpp>
  32. #include <signaldata/DumpStateOrd.hpp>
  34. #include <RefConvert.hpp>
  35. #include <NdbSleep.h>
  36. #include <NdbOut.hpp>
  37. #include <Configuration.hpp>
  39. #define DEBUG(x) { ndbout << "FS::" << x << endl; }
  41. inline
  42. int pageSize( const NewVARIABLE* baseAddrRef )
  43. {
  44.    int log_psize;
  45.    int log_qsize = baseAddrRef->bits.q;
  46.    int log_vsize = baseAddrRef->bits.v;
  47.    if (log_vsize < 3)
  48.       log_vsize = 3;
  49.    log_psize = log_qsize + log_vsize - 3;
  50.    return (1 << log_psize);
  51. }
  54. Ndbfs::Ndbfs(const Configuration & conf) :
  55.   SimulatedBlock(NDBFS, conf),
  56.   scanningInProgress(false),
  57.   theLastId(0),
  58.   m_maxOpenedFiles(0)
  59. {
  60.   theFileSystemPath = conf.fileSystemPath();
  61.   theBackupFilePath = conf.backupFilePath();
  63.   theRequestPool = new Pool<Request>;
  65.   const ndb_mgm_configuration_iterator * p = conf.getOwnConfigIterator();
  66.   ndbrequire(p != 0);
  68.   m_maxFiles = 40;
  69.   ndb_mgm_get_int_parameter(p, CFG_DB_MAX_OPEN_FILES, &m_maxFiles);
  70.   
  71.   // Create idle AsyncFiles
  72.   Uint32 noIdleFiles = m_maxFiles > 27  ? 27 : m_maxFiles ;
  73.   for (Uint32 i = 0; i < noIdleFiles; i++){
  74.     theIdleFiles.push_back(createAsyncFile());
  75.   }
  77.   BLOCK_CONSTRUCTOR(Ndbfs);
  79.   // Set received signals
  80.   addRecSignal(GSN_DUMP_STATE_ORD,  &Ndbfs::execDUMP_STATE_ORD);
  81.   addRecSignal(GSN_STTOR,  &Ndbfs::execSTTOR);
  82.   addRecSignal(GSN_FSOPENREQ, &Ndbfs::execFSOPENREQ);
  83.   addRecSignal(GSN_FSCLOSEREQ, &Ndbfs::execFSCLOSEREQ);
  84.   addRecSignal(GSN_FSWRITEREQ, &Ndbfs::execFSWRITEREQ);
  85.   addRecSignal(GSN_FSREADREQ, &Ndbfs::execFSREADREQ);
  86.   addRecSignal(GSN_FSSYNCREQ, &Ndbfs::execFSSYNCREQ);
  87.   addRecSignal(GSN_CONTINUEB, &Ndbfs::execCONTINUEB);
  88.   addRecSignal(GSN_FSAPPENDREQ, &Ndbfs::execFSAPPENDREQ);
  89.   addRecSignal(GSN_FSREMOVEREQ, &Ndbfs::execFSREMOVEREQ);
  90.    // Set send signals
  91. }
  93. Ndbfs::~Ndbfs()
  94. {
  95.   // Delete all files
  96.   // AsyncFile destuctor will take care of deleting
  97.   // the thread it has created
  98.   for (unsigned i = 0; i < theFiles.size(); i++){
  99.     AsyncFile* file = theFiles[i];
  100.     delete file; 
  101.     theFiles[i] = NULL;
  102.   }//for
  103.   theFiles.clear();
  105.   delete theRequestPool;
  106. }
  108. /* Received a restart signal.
  109.  * Answer it like any other block
  110.  * PR0  : StartCase
  111.  * DR0  : StartPhase
  112.  * DR1  : ?
  113.  * DR2  : ?
  114.  * DR3  : ?
  115.  * DR4  : ?
  116.  * DR5  : SignalKey
  117.  */
  118. void
  119. Ndbfs::execSTTOR(Signal* signal)
  120. {
  121.   jamEntry();
  122.   
  123.   if(signal->theData[1] == 0){ // StartPhase 0
  124.     jam();
  125.     cownref = NDBFS_REF;
  126.     // close all open files
  127.     ndbrequire(theOpenFiles.size() == 0);
  128.     
  129.     scanningInProgress = false;
  130.     
  131.     signal->theData[0] = NdbfsContinueB::ZSCAN_MEMORYCHANNEL_10MS_DELAY;
  132.     sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 10, 1);
  134.     signal->theData[3] = 255;
  135.     sendSignal(NDBCNTR_REF, GSN_STTORRY, signal,4, JBB);
  136.     return;
  137.   }
  138.   ndbrequire(0);
  139. }
  141. int 
  142. Ndbfs::forward( AsyncFile * file, Request* request)
  143. {
  144.   jam();
  145.   file->execute(request);
  146.   return 1;
  147. }
  149. void 
  150. Ndbfs::execFSOPENREQ(Signal* signal)
  151. {
  152.   jamEntry();
  153.   const FsOpenReq * const fsOpenReq = (FsOpenReq *)&signal->theData[0];
  154.   const BlockReference userRef = fsOpenReq->userReference;
  155.   AsyncFile* file = getIdleFile();
  156.   ndbrequire(file != NULL);
  157.   ndbrequire(signal->getLength() == FsOpenReq::SignalLength)
  158.   file->theFileName.set( userRef, fsOpenReq->fileNumber);
  159.   file->reportTo(&theFromThreads);
  160.   
  161.   Request* request = theRequestPool->get();
  162.   request->action = Request::open;
  163.   request->error = 0;
  164.   request->par.open.flags = fsOpenReq->fileFlags;
  165.   request->set(userRef, fsOpenReq->userPointer, newId() );
  166.   request->file = file;
  167.   request->theTrace = signal->getTrace();
  168.   
  169.   ndbrequire(forward(file, request));
  170. }
  172. void 
  173. Ndbfs::execFSREMOVEREQ(Signal* signal)
  174. {
  175.   jamEntry();
  176.   const FsRemoveReq * const req = (FsRemoveReq *)signal->getDataPtr();
  177.   const BlockReference userRef = req->userReference;
  178.   AsyncFile* file = getIdleFile();
  179.   ndbrequire(file != NULL);
  181.   file->theFileName.set( userRef, req->fileNumber, req->directory);
  182.   file->reportTo(&theFromThreads);
  183.   
  184.   Request* request = theRequestPool->get();
  185.   request->action = Request::rmrf;
  186.   request->par.rmrf.directory = req->directory;
  187.   request->par.rmrf.own_directory = req->ownDirectory;
  188.   request->error = 0;
  189.   request->set(userRef, req->userPointer, newId() );
  190.   request->file = file;
  191.   request->theTrace = signal->getTrace();
  192.   
  193.   ndbrequire(forward(file, request));
  194. }
  196. /*
  197.  * PR0: File Pointer DR0: User reference DR1: User Pointer DR2: Flag bit 0= 1
  198.  * remove file
  199.  */
  200. void 
  201. Ndbfs::execFSCLOSEREQ(Signal * signal)
  202. {
  203.   jamEntry();
  204.   const FsCloseReq * const fsCloseReq = (FsCloseReq *)&signal->theData[0];
  205.   const BlockReference userRef = fsCloseReq->userReference;
  206.   const Uint16 filePointer = (Uint16)fsCloseReq->filePointer;
  207.   const UintR userPointer = fsCloseReq->userPointer; 
  209.   AsyncFile* openFile = theOpenFiles.find(filePointer);
  210.   if (openFile == NULL) {
  211.     // The file was not open, send error back to sender
  212.     jam();    
  213.     // Initialise FsRef signal
  214.     FsRef * const fsRef = (FsRef *)&signal->theData[0];
  215.     fsRef->userPointer  = userPointer; 
  216.     fsRef->setErrorCode(fsRef->errorCode, FsRef::fsErrFileDoesNotExist);
  217.     fsRef->osErrorCode  = ~0; // Indicate local error
  218.     sendSignal(userRef, GSN_FSCLOSEREF, signal, 3, JBB);
  219.     return;
  220.   }
  222.   Request *request = theRequestPool->get();
  223.   if( fsCloseReq->getRemoveFileFlag(fsCloseReq->fileFlag) == true ) {
  224.      jam();
  225.      request->action = Request::closeRemove;
  226.   } else {
  227.      jam();
  228.      request->action = Request::close;
  229.   }
  230.   request->set(userRef, fsCloseReq->userPointer, filePointer);
  231.   request->file = openFile;
  232.   request->error = 0;
  233.   request->theTrace = signal->getTrace();
  235.   ndbrequire(forward(openFile, request));
  236. }
  238. void 
  239. Ndbfs::readWriteRequest(int action, Signal * signal)
  240. {
  241.   const FsReadWriteReq * const fsRWReq = (FsReadWriteReq *)&signal->theData[0];
  242.   Uint16 filePointer =  (Uint16)fsRWReq->filePointer;
  243.   const UintR userPointer = fsRWReq->userPointer; 
  244.   const BlockReference userRef = fsRWReq->userReference;
  245.   const BlockNumber blockNumber = refToBlock(userRef);
  247.   AsyncFile* openFile = theOpenFiles.find(filePointer);
  249.   const NewVARIABLE *myBaseAddrRef = &getBat(blockNumber)[fsRWReq->varIndex];
  250.   UintPtr tPageSize;
  251.   UintPtr tClusterSize;
  252.   UintPtr tNRR;
  253.   UintPtr tPageOffset;
  254.   char*        tWA;
  255.   FsRef::NdbfsErrorCodeType errorCode;
  257.   Request *request = theRequestPool->get();
  258.   request->error = 0;
  259.   request->set(userRef, userPointer, filePointer);
  260.   request->file = openFile;
  261.   request->action = (Request::Action) action;
  262.   request->theTrace = signal->getTrace();
  264.   if (fsRWReq->numberOfPages == 0) { //Zero pages not allowed
  265.     jam();
  266.     errorCode = FsRef::fsErrInvalidParameters;
  267.     goto error;
  268.   }
  270.   if (fsRWReq->varIndex >= getBatSize(blockNumber)) {
  271.     jam();// Ensure that a valid variable is used    
  272.     errorCode = FsRef::fsErrInvalidParameters;
  273.     goto error;
  274.   }
  275.   if (myBaseAddrRef == NULL) {
  276.     jam(); // Ensure that a valid variable is used
  277.     errorCode = FsRef::fsErrInvalidParameters;
  278.     goto error;
  279.   }
  280.   if (openFile == NULL) {
  281.     jam(); //file not open
  282.     errorCode = FsRef::fsErrFileDoesNotExist;
  283.     goto error;
  284.   }
  285.   tPageSize = pageSize(myBaseAddrRef);
  286.   tClusterSize = myBaseAddrRef->ClusterSize;
  287.   tNRR = myBaseAddrRef->nrr;
  288.   tWA = (char*)myBaseAddrRef->WA;
  289.  
  290.   switch (fsRWReq->getFormatFlag(fsRWReq->operationFlag)) {
  292.   // List of memory and file pages pairs
  293.   case FsReadWriteReq::fsFormatListOfPairs: { 
  294.     jam();
  295.     for (unsigned int i = 0; i < fsRWReq->numberOfPages; i++) {
  296.       jam();
  297.       const UintPtr varIndex = fsRWReq->data.listOfPair[i].varIndex;
  298.       const UintPtr fileOffset = fsRWReq->data.listOfPair[i].fileOffset;
  299.       if (varIndex >= tNRR) {
  300.         jam();
  301.         errorCode = FsRef::fsErrInvalidParameters;
  302.         goto error;
  303.       }//if
  304.       request->par.readWrite.pages[i].buf = &tWA[varIndex * tClusterSize];
  305.       request->par.readWrite.pages[i].size = tPageSize;
  306.       request->par.readWrite.pages[i].offset = fileOffset * tPageSize;
  307.     }//for
  308.     request->par.readWrite.numberOfPages = fsRWReq->numberOfPages;
  309.     break;
  310.   }//case
  312.   // Range of memory page with one file page
  313.   case FsReadWriteReq::fsFormatArrayOfPages: { 
  314.     if ((fsRWReq->numberOfPages + fsRWReq->data.arrayOfPages.varIndex) > tNRR) {
  315.       jam();
  316.       errorCode = FsRef::fsErrInvalidParameters;
  317.       goto error;
  318.     }//if
  319.     const UintPtr varIndex = fsRWReq->data.arrayOfPages.varIndex;
  320.     const UintPtr fileOffset = fsRWReq->data.arrayOfPages.fileOffset;
  321.     
  322.     request->par.readWrite.pages[0].offset = fileOffset * tPageSize;
  323.     request->par.readWrite.pages[0].size = tPageSize * fsRWReq->numberOfPages;
  324.     request->par.readWrite.numberOfPages = 1;
  325.     request->par.readWrite.pages[0].buf = &tWA[varIndex * tPageSize];
  326.     break;
  327.   }//case
  329.   // List of memory pages followed by one file page
  330.   case FsReadWriteReq::fsFormatListOfMemPages: { 
  332.     tPageOffset = fsRWReq->data.listOfMemPages.varIndex[fsRWReq->numberOfPages];
  333.     tPageOffset *= tPageSize;
  334.     
  335.     for (unsigned int i = 0; i < fsRWReq->numberOfPages; i++) {
  336.       jam();
  337.       UintPtr varIndex = fsRWReq->data.listOfMemPages.varIndex[i];
  339.       if (varIndex >= tNRR) {
  340.         jam();
  341.         errorCode = FsRef::fsErrInvalidParameters;
  342.         goto error;
  343.       }//if
  344.       request->par.readWrite.pages[i].buf = &tWA[varIndex * tClusterSize];
  345.       request->par.readWrite.pages[i].size = tPageSize;
  346.       request->par.readWrite.pages[i].offset = tPageOffset + (i*tPageSize);
  347.     }//for
  348.     request->par.readWrite.numberOfPages = fsRWReq->numberOfPages;
  349.     break;
  350.     // make it a writev or readv
  351.   }//case
  352.   
  353.   default: {
  354.     jam();
  355.     errorCode = FsRef::fsErrInvalidParameters;
  356.     goto error;
  357.   }//default
  358.   
  359.   }//switch
  360.   
  361.   ndbrequire(forward(openFile, request));
  362.   return;
  364. error:
  365.   theRequestPool->put(request);
  366.   FsRef * const fsRef = (FsRef *)&signal->theData[0];
  367.   fsRef->userPointer = userPointer;
  368.   fsRef->setErrorCode(fsRef->errorCode, errorCode);
  369.   fsRef->osErrorCode = ~0; // Indicate local error
  370.   switch (action) {
  371.   case Request:: write:
  372.   case Request:: writeSync: {
  373.     jam();
  374.     sendSignal(userRef, GSN_FSWRITEREF, signal, 3, JBB);
  375.     break;
  376.   }//case
  377.   case Request:: read: {
  378.     jam();
  379.     sendSignal(userRef, GSN_FSREADREF, signal, 3, JBB);
  380.   }//case
  381.   }//switch
  382.   return;
  383. }
  385. /*
  386.     PR0: File Pointer , theData[0]
  387.     DR0: User reference, theData[1]
  388.     DR1: User Pointer,   etc.
  389.     DR2: Flag
  390.     DR3: Var number
  391.     DR4: amount of pages
  392.     DR5->: Memory Page id and File page id according to Flag
  393. */
  394. void 
  395. Ndbfs::execFSWRITEREQ(Signal* signal)
  396. {
  397.   jamEntry();
  398.   const FsReadWriteReq * const fsWriteReq = (FsReadWriteReq *)&signal->theData[0];
  399.   
  400.   if (fsWriteReq->getSyncFlag(fsWriteReq->operationFlag) == true){
  401.     jam();
  402.     readWriteRequest( Request::writeSync, signal );
  403.   } else {
  404.     jam();
  405.     readWriteRequest( Request::write, signal );
  406.   }
  407. }
  409. /*
  410.     PR0: File Pointer
  411.     DR0: User reference
  412.     DR1: User Pointer
  413.     DR2: Flag
  414.     DR3: Var number
  415.     DR4: amount of pages
  416.     DR5->: Memory Page id and File page id according to Flag
  417. */
  418. void 
  419. Ndbfs::execFSREADREQ(Signal* signal)
  420. {
  421.    jamEntry();
  422.    readWriteRequest( Request::read, signal );
  423. }
  425. /*
  426.  * PR0: File Pointer DR0: User reference DR1: User Pointer
  427.  */
  428. void
  429. Ndbfs::execFSSYNCREQ(Signal * signal)
  430. {
  431.   jamEntry();
  432.   Uint16 filePointer =  (Uint16)signal->theData[0];
  433.   BlockReference userRef = signal->theData[1];
  434.   const UintR userPointer = signal->theData[2]; 
  435.   AsyncFile* openFile = theOpenFiles.find(filePointer);
  437.   if (openFile == NULL) {
  438.      jam(); //file not open
  439.      FsRef * const fsRef = (FsRef *)&signal->theData[0];
  440.      fsRef->userPointer = userPointer;
  441.      fsRef->setErrorCode(fsRef->errorCode, FsRef::fsErrFileDoesNotExist);
  442.      fsRef->osErrorCode = ~0; // Indicate local error
  443.      sendSignal(userRef, GSN_FSSYNCREF, signal, 3, JBB);
  444.      return;
  445.   }
  446.   
  447.   Request *request = theRequestPool->get();
  448.   request->error = 0;
  449.   request->action = Request::sync;
  450.   request->set(userRef, userPointer, filePointer);
  451.   request->file = openFile;
  452.   request->theTrace = signal->getTrace();
  453.   
  454.   ndbrequire(forward(openFile,request));
  455. }
  457. void 
  458. Ndbfs::execFSAPPENDREQ(Signal * signal)
  459. {
  460.   const FsAppendReq * const fsReq = (FsAppendReq *)&signal->theData[0];
  461.   const Uint16 filePointer =  (Uint16)fsReq->filePointer;
  462.   const UintR userPointer = fsReq->userPointer; 
  463.   const BlockReference userRef = fsReq->userReference;
  464.   const BlockNumber blockNumber = refToBlock(userRef);
  466.   FsRef::NdbfsErrorCodeType errorCode;
  468.   AsyncFile* openFile = theOpenFiles.find(filePointer);
  469.   const NewVARIABLE *myBaseAddrRef = &getBat(blockNumber)[fsReq->varIndex];
  471.   const Uint32* tWA   = (const Uint32*)myBaseAddrRef->WA;
  472.   const Uint32  tSz   = myBaseAddrRef->nrr;
  473.   const Uint32 offset = fsReq->offset;
  474.   const Uint32 size   = fsReq->size;
  475.   Request *request = theRequestPool->get();
  477.   if (openFile == NULL) {
  478.     jam();
  479.     errorCode = FsRef::fsErrFileDoesNotExist;
  480.     goto error;
  481.   }
  483.   if (myBaseAddrRef == NULL) {
  484.     jam(); // Ensure that a valid variable is used
  485.     errorCode = FsRef::fsErrInvalidParameters;
  486.     goto error;
  487.   }
  488.   
  489.   if (fsReq->varIndex >= getBatSize(blockNumber)) {
  490.     jam();// Ensure that a valid variable is used    
  491.     errorCode = FsRef::fsErrInvalidParameters;
  492.     goto error;
  493.   }
  494.   
  495.   if(offset + size > tSz){
  496.     jam(); // Ensure that a valid variable is used
  497.     errorCode = FsRef::fsErrInvalidParameters;
  498.     goto error;
  499.   }
  501.   request->error = 0;
  502.   request->set(userRef, userPointer, filePointer);
  503.   request->file = openFile;
  504.   request->action = Request::append;
  505.   request->theTrace = signal->getTrace();
  506.   
  507.   request->par.append.buf = (const char *)(tWA + offset);
  508.   request->par.append.size = size << 2;
  509.   
  510.   ndbrequire(forward(openFile, request));
  511.   return;
  512.   
  513. error:
  514.   jam();
  515.   theRequestPool->put(request);
  516.   FsRef * const fsRef = (FsRef *)&signal->theData[0];
  517.   fsRef->userPointer = userPointer;
  518.   fsRef->setErrorCode(fsRef->errorCode, errorCode);
  519.   fsRef->osErrorCode = ~0; // Indicate local error
  521.   jam();
  522.   sendSignal(userRef, GSN_FSAPPENDREF, signal, 3, JBB);
  523.   return;
  524. }
  526. Uint16
  527. Ndbfs::newId()
  528. {
  529.   // finds a new key, eg a new filepointer
  530.   for (int i = 1; i < SHRT_MAX; i++) 
  531.   {
  532.     if (theLastId == SHRT_MAX) {
  533.       jam();
  534.       theLastId = 1;
  535.     } else {
  536.       jam();
  537.       theLastId++;
  538.     }
  539.       
  540.     if(theOpenFiles.find(theLastId) == NULL) {
  541.       jam();
  542.       return theLastId;
  543.     }
  544.   }  
  545.   ndbrequire(1 == 0);
  546.   // The program will not reach this point
  547.   return 0;
  548. }
  550. AsyncFile*
  551. Ndbfs::createAsyncFile(){
  553.   // Check limit of open files
  554.   if (theFiles.size()+1 ==  m_maxFiles) {
  555.     // Print info about all open files
  556.     for (unsigned i = 0; i < theFiles.size(); i++){
  557.       AsyncFile* file = theFiles[i];
  558.       ndbout_c("%2d (0x%x): %s", i, file, file->isOpen()?"OPEN":"CLOSED");
  559.     }
  560.     ERROR_SET(fatal, AFS_ERROR_MAXOPEN,""," Ndbfs::createAsyncFile");
  561.   }
  563.   AsyncFile* file = new AsyncFile;
  564.   file->doStart(getOwnNodeId(), theFileSystemPath, theBackupFilePath);
  566.   // Put the file in list of all files
  567.   theFiles.push_back(file);
  569. #ifdef VM_TRACE
  570.   infoEvent("NDBFS: Created new file thread %d", theFiles.size());
  571. #endif
  572.   
  573.   return file;
  574. }
  576. AsyncFile*
  577. Ndbfs::getIdleFile(){
  578.   AsyncFile* file;
  579.   if (theIdleFiles.size() > 0){
  580.     file = theIdleFiles[0];
  581.     theIdleFiles.erase(0);
  582.   } else {
  583.     file = createAsyncFile();
  584.   } 
  585.   return file;
  586. }
  590. void
  591. Ndbfs::report(Request * request, Signal* signal)
  592. {
  593.   const Uint32 orgTrace = signal->getTrace();
  594.   signal->setTrace(request->theTrace);
  595.   const BlockReference ref = request->theUserReference;
  596.   if (request->error) {
  597.     jam();
  598.     // Initialise FsRef signal
  599.     FsRef * const fsRef = (FsRef *)&signal->theData[0];
  600.     fsRef->userPointer = request->theUserPointer;
  601.     fsRef->setErrorCode(fsRef->errorCode, translateErrno(request->error));
  602.     fsRef->osErrorCode = request->error; 
  604.     switch (request->action) {
  605.     case Request:: open: {
  606.       jam();
  607.       // Put the file back in idle files list
  608.       theIdleFiles.push_back(request->file);  
  609.       sendSignal(ref, GSN_FSOPENREF, signal, FsRef::SignalLength, JBB);
  610.       break;
  611.     }
  612.     case Request:: closeRemove:
  613.     case Request:: close: {
  614.       jam();
  615.       sendSignal(ref, GSN_FSCLOSEREF, signal, FsRef::SignalLength, JBB);
  616.       break;
  617.     }
  618.     case Request:: writeSync:
  619.     case Request:: writevSync:
  620.     case Request:: write:
  621.     case Request:: writev: {
  622.       jam();
  623.       sendSignal(ref, GSN_FSWRITEREF, signal, FsRef::SignalLength, JBB);
  624.       break;
  625.     }
  626.     case Request:: read:
  627.     case Request:: readv: {
  628.       jam();
  629.       sendSignal(ref, GSN_FSREADREF, signal, FsRef::SignalLength, JBB);
  630.       break;
  631.     }
  632.     case Request:: sync: {
  633.       jam();
  634.       sendSignal(ref, GSN_FSSYNCREF, signal, FsRef::SignalLength, JBB);
  635.       break;
  636.     }
  637.     case Request::append: {
  638.       jam();
  639.       sendSignal(ref, GSN_FSAPPENDREF, signal, FsRef::SignalLength, JBB);
  640.       break;
  641.     }
  642.     case Request::rmrf: {
  643.       jam();
  644.       // Put the file back in idle files list
  645.       theIdleFiles.push_back(request->file);  
  646.       sendSignal(ref, GSN_FSREMOVEREF, signal, FsRef::SignalLength, JBB);
  647.       break;
  648.     }
  649.     
  650.     case Request:: end: {
  651.       // Report nothing
  652.       break;
  653.     }
  654.     }//switch
  655.   } else {
  656.     jam();
  657.     FsConf * const fsConf = (FsConf *)&signal->theData[0];
  658.     fsConf->userPointer = request->theUserPointer;
  659.     switch (request->action) {
  660.     case Request:: open: {
  661.       jam();
  662.       theOpenFiles.insert(request->file, request->theFilePointer);
  664.       // Keep track on max number of opened files
  665.       if (theOpenFiles.size() > m_maxOpenedFiles)
  666. m_maxOpenedFiles = theOpenFiles.size();
  668.       fsConf->filePointer = request->theFilePointer;
  669.       sendSignal(ref, GSN_FSOPENCONF, signal, 3, JBB);
  670.       break;
  671.     }
  672.     case Request:: closeRemove:
  673.     case Request:: close: {
  674.       jam();
  675.       // removes the file from OpenFiles list
  676.       theOpenFiles.erase(request->theFilePointer); 
  677.       // Put the file in idle files list
  678.       theIdleFiles.push_back(request->file); 
  679.       sendSignal(ref, GSN_FSCLOSECONF, signal, 1, JBB);
  680.       break;
  681.     }
  682.     case Request:: writeSync:
  683.     case Request:: writevSync:
  684.     case Request:: write:
  685.     case Request:: writev: {
  686.       jam();
  687.       sendSignal(ref, GSN_FSWRITECONF, signal, 1, JBB);
  688.       break;
  689.     }
  690.     case Request:: read:
  691.     case Request:: readv: {
  692.       jam();
  693.       sendSignal(ref, GSN_FSREADCONF, signal, 1, JBB);
  694.       break;
  695.     }
  696.     case Request:: sync: {
  697.       jam();
  698.       sendSignal(ref, GSN_FSSYNCCONF, signal, 1, JBB);
  699.       break;
  700.     }//case
  701.     case Request::append: {
  702.       jam();
  703.       signal->theData[1] = request->par.append.size;
  704.       sendSignal(ref, GSN_FSAPPENDCONF, signal, 2, JBB);
  705.       break;
  706.     }
  707.     case Request::rmrf: {
  708.       jam();
  709.       // Put the file in idle files list
  710.       theIdleFiles.push_back(request->file);            
  711.       sendSignal(ref, GSN_FSREMOVECONF, signal, 1, JBB);
  712.       break;
  713.     }
  714.     case Request:: end: {
  715.       // Report nothing
  716.       break;
  717.     }
  718.     }    
  719.   }//if
  720.   signal->setTrace(orgTrace);
  721. }
  724. bool
  725. Ndbfs::scanIPC(Signal* signal)
  726. {
  727.    Request* request = theFromThreads.tryReadChannel();
  728.    jam();
  729.    if (request) {
  730.       jam();
  731.       report(request, signal);
  732.       theRequestPool->put(request);
  733.       return true;
  734.    }
  735.    return false;
  736. }
  738. #if defined NDB_WIN32
  739. int Ndbfs::translateErrno(int aErrno)
  740. {
  741.   switch (aErrno)
  742.     {
  743.       //permission denied
  744.     case ERROR_ACCESS_DENIED:
  746.       return FsRef::fsErrPermissionDenied;
  747.       //temporary not accessible
  748.     case ERROR_PATH_BUSY:
  749.     case ERROR_NO_MORE_SEARCH_HANDLES:
  751.       return FsRef::fsErrTemporaryNotAccessible;
  752.       //no space left on device
  753.     case ERROR_HANDLE_DISK_FULL:
  754.     case ERROR_DISK_FULL:
  756.       return FsRef::fsErrNoSpaceLeftOnDevice;
  757.       //none valid parameters
  758.     case ERROR_INVALID_HANDLE:
  759.     case ERROR_INVALID_DRIVE:
  760.     case ERROR_INVALID_ACCESS:
  761.     case ERROR_HANDLE_EOF:
  762.     case ERROR_BUFFER_OVERFLOW:
  764.       return FsRef::fsErrInvalidParameters;
  765.       //environment error
  766.     case ERROR_CRC:
  767.     case ERROR_ARENA_TRASHED:
  768.     case ERROR_BAD_ENVIRONMENT:
  769.     case ERROR_INVALID_BLOCK:
  770.     case ERROR_WRITE_FAULT:
  771.     case ERROR_READ_FAULT:
  772.     case ERROR_OPEN_FAILED:
  774.       return FsRef::fsErrEnvironmentError;
  776.       //no more process resources
  777.     case ERROR_TOO_MANY_OPEN_FILES:
  778.     case ERROR_NOT_ENOUGH_MEMORY:
  779.     case ERROR_OUTOFMEMORY:
  780.       return FsRef::fsErrNoMoreResources;
  781.       //no file
  782.     case ERROR_FILE_NOT_FOUND:
  783.       return FsRef::fsErrFileDoesNotExist;
  785.     case ERR_ReadUnderflow:
  786.       return FsRef::fsErrReadUnderflow;
  788.     default:
  789.       return FsRef::fsErrUnknown;
  790.     }
  791. }
  792. #elif defined NDB_OSE || defined NDB_SOFTOSE
  793. int Ndbfs::translateErrno(int aErrno)
  794. {
  795.   switch (aErrno)
  796.     {
  797.       //permission denied
  798.     case EACCES:
  799.     case EROFS:
  800.     case ENXIO:
  801.       return FsRef::fsErrPermissionDenied;
  802.       //temporary not accessible
  803.     case EAGAIN:
  804.     case ETIMEDOUT:
  805.     case ENOLCK:
  806.       return FsRef::fsErrTemporaryNotAccessible;
  807.       //no space left on device
  808.     case ENFILE:
  809.     case EDQUOT:
  810.     case ENOSPC:
  811.       return FsRef::fsErrNoSpaceLeftOnDevice;
  812.       //none valid parameters
  813.     case EINVAL:
  814.     case EFBIG:
  815.     case EBADF:
  816.     case ENAMETOOLONG:
  817.     case EFAULT:
  818.     case EISDIR:
  819.       return FsRef::fsErrInvalidParameters;
  820.       //environment error
  821.     case EMLINK:
  822.     case ELOOP:
  823.       return FsRef::fsErrEnvironmentError;
  825.       //no more process resources
  826.     case EMFILE:
  827.     case ENOMEM:
  828.       return FsRef::fsErrNoMoreResources;
  829.       //no file
  830.     case ENOENT:
  831.       return FsRef::fsErrFileDoesNotExist;
  833.     case ERR_ReadUnderflow:
  834.       return FsRef::fsErrReadUnderflow;
  836.     default:
  837.       return FsRef::fsErrUnknown;
  838.     }
  839. }
  840. #else
  841. int Ndbfs::translateErrno(int aErrno)
  842. {
  843.   switch (aErrno)
  844.     {
  845.       //permission denied
  846.     case EACCES:
  847.     case EROFS:
  848.     case ENXIO:
  849.       return FsRef::fsErrPermissionDenied;
  850.       //temporary not accessible
  851.     case EAGAIN:
  852.     case ETIMEDOUT:
  853.     case ENOLCK:
  854.     case EINTR:
  855.     case EIO:
  856.       return FsRef::fsErrTemporaryNotAccessible;
  857.       //no space left on device
  858.     case ENFILE:
  859.     case EDQUOT:
  860. #ifdef ENOSR
  861.     case ENOSR:
  862. #endif
  863.     case ENOSPC:
  864.     case EFBIG:
  865.       return FsRef::fsErrNoSpaceLeftOnDevice;
  866.       //none valid parameters
  867.     case EINVAL:
  868.     case EBADF:
  869.     case ENAMETOOLONG:
  870.     case EFAULT:
  871.     case EISDIR:
  872.     case ENOTDIR:
  873.     case EEXIST:
  874.     case ETXTBSY:
  875.       return FsRef::fsErrInvalidParameters;
  876.       //environment error
  877.     case ELOOP:
  878. #ifdef ENOLINK
  879.     case ENOLINK:
  880. #endif
  881. #ifdef EMULTIHOP
  882.     case EMULTIHOP:
  883. #endif
  884. #ifdef EOPNOTSUPP
  885.     case EOPNOTSUPP:
  886. #endif
  887. #ifdef ESPIPE
  888.     case ESPIPE:
  889. #endif
  890.     case EPIPE:
  891.       return FsRef::fsErrEnvironmentError;
  893.       //no more process resources
  894.     case EMFILE:
  895.     case ENOMEM:
  896.       return FsRef::fsErrNoMoreResources;
  897.       //no file
  898.     case ENOENT:
  899.       return FsRef::fsErrFileDoesNotExist;
  901.     case ERR_ReadUnderflow:
  902.       return FsRef::fsErrReadUnderflow;
  903.       
  904.     default:
  905.       return FsRef::fsErrUnknown;
  906.     }
  907. }
  908. #endif
  912. void 
  913. Ndbfs::execCONTINUEB(Signal* signal)
  914. {
  915.   jamEntry();
  916.   if (signal->theData[0] == NdbfsContinueB::ZSCAN_MEMORYCHANNEL_10MS_DELAY) {
  917.     jam();
  919.     // Also send CONTINUEB to ourself in order to scan for 
  920.     // incoming answers from AsyncFile on MemoryChannel theFromThreads
  921.     signal->theData[0] = NdbfsContinueB::ZSCAN_MEMORYCHANNEL_10MS_DELAY;
  922.     sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 10, 1);
  923.     if (scanningInProgress == true) {
  924.       jam();
  925.       return;
  926.     }
  927.   }
  928.   if (scanIPC(signal)) {
  929.     jam();
  930.     scanningInProgress = true;
  931.     signal->theData[0] = NdbfsContinueB::ZSCAN_MEMORYCHANNEL_NO_DELAY;    
  932.     sendSignal(reference(), GSN_CONTINUEB, signal, 1, JBB);
  933.    } else {
  934.     jam();
  935.     scanningInProgress = false;
  936.    }
  937.    return;
  938. }
  940. bool Global_useO_SYNC = false;
  941. bool Global_useO_DIRECT = false;
  942. bool Global_unlinkO_CREAT = false;
  943. Uint32 Global_syncFreq = 1024 * 1024;
  945. void
  946. Ndbfs::execDUMP_STATE_ORD(Signal* signal)
  947. {
  948.   if(signal->theData[0] == 19){
  949.     if(signal->length() > 1){
  950.       Global_useO_SYNC = signal->theData[1];
  951.     }
  952.     if(signal->length() > 2){
  953.       Global_syncFreq = signal->theData[2] * 1024 * 1024;
  954.     }
  955.     if(signal->length() > 3){
  956.       Global_unlinkO_CREAT = signal->theData[3];
  957.     }
  958.     if(signal->length() > 4){
  959.       Global_useO_DIRECT = signal->theData[4];
  960.     }
  961.     ndbout_c("useO_SYNC = %d syncFreq = %d unlinkO_CREATE = %d O_DIRECT = %d",
  962.      Global_useO_SYNC,
  963.      Global_syncFreq,
  964.      Global_unlinkO_CREAT,
  965.      Global_useO_DIRECT);
  966.     return;
  967.   }
  968.   if(signal->theData[0] == DumpStateOrd::NdbfsDumpFileStat){
  969.     infoEvent("NDBFS: Files: %d Open files: %d",
  970.       theFiles.size(),
  971.       theOpenFiles.size());
  972.     infoEvent(" Idle files: %d Max opened files: %d",
  973.        theIdleFiles.size(),
  974.        m_maxOpenedFiles);
  975.     infoEvent(" Max files: %d",
  976.       m_maxFiles);
  977.     infoEvent(" Requests: %d",
  978.       theRequestPool->size());
  980.     return;
  981.   }
  982.   if(signal->theData[0] == DumpStateOrd::NdbfsDumpOpenFiles){
  983.     infoEvent("NDBFS: Dump open files: %d", theOpenFiles.size());
  984.     
  985.     for (unsigned i = 0; i < theOpenFiles.size(); i++){
  986.       AsyncFile* file = theOpenFiles.getFile(i);
  987.       infoEvent("%2d (0x%x): %s", i,file, file->theFileName.c_str());
  988.     }
  989.     return;
  990.   }
  991.   if(signal->theData[0] == DumpStateOrd::NdbfsDumpAllFiles){
  992.     infoEvent("NDBFS: Dump all files: %d", theFiles.size());
  993.     
  994.     for (unsigned i = 0; i < theFiles.size(); i++){
  995.       AsyncFile* file = theFiles[i];
  996.       infoEvent("%2d (0x%x): %s", i,file, file->isOpen()?"OPEN":"CLOSED");
  997.     }
  998.     return;
  999.   }
  1000.   if(signal->theData[0] == DumpStateOrd::NdbfsDumpIdleFiles){
  1001.     infoEvent("NDBFS: Dump idle files: %d", theIdleFiles.size());
  1002.     
  1003.     for (unsigned i = 0; i < theIdleFiles.size(); i++){
  1004.       AsyncFile* file = theIdleFiles[i];
  1005.       infoEvent("%2d (0x%x): %s", i,file, file->isOpen()?"OPEN":"CLOSED");
  1006.     }
  1007.     return;
  1008.   }
  1009. }//Ndbfs::execDUMP_STATE_ORD()
  1013. BLOCK_FUNCTIONS(Ndbfs)
  1015. template class Vector<AsyncFile*>;
  1016. template class Vector<OpenFiles::OpenFileItem>;
  1017. template class MemoryChannel<Request>;
  1018. template class Pool<Request>;