bk commit into 5.1 tree (tomas:1.2521)

[tomas]

Below is the list of changes that have just been committed into a local
5.1 repository of tomas. When tomas does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet@stripped, 2007-05-30 09:02:51+02:00, tomas@stripped +1 -0
  Merge whalegate.ndb.mysql.com:/home/tomas/mysql-5.0-ndb
  into  whalegate.ndb.mysql.com:/home/tomas/mysql-5.1-single-user
  MERGE: 1.1810.2942.30

  storage/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp@stripped, 2007-05-30 09:02:48+02:00,
tomas@stripped +1 -2
    manual merge
    MERGE: 1.14.8.2

  storage/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp@stripped, 2007-05-30 09:01:28+02:00,
tomas@stripped +0 -0
    Merge rename: ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp ->
storage/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp

# This is a BitKeeper patch.  What follows are the unified diffs for the
# set of deltas contained in the patch.  The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User:	tomas
# Host:	whalegate.ndb.mysql.com
# Root:	/home/tomas/mysql-5.1-single-user/RESYNC

--- 1.14.8.1/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp	2007-05-30 09:00:48 +02:00
+++ 1.35/storage/ndb/src/kernel/blocks/ndbfs/Ndbfs.cpp	2007-05-30 09:02:48 +02:00
@@ -49,10 +49,11 @@
 }
 
 
-Ndbfs::Ndbfs(const Configuration & conf) :
-  SimulatedBlock(NDBFS, conf),
+Ndbfs::Ndbfs(Block_context& ctx) :
+  SimulatedBlock(NDBFS, ctx),
   scanningInProgress(false),
   theLastId(0),
+  theRequestPool(0),
   m_maxOpenedFiles(0)
 {
   BLOCK_CONSTRUCTOR(Ndbfs);
@@ -70,8 +71,6 @@
   addRecSignal(GSN_FSAPPENDREQ, &Ndbfs::execFSAPPENDREQ);
   addRecSignal(GSN_FSREMOVEREQ, &Ndbfs::execFSREMOVEREQ);
    // Set send signals
-
-  theRequestPool = 0;
 }
 
 Ndbfs::~Ndbfs()
@@ -85,7 +84,6 @@
     theFiles[i] = NULL;
   }//for
   theFiles.clear();
-
   if (theRequestPool)
     delete theRequestPool;
 }
@@ -99,19 +97,21 @@
   Uint32 senderData = req->senderData;
 
   const ndb_mgm_configuration_iterator * p = 
-    theConfiguration.getOwnConfigIterator();
+    m_ctx.m_config.getOwnConfigIterator();
   ndbrequire(p != 0);
-
-  theFileSystemPath = theConfiguration.fileSystemPath();
-  theBackupFilePath = theConfiguration.backupFilePath();
+  theFileSystemPath.assfmt("%sndb_%u_fs%s", m_ctx.m_config.fileSystemPath(),
+			   getOwnNodeId(), DIR_SEPARATOR);
+  theBackupFilePath.assign(m_ctx.m_config.backupFilePath());
 
   theRequestPool = new Pool<Request>;
 
-  m_maxFiles = 40;
+  m_maxFiles = 0;
   ndb_mgm_get_int_parameter(p, CFG_DB_MAX_OPEN_FILES, &m_maxFiles);
-  
+  Uint32 noIdleFiles = 27;
+  ndb_mgm_get_int_parameter(p, CFG_DB_INITIAL_OPEN_FILES, &noIdleFiles);
+  if (noIdleFiles > m_maxFiles && m_maxFiles != 0)
+    m_maxFiles = noIdleFiles;
   // Create idle AsyncFiles
-  Uint32 noIdleFiles = m_maxFiles > 27  ? 27 : m_maxFiles ;
   for (Uint32 i = 0; i < noIdleFiles; i++){
     theIdleFiles.push_back(createAsyncFile());
   }
