Exemplo n.º 1
0
/**
 * Create a new file on this (remote) meta-server. This is the 'toFile' on a rename() client call.
 *
 * Note: Replaces existing entry.
 *
 * @param buf serialized inode object
 * @param outUnlinkedInode the unlinked (owned) file (in case a file was overwritten
 * by the move operation); the caller is responsible for the deletion of the local file and the
 * corresponding object; may not be NULL
 */
FhgfsOpsErr MetaStore::moveRemoteFileInsert(EntryInfo* fromFileInfo, std::string toParentID,
   std::string newEntryName, const char* buf, FileInode** outUnlinkedInode)
{
   // note: we do not allow newEntry to be a file if the old entry was a directory (and vice versa)
   const char* logContext = "rename(): Insert remote entry";

   FhgfsOpsErr retVal = FhgfsOpsErr_INTERNAL;

   *outUnlinkedInode = NULL;

   SafeRWLock safeMetaStoreLock(&rwlock, SafeRWLock_READ); // L O C K

   DirInode* toParent = referenceDirUnlocked(toParentID, true);
   if(!toParent)
   {
      retVal = FhgfsOpsErr_PATHNOTEXISTS;
      safeMetaStoreLock.unlock(); // U N L O C K
      return retVal;
   }

   // toParent exists
   SafeRWLock toParentMutexLock(&toParent->rwlock, SafeRWLock_WRITE); // L O C K ( T O )


   DirEntry* overWrittenEntry = toParent->dirEntryCreateFromFileUnlocked(newEntryName);
   if (overWrittenEntry)
   {
      EntryInfo overWriteInfo;
      std::string parentID = overWrittenEntry->getID();
      overWrittenEntry->getEntryInfo(parentID, 0, &overWriteInfo);
      bool isSameInode;

      FhgfsOpsErr checkRes = checkRenameOverwrite(fromFileInfo, &overWriteInfo, isSameInode);

      if ((checkRes != FhgfsOpsErr_SUCCESS)  || ((checkRes == FhgfsOpsErr_SUCCESS) && isSameInode) )
      {
         retVal = checkRes;
         goto outUnlock;
      }

      // only unlink the dir-entry-name here, so we can still restore it from dir-entry-id
      FhgfsOpsErr unlinkRes = toParent->unlinkDirEntryUnlocked(newEntryName, overWrittenEntry,
         DirEntry_UNLINK_FILENAME);
      if (unlikely(unlinkRes != FhgfsOpsErr_SUCCESS) )
      {
         if (unlikely (unlinkRes == FhgfsOpsErr_PATHNOTEXISTS) )
            LogContext(logContext).log(Log_WARNING, "Unexpectedly failed to unlink file: " +
               toParent->entries.getDirEntryPathUnlocked() + newEntryName + ". ");
         else
         {
            LogContext(logContext).logErr("Failed to unlink existing file. Aborting rename().");
            retVal = unlinkRes;
            goto outUnlock;
         }
      }
   }

   { // create new dirEntry with inlined inode
      FileInode* inode = new FileInode(); // the deserialized inode
      bool deserializeRes = inode->deserializeMetaData(buf);
      if (deserializeRes == false)
      {
         LogContext("File rename").logErr("Bug: Deserialization of remote buffer failed. Are all "
            "meta servers running with the same version?" );
         retVal = FhgfsOpsErr_INTERNAL;

         delete inode;
         goto outUnlock;
      }

      // destructs inode
      retVal = mkMetaFileUnlocked(toParent, newEntryName, fromFileInfo->getEntryType(), inode);
   }

   if (overWrittenEntry && retVal == FhgfsOpsErr_SUCCESS)
   { // unlink the overwritten entry, will unlock, release and return
      bool unlinkedWasInlined = overWrittenEntry->getIsInodeInlined();

      FhgfsOpsErr unlinkRes = unlinkOverwrittenEntryUnlocked(toParent, overWrittenEntry,
         outUnlinkedInode);

      EntryInfo unlinkEntryInfo;
      overWrittenEntry->getEntryInfo(toParentID, 0, &unlinkEntryInfo);

      // unlock everything here, but do not release toParent yet.
      toParentMutexLock.unlock(); // U N L O C K ( T O )
      safeMetaStoreLock.unlock();

      // unlinkInodeLater() requires that everything was unlocked!
      if (unlinkRes == FhgfsOpsErr_INUSE)
      {
         unlinkRes = unlinkInodeLater(&unlinkEntryInfo, unlinkedWasInlined );
         if (unlinkRes == FhgfsOpsErr_AGAIN)
            unlinkRes = unlinkOverwrittenEntry(toParent, overWrittenEntry, outUnlinkedInode);

         if (unlinkRes != FhgfsOpsErr_SUCCESS && unlinkRes != FhgfsOpsErr_PATHNOTEXISTS)
            LogContext(logContext).logErr("Failed to unlink overwritten entry:"
               " FileName: "      + newEntryName                   +
               " ParentEntryID: " + toParent->getID()              +
               " entryID: "       + overWrittenEntry->getEntryID() +
               " Error: "         + FhgfsOpsErrTk::toErrString(unlinkRes) );
      }

      delete overWrittenEntry;

      releaseDir(toParentID);

      return retVal;
   }
   else
   if (overWrittenEntry)
   {
      // TODO: Restore the overwritten entry
   }

outUnlock:

   toParentMutexLock.unlock(); // U N L O C K ( T O )
   dirStore.releaseDir(toParent->getID() );

   safeMetaStoreLock.unlock();

   SAFE_DELETE(overWrittenEntry);

   return retVal;
}
Exemplo n.º 2
0
/**
 * Simple rename on the same server in the same directory.
 *
 * @param outUnlinkInode is the inode of a dirEntry being possibly overwritten (toName already
 *    existed).
 */