@@ -140,6 +140,16 @@
   
   if(signal->theData[1] == 0){ // StartPhase 0
     jam();
+    
+    {
+#ifdef NDB_WIN32
+      CreateDirectory(theFileSystemPath.c_str(), 0);
+#else
+      mkdir(theFileSystemPath.c_str(),
+	    S_IRUSR | S_IWUSR | S_IXUSR | S_IXGRP | S_IRGRP);
+#endif
+    }      
+    
     cownref = NDBFS_REF;
     // close all open files
     ndbrequire(theOpenFiles.size() == 0);
@@ -172,17 +182,56 @@
   const BlockReference userRef = fsOpenReq->userReference;
   AsyncFile* file = getIdleFile();
   ndbrequire(file != NULL);
-  ndbrequire(signal->getLength() == FsOpenReq::SignalLength)
-  file->theFileName.set( userRef, fsOpenReq->fileNumber);
+  Filename::NameSpec spec(theFileSystemPath, theBackupFilePath);
+
+  Uint32 userPointer = fsOpenReq->userPointer;
+  
+  if(fsOpenReq->fileFlags & FsOpenReq::OM_INIT)
+  {
+    Ptr<GlobalPage> page_ptr;
+    if(m_global_page_pool.seize(page_ptr) == false)
+    {
+      FsRef * const fsRef = (FsRef *)&signal->theData[0];
+      fsRef->userPointer  = userPointer; 
+      fsRef->setErrorCode(fsRef->errorCode, FsRef::fsErrOutOfMemory);
+      fsRef->osErrorCode  = ~0; // Indicate local error
+      sendSignal(userRef, GSN_FSOPENREF, signal, 3, JBB);
+      return;
+    }
+    file->m_page_ptr = page_ptr;
+  } 
+  else
+  {
+    ndbassert(file->m_page_ptr.isNull());
+    file->m_page_ptr.setNull();
+  }
+  
+  if(signal->getNoOfSections() == 0){
+    jam();
+    file->theFileName.set(spec, userRef, fsOpenReq->fileNumber);
+  } else {
+    jam();
+    SegmentedSectionPtr ptr;
+    signal->getSection(ptr, FsOpenReq::FILENAME);
+    file->theFileName.set(spec, ptr, g_sectionSegmentPool);
+    releaseSections(signal);
+  }
   file->reportTo(&theFromThreads);
+  if (getenv("NDB_TRACE_OPEN"))
+    ndbout_c("open(%s)", file->theFileName.c_str());
   
   Request* request = theRequestPool->get();
   request->action = Request::open;
   request->error = 0;
-  request->par.open.flags = fsOpenReq->fileFlags;
-  request->set(userRef, fsOpenReq->userPointer, newId() );
+  request->set(userRef, userPointer, newId() );
   request->file = file;
   request->theTrace = signal->getTrace();
+  request->par.open.flags = fsOpenReq->fileFlags;
+  request->par.open.page_size = fsOpenReq->page_size;
+  request->par.open.file_size = fsOpenReq->file_size_hi;
+  request->par.open.file_size <<= 32;
+  request->par.open.file_size |= fsOpenReq->file_size_lo;
+  request->par.open.auto_sync_size = fsOpenReq->auto_sync_size;
   
   ndbrequire(forward(file, request));
 }
@@ -196,7 +245,8 @@
   AsyncFile* file = getIdleFile();
   ndbrequire(file != NULL);
 
-  file->theFileName.set( userRef, req->fileNumber, req->directory);
+  Filename::NameSpec spec(theFileSystemPath, theBackupFilePath);
+  file->theFileName.set(spec, userRef, req->fileNumber, req->directory);
   file->reportTo(&theFromThreads);
   
   Request* request = theRequestPool->get();
@@ -279,106 +329,130 @@
   request->action = (Request::Action) action;
   request->theTrace = signal->getTrace();
 
+  Uint32 format = fsRWReq->getFormatFlag(fsRWReq->operationFlag);
+
   if (fsRWReq->numberOfPages == 0) { //Zero pages not allowed
     jam();
     errorCode = FsRef::fsErrInvalidParameters;
     goto error;
   }
 
-  if (fsRWReq->varIndex >= getBatSize(blockNumber)) {
-    jam();// Ensure that a valid variable is used    
-    errorCode = FsRef::fsErrInvalidParameters;
-    goto error;
-  }
-  if (myBaseAddrRef == NULL) {
-    jam(); // Ensure that a valid variable is used
-    errorCode = FsRef::fsErrInvalidParameters;
-    goto error;
-  }
-  if (openFile == NULL) {
-    jam(); //file not open
-    errorCode = FsRef::fsErrFileDoesNotExist;
-    goto error;
-  }
-  tPageSize = pageSize(myBaseAddrRef);
-  tClusterSize = myBaseAddrRef->ClusterSize;
-  tNRR = myBaseAddrRef->nrr;
-  tWA = (char*)myBaseAddrRef->WA;
- 
-  switch (fsRWReq->getFormatFlag(fsRWReq->operationFlag)) {
-
-  // List of memory and file pages pairs
-  case FsReadWriteReq::fsFormatListOfPairs: { 
-    jam();
-    for (unsigned int i = 0; i < fsRWReq->numberOfPages; i++) {
-      jam();
-      const UintPtr varIndex = fsRWReq->data.listOfPair[i].varIndex;
-      const UintPtr fileOffset = fsRWReq->data.listOfPair[i].fileOffset;
-      if (varIndex >= tNRR) {
-        jam();
-        errorCode = FsRef::fsErrInvalidParameters;
-        goto error;
-      }//if
-      request->par.readWrite.pages[i].buf = &tWA[varIndex * tClusterSize];
-      request->par.readWrite.pages[i].size = tPageSize;
-      request->par.readWrite.pages[i].offset = fileOffset * tPageSize;
-    }//for
-    request->par.readWrite.numberOfPages = fsRWReq->numberOfPages;
-    break;
-  }//case
-
-  // Range of memory page with one file page
-  case FsReadWriteReq::fsFormatArrayOfPages: { 
-    if ((fsRWReq->numberOfPages + fsRWReq->data.arrayOfPages.varIndex) > tNRR) {
-      jam();
+  if(format != FsReadWriteReq::fsFormatGlobalPage &&
+     format != FsReadWriteReq::fsFormatSharedPage)
+  {     
+    if (fsRWReq->varIndex >= getBatSize(blockNumber)) {
+      jam();// Ensure that a valid variable is used    
       errorCode = FsRef::fsErrInvalidParameters;
       goto error;
-    }//if
-    const UintPtr varIndex = fsRWReq->data.arrayOfPages.varIndex;
-    const UintPtr fileOffset = fsRWReq->data.arrayOfPages.fileOffset;
-    
-    request->par.readWrite.pages[0].offset = fileOffset * tPageSize;
-    request->par.readWrite.pages[0].size = tPageSize * fsRWReq->numberOfPages;
-    request->par.readWrite.numberOfPages = 1;
-    request->par.readWrite.pages[0].buf = &tWA[varIndex * tPageSize];
-    break;
-  }//case
-
-  // List of memory pages followed by one file page
-  case FsReadWriteReq::fsFormatListOfMemPages: { 
-
-    tPageOffset = fsRWReq->data.listOfMemPages.varIndex[fsRWReq->numberOfPages];
-    tPageOffset *= tPageSize;
+    }
+    if (myBaseAddrRef == NULL) {
+      jam(); // Ensure that a valid variable is used
+      errorCode = FsRef::fsErrInvalidParameters;
+      goto error;
+    }
+    if (openFile == NULL) {
+      jam(); //file not open
+      errorCode = FsRef::fsErrFileDoesNotExist;
+      goto error;
+    }
+    tPageSize = pageSize(myBaseAddrRef);
+    tClusterSize = myBaseAddrRef->ClusterSize;
+    tNRR = myBaseAddrRef->nrr;
+    tWA = (char*)myBaseAddrRef->WA;
     
-    for (unsigned int i = 0; i < fsRWReq->numberOfPages; i++) {
+    switch (format) {
+      
+      // List of memory and file pages pairs
+    case FsReadWriteReq::fsFormatListOfPairs: { 
       jam();
-      UintPtr varIndex = fsRWReq->data.listOfMemPages.varIndex[i];
-
-      if (varIndex >= tNRR) {
+      for (unsigned int i = 0; i < fsRWReq->numberOfPages; i++) {
+	jam();
+	const UintPtr varIndex = fsRWReq->data.listOfPair[i].varIndex;
+	const UintPtr fileOffset = fsRWReq->data.listOfPair[i].fileOffset;
+	if (varIndex >= tNRR) {
+	  jam();
+	  errorCode = FsRef::fsErrInvalidParameters;
+	  goto error;
+	}//if
+	request->par.readWrite.pages[i].buf = &tWA[varIndex * tClusterSize];
+	request->par.readWrite.pages[i].size = tPageSize;
+	request->par.readWrite.pages[i].offset = fileOffset * tPageSize;
+      }//for
+      request->par.readWrite.numberOfPages = fsRWReq->numberOfPages;
+      break;
+    }//case
+      
+      // Range of memory page with one file page
+    case FsReadWriteReq::fsFormatArrayOfPages: { 
+      if ((fsRWReq->numberOfPages + fsRWReq->data.arrayOfPages.varIndex) > tNRR)
{
         jam();
         errorCode = FsRef::fsErrInvalidParameters;
         goto error;
       }//if
-      request->par.readWrite.pages[i].buf = &tWA[varIndex * tClusterSize];
-      request->par.readWrite.pages[i].size = tPageSize;
-      request->par.readWrite.pages[i].offset = tPageOffset + (i*tPageSize);
-    }//for
-    request->par.readWrite.numberOfPages = fsRWReq->numberOfPages;
-    break;
-    // make it a writev or readv
-  }//case
-  
-  default: {
-    jam();
-    errorCode = FsRef::fsErrInvalidParameters;
-    goto error;
-  }//default
-  
-  }//switch
+      const UintPtr varIndex = fsRWReq->data.arrayOfPages.varIndex;
+      const UintPtr fileOffset = fsRWReq->data.arrayOfPages.fileOffset;
+      
+      request->par.readWrite.pages[0].offset = fileOffset * tPageSize;
+      request->par.readWrite.pages[0].size = tPageSize * fsRWReq->numberOfPages;
+      request->par.readWrite.numberOfPages = 1;
+      request->par.readWrite.pages[0].buf = &tWA[varIndex * tPageSize];
+      break;
+    }//case
+      
+      // List of memory pages followed by one file page
+    case FsReadWriteReq::fsFormatListOfMemPages: { 
+      
+      tPageOffset = fsRWReq->data.listOfMemPages.varIndex[fsRWReq->numberOfPages];
+      tPageOffset *= tPageSize;
+      
+      for (unsigned int i = 0; i < fsRWReq->numberOfPages; i++) {
+	jam();
+	UintPtr varIndex = fsRWReq->data.listOfMemPages.varIndex[i];
+	
+	if (varIndex >= tNRR) {
+	  jam();
+	  errorCode = FsRef::fsErrInvalidParameters;
+	  goto error;
+	}//if
+	request->par.readWrite.pages[i].buf = &tWA[varIndex * tClusterSize];
+	request->par.readWrite.pages[i].size = tPageSize;
+	request->par.readWrite.pages[i].offset = tPageOffset + (i*tPageSize);
+      }//for
+      request->par.readWrite.numberOfPages = fsRWReq->numberOfPages;
+      break;
+      // make it a writev or readv
+    }//case
+      
+    default: {
+      jam();
+      errorCode = FsRef::fsErrInvalidParameters;
+      goto error;
+    }//default
+    }//switch
+  } 
+  else if (format == FsReadWriteReq::fsFormatGlobalPage)
+  {
+    Ptr<GlobalPage> ptr;
+    m_global_page_pool.getPtr(ptr, fsRWReq->data.pageData[0]);
+    request->par.readWrite.pages[0].buf = (char*)ptr.p;
+    request->par.readWrite.pages[0].size =
((UintPtr)GLOBAL_PAGE_SIZE)*fsRWReq->numberOfPages;
+    request->par.readWrite.pages[0].offset=
((UintPtr)GLOBAL_PAGE_SIZE)*fsRWReq->varIndex;
+    request->par.readWrite.numberOfPages = 1;
+  }
+  else
+  {
+    ndbrequire(format == FsReadWriteReq::fsFormatSharedPage);
+    Ptr<GlobalPage> ptr;
+    m_shared_page_pool.getPtr(ptr, fsRWReq->data.pageData[0]);
+    request->par.readWrite.pages[0].buf = (char*)ptr.p;
+    request->par.readWrite.pages[0].size =
((UintPtr)GLOBAL_PAGE_SIZE)*fsRWReq->numberOfPages;
+    request->par.readWrite.pages[0].offset=
((UintPtr)GLOBAL_PAGE_SIZE)*fsRWReq->varIndex;
+    request->par.readWrite.numberOfPages = 1;
+  }
   
   ndbrequire(forward(openFile, request));
   return;
-
+  
 error:
   theRequestPool->put(request);
   FsRef * const fsRef = (FsRef *)&signal->theData[0];
@@ -392,6 +466,7 @@
     sendSignal(userRef, GSN_FSWRITEREF, signal, 3, JBB);
     break;
   }//case