FhgfsOpsErr MetaStore::renameInSameDir(DirInode* parentDir, std::string fromName,
   std::string toName, FileInode** outUnlinkInode)
{
   const char* logContext = "Rename in dir";

   SafeRWLock safeLock(&rwlock, SafeRWLock_READ); // L O C K
   SafeRWLock fromMutexLock(&parentDir->rwlock, SafeRWLock_WRITE); // L O C K ( F R O M )

   FhgfsOpsErr retVal;
   FhgfsOpsErr unlinkRes;

   DirEntry* overWrittenEntry = NULL;

   retVal = performRenameEntryInSameDir(parentDir, fromName, toName, &overWrittenEntry);

   if (retVal != FhgfsOpsErr_SUCCESS)
   {
      fromMutexLock.unlock();
      safeLock.unlock();

      SAFE_DELETE(overWrittenEntry);

      return retVal;
   }

   EntryInfo unlinkEntryInfo;
   bool unlinkedWasInlined;

   if (overWrittenEntry)
   {
      std::string parentDirID = parentDir->getID();
      overWrittenEntry->getEntryInfo(parentDirID, 0, &unlinkEntryInfo);
      unlinkedWasInlined = overWrittenEntry->getIsInodeInlined();

      unlinkRes = unlinkOverwrittenEntryUnlocked(parentDir, overWrittenEntry, outUnlinkInode);
   }
   else
   {
      *outUnlinkInode = NULL;

      // irrelevant values, just to please the compiler
      unlinkRes = FhgfsOpsErr_SUCCESS;
      unlinkedWasInlined = true;
   }

   /* Now update the ctime (attribChangeTime) of the renamed entry.
    * Only do that for Directory dentry after giving up the DirInodes (fromMutex) lock
    * as dirStore.setAttr() will aquire the InodeDirStore:: lock
    * and the lock order is InodeDirStore:: and then DirInode::  (risk of deadlock) */

   DirEntry* entry = parentDir->dirEntryCreateFromFileUnlocked(toName);
   if (likely(entry) ) // entry was just renamed to, so very likely it exists
   {
      EntryInfo entryInfo;
      std::string parentID = parentDir->getID();
      entry->getEntryInfo(parentID, 0, &entryInfo);

      fromMutexLock.unlock();
      setAttrUnlocked(&entryInfo, 0, NULL); /* This will fail if the DirInode is on another
                                             * meta server, but as updating the ctime is not
                                             * a real posix requirement (but filesystems usually
                                             * do it) we simply ignore this issue for now. */

      SAFE_DELETE(entry);
   }
   else
      fromMutexLock.unlock();

   safeLock.unlock();

   // unlink later must be called after releasing all locks

   if (overWrittenEntry)
   {
      if (unlinkRes == FhgfsOpsErr_INUSE)
      {
         unlinkRes = unlinkInodeLater(&unlinkEntryInfo, unlinkedWasInlined );
         if (unlinkRes == FhgfsOpsErr_AGAIN)
         {
            unlinkRes = unlinkOverwrittenEntry(parentDir, overWrittenEntry, outUnlinkInode);
         }
      }

      if (unlinkRes != FhgfsOpsErr_SUCCESS && unlinkRes != FhgfsOpsErr_PATHNOTEXISTS)
      {
         LogContext(logContext).logErr("Failed to unlink overwritten entry:"
            " FileName: "      + toName                         +
            " ParentEntryID: " + parentDir->getID()             +
            " entryID: "       + overWrittenEntry->getEntryID() +
            " Error: "         + FhgfsOpsErrTk::toErrString(unlinkRes) );


         // TODO: Restore the dentry
      }
   }

   SAFE_DELETE(overWrittenEntry);

   return retVal;
}