+  case Request:: readPartial: 
   case Request:: read: {
     jam();
     sendSignal(userRef, GSN_FSREADREF, signal, 3, JBB);
@@ -436,8 +511,12 @@
 void 
 Ndbfs::execFSREADREQ(Signal* signal)
 {
-   jamEntry();
-   readWriteRequest( Request::read, signal );
+  jamEntry();
+  FsReadWriteReq * req = (FsReadWriteReq *)signal->getDataPtr();
+  if (FsReadWriteReq::getPartialReadFlag(req->operationFlag))
+    readWriteRequest( Request::readPartial, signal );
+  else
+    readWriteRequest( Request::read, signal );
 }
 
 /*
@@ -490,6 +569,7 @@
   const Uint32  tSz   = myBaseAddrRef->nrr;
   const Uint32 offset = fsReq->offset;
   const Uint32 size   = fsReq->size;
+  const Uint32 synch_flag = fsReq->synch_flag;
   Request *request = theRequestPool->get();
 
   if (openFile == NULL) {
@@ -519,12 +599,15 @@
   request->error = 0;
   request->set(userRef, userPointer, filePointer);
   request->file = openFile;
-  request->action = Request::append;
   request->theTrace = signal->getTrace();
   
   request->par.append.buf = (const char *)(tWA + offset);
   request->par.append.size = size << 2;
-  
+
+  if (!synch_flag)
+    request->action = Request::append;
+  else
+    request->action = Request::append_synch;
   ndbrequire(forward(openFile, request));
   return;
   
@@ -569,17 +652,17 @@
 Ndbfs::createAsyncFile(){
 
   // Check limit of open files
-  if (theFiles.size() ==  m_maxFiles) {
+  if (m_maxFiles !=0 && theFiles.size() ==  m_maxFiles) {
     // Print info about all open files
     for (unsigned i = 0; i < theFiles.size(); i++){
       AsyncFile* file = theFiles[i];
-      ndbout_c("%2d (0x%x): %s", i, file, file->isOpen()?"OPEN":"CLOSED");
+      ndbout_c("%2d (0x%lx): %s", i, (long) file, file->isOpen()?"OPEN":"CLOSED");
     }
     ERROR_SET(fatal, NDBD_EXIT_AFS_MAXOPEN,""," Ndbfs::createAsyncFile");
   }
 
-  AsyncFile* file = new AsyncFile;
-  file->doStart(getOwnNodeId(), theFileSystemPath, theBackupFilePath);
+  AsyncFile* file = new AsyncFile(* this);
+  file->doStart();
 
   // Put the file in list of all files
   theFiles.push_back(file);
@@ -611,14 +694,28 @@
   const Uint32 orgTrace = signal->getTrace();
   signal->setTrace(request->theTrace);
   const BlockReference ref = request->theUserReference;
+
+  if(!request->file->m_page_ptr.isNull())
+  {
+    m_global_page_pool.release(request->file->m_page_ptr);
+    request->file->m_page_ptr.setNull();
+  }
+  
   if (request->error) {
     jam();
     // Initialise FsRef signal
     FsRef * const fsRef = (FsRef *)&signal->theData[0];
     fsRef->userPointer = request->theUserPointer;
-    fsRef->setErrorCode(fsRef->errorCode, translateErrno(request->error));
-    fsRef->osErrorCode = request->error; 
-
+    if(request->error & FsRef::FS_ERR_BIT)
+    {
+      fsRef->errorCode = request->error;
+      fsRef->osErrorCode = 0;
+    }
+    else 
+    {
+      fsRef->setErrorCode(fsRef->errorCode, translateErrno(request->error));
+      fsRef->osErrorCode = request->error; 
+    }
     switch (request->action) {
     case Request:: open: {
       jam();
@@ -641,7 +738,8 @@
       sendSignal(ref, GSN_FSWRITEREF, signal, FsRef::SignalLength, JBB);
       break;
     }
-    case Request:: read:
+    case Request:: read: 
+    case Request:: readPartial:
     case Request:: readv: {
       jam();
       sendSignal(ref, GSN_FSREADREF, signal, FsRef::SignalLength, JBB);
@@ -652,7 +750,9 @@
       sendSignal(ref, GSN_FSSYNCREF, signal, FsRef::SignalLength, JBB);
       break;
     }
-    case Request::append: {
+    case Request::append:
+    case Request::append_synch:
+    {
       jam();
       sendSignal(ref, GSN_FSAPPENDREF, signal, FsRef::SignalLength, JBB);
       break;
@@ -711,12 +811,20 @@
       sendSignal(ref, GSN_FSREADCONF, signal, 1, JBB);
       break;
     }
+    case Request:: readPartial: {
+      jam();
+      fsConf->bytes_read = request->par.readWrite.pages[0].size;
+      sendSignal(ref, GSN_FSREADCONF, signal, 2, JBB);
+      break;
+    }
     case Request:: sync: {
       jam();
       sendSignal(ref, GSN_FSSYNCCONF, signal, 1, JBB);
       break;
     }//case
-    case Request::append: {
+    case Request::append:
+    case Request::append_synch:
+    {
       jam();
       signal->theData[1] = request->par.append.size;
       sendSignal(ref, GSN_FSAPPENDCONF, signal, 2, JBB);
@@ -754,7 +862,7 @@
 }
 
 #if defined NDB_WIN32
-int Ndbfs::translateErrno(int aErrno)
+Uint32 Ndbfs::translateErrno(int aErrno)
 {
   switch (aErrno)
     {
@@ -807,56 +915,8 @@
       return FsRef::fsErrUnknown;
     }
 }
-#elif defined NDB_OSE || defined NDB_SOFTOSE
-int Ndbfs::translateErrno(int aErrno)
-{
-  switch (aErrno)
-    {
-      //permission denied
-    case EACCES:
-    case EROFS:
-    case ENXIO:
-      return FsRef::fsErrPermissionDenied;
-      //temporary not accessible
-    case EAGAIN:
-    case ETIMEDOUT:
-    case ENOLCK:
-      return FsRef::fsErrTemporaryNotAccessible;
-      //no space left on device
-    case ENFILE:
-    case EDQUOT:
-    case ENOSPC:
-      return FsRef::fsErrNoSpaceLeftOnDevice;
-      //none valid parameters
-    case EINVAL:
-    case EFBIG:
-    case EBADF:
-    case ENAMETOOLONG:
-    case EFAULT:
-    case EISDIR:
-      return FsRef::fsErrInvalidParameters;
-      //environment error
-    case EMLINK:
-    case ELOOP:
-      return FsRef::fsErrEnvironmentError;
-
-      //no more process resources
-    case EMFILE:
-    case ENOMEM:
-      return FsRef::fsErrNoMoreResources;
-      //no file
-    case ENOENT:
-      return FsRef::fsErrFileDoesNotExist;
-
-    case ERR_ReadUnderflow:
-      return FsRef::fsErrReadUnderflow;
-
-    default:
-      return FsRef::fsErrUnknown;
-    }
-}
 #else
-int Ndbfs::translateErrno(int aErrno)
+Uint32 Ndbfs::translateErrno(int aErrno)
 {
   switch (aErrno)
     {
@@ -955,32 +1015,10 @@
    return;
 }
 
-bool Global_useO_SYNC = false;
-bool Global_useO_DIRECT = false;
-bool Global_unlinkO_CREAT = false;
-Uint32 Global_syncFreq = 1024 * 1024;
-
 void
 Ndbfs::execDUMP_STATE_ORD(Signal* signal)
 {
   if(signal->theData[0] == 19){
-    if(signal->length() > 1){
-      Global_useO_SYNC = signal->theData[1];
-    }
-    if(signal->length() > 2){
-      Global_syncFreq = signal->theData[2] * 1024 * 1024;
-    }
-    if(signal->length() > 3){
-      Global_unlinkO_CREAT = signal->theData[3];
-    }
-    if(signal->length() > 4){
-      Global_useO_DIRECT = signal->theData[4];
-    }
-    ndbout_c("useO_SYNC = %d syncFreq = %d unlinkO_CREATE = %d O_DIRECT = %d",
-	     Global_useO_SYNC,
-	     Global_syncFreq,
-	     Global_unlinkO_CREAT,
-	     Global_useO_DIRECT);
     return;
   }
   if(signal->theData[0] == DumpStateOrd::NdbfsDumpFileStat){
@@ -1030,7 +1068,7 @@
     ndbrequire(signal->getLength() == 2);
     Uint32 file= signal->theData[1];
     AsyncFile* openFile = theOpenFiles.find(file);
-    ndbrequire(openFile);
+    ndbrequire(openFile != 0);
     ndbout_c("File: %s %p", openFile->theFileName.c_str(), openFile);
     Request* curr = openFile->m_current_request;
     Request* last = openFile->m_last_request;
@@ -1045,11 +1083,20 @@
     ndbout << "All files: " << endl;
     for (unsigned i = 0; i < theFiles.size(); i++){
       AsyncFile* file = theFiles[i];
-      ndbout_c("%2d (0x%x): %s", i,file, file->isOpen()?"OPEN":"CLOSED");
+      ndbout_c("%2d (0x%lx): %s", i, (long) file, file->isOpen()?"OPEN":"CLOSED");
     }
   }
 }//Ndbfs::execDUMP_STATE_ORD()
 
+const char*
+Ndbfs::get_filename(Uint32 fd) const
+{
+  jamEntry();
+  const AsyncFile* openFile = theOpenFiles.find(fd);
+  if(openFile)
+    return openFile->theFileName.get_base_name();
+  return "";
+}
 
 
 BLOCK_FUNCTIONS(Ndbfs)