got rid of 'src' folders in each sub-project

5 files changed, 1596 insertions, 0 deletions

diff --git a/src/core/file_sys/directory_file_system.cpp b/src/core/file_sys/directory_file_system.cpp
new file mode 100644
index 000000000..29369eec4
--- /dev/null
+++ b/src/core/file_sys/directory_file_system.cpp
@@ -0,0 +1,671 @@
+// Copyright (c) 2012- PPSSPP Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0 or later versions.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official git repository and contact information can be found at
+// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
+
+#include "chunk_file.h"
+#include "file_util.h"
+#include "directory_file_system.h"
+//#include "ISOFileSystem.h"
+//#include "Core/HLE/sceKernel.h"
+//#include "file/zip_read.h"
+#include "utf8.h"
+
+#if EMU_PLATFORM == PLATFORM_WINDOWS
+#include <windows.h>
+#include <sys/stat.h>
+#else
+#include <dirent.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <ctype.h>
+#endif
+
+#if HOST_IS_CASE_SENSITIVE
+static bool FixFilenameCase(const std::string &path, std::string &filename)
+{
+        // Are we lucky?
+        if (File::Exists(path + filename))
+                return true;
+
+        size_t filenameSize = filename.size();  // size in bytes, not characters
+        for (size_t i = 0; i < filenameSize; i++)
+        {
+                filename[i] = tolower(filename[i]);
+        }
+
+        //TODO: lookup filename in cache for "path"
+
+        struct dirent_large { struct dirent entry; char padding[FILENAME_MAX+1]; } diren;
+        struct dirent_large;
+        struct dirent *result = NULL;
+
+        DIR *dirp = opendir(path.c_str());
+        if (!dirp)
+                return false;
+
+        bool retValue = false;
+
+        while (!readdir_r(dirp, (dirent*) &diren, &result) && result)
+        {
+                if (strlen(result->d_name) != filenameSize)
+                        continue;
+
+                size_t i;
+                for (i = 0; i < filenameSize; i++)
+                {
+                        if (filename[i] != tolower(result->d_name[i]))
+                                break;
+                }
+
+                if (i < filenameSize)
+                        continue;
+
+                filename = result->d_name;
+                retValue = true;
+        }
+
+        closedir(dirp);
+
+        return retValue;
+}
+
+bool FixPathCase(std::string& basePath, std::string &path, FixPathCaseBehavior behavior)
+{
+        size_t len = path.size();
+
+        if (len == 0)
+                return true;
+
+        if (path[len - 1] == '/')
+        {
+                len--;
+
+                if (len == 0)
+                        return true;
+        }
+
+        std::string fullPath;
+        fullPath.reserve(basePath.size() + len + 1);
+        fullPath.append(basePath); 
+
+        size_t start = 0;
+        while (start < len)
+        {
+                size_t i = path.find('/', start);
+                if (i == std::string::npos)
+                        i = len;
+
+                if (i > start)
+                {
+                        std::string component = path.substr(start, i - start);
+
+                        // Fix case and stop on nonexistant path component
+                        if (FixFilenameCase(fullPath, component) == false) {
+                                // Still counts as success if partial matches allowed or if this
+                                // is the last component and only the ones before it are required
+                                return (behavior == FPC_PARTIAL_ALLOWED || (behavior == FPC_PATH_MUST_EXIST && i >= len));
+                        }
+
+                        path.replace(start, i - start, component);
+
+                        fullPath.append(component);
+                        fullPath.append(1, '/');
+                }
+
+                start = i + 1;
+        }
+
+        return true;
+}
+
+#endif
+
+std::string DirectoryFileHandle::GetLocalPath(std::string& basePath, std::string localpath)
+{
+        if (localpath.empty())
+                return basePath;
+
+        if (localpath[0] == '/')
+                localpath.erase(0,1);
+        //Convert slashes
+#ifdef _WIN32
+        for (size_t i = 0; i < localpath.size(); i++) {
+                if (localpath[i] == '/')
+                        localpath[i] = '\\';
+        }
+#endif
+        return basePath + localpath;
+}
+
+bool DirectoryFileHandle::Open(std::string& basePath, std::string& fileName, FileAccess access)
+{
+#if HOST_IS_CASE_SENSITIVE
+        if (access & (FILEACCESS_APPEND|FILEACCESS_CREATE|FILEACCESS_WRITE))
+        {
+                DEBUG_LOG(FILESYS, "Checking case for path %s", fileName.c_str());
+                if ( ! FixPathCase(basePath, fileName, FPC_PATH_MUST_EXIST) )
+                        return false;  // or go on and attempt (for a better error code than just 0?)
+        }
+        // else we try fopen first (in case we're lucky) before simulating case insensitivity
+#endif
+
+        std::string fullName = GetLocalPath(basePath,fileName);
+        INFO_LOG(FILESYS,"Actually opening %s", fullName.c_str());
+
+        //TODO: tests, should append seek to end of file? seeking in a file opened for append?
+#ifdef _WIN32
+        // Convert parameters to Windows permissions and access
+        DWORD desired = 0;
+        DWORD sharemode = 0;
+        DWORD openmode = 0;
+        if (access & FILEACCESS_READ) {
+                desired   |= GENERIC_READ;
+                sharemode |= FILE_SHARE_READ;
+        }
+        if (access & FILEACCESS_WRITE) {
+                desired   |= GENERIC_WRITE;
+                sharemode |= FILE_SHARE_WRITE;
+        }
+        if (access & FILEACCESS_CREATE) {
+                openmode = OPEN_ALWAYS;
+        } else {
+                openmode = OPEN_EXISTING;
+        }
+        //Let's do it!
+        hFile = CreateFile(ConvertUTF8ToWString(fullName).c_str(), desired, sharemode, 0, openmode, 0, 0);
+        bool success = hFile != INVALID_HANDLE_VALUE;
+#else
+        // Convert flags in access parameter to fopen access mode
+        const char *mode = NULL;
+        if (access & FILEACCESS_APPEND) {
+                if (access & FILEACCESS_READ)
+                        mode = "ab+";  // append+read, create if needed
+                else
+                        mode = "ab";  // append only, create if needed
+        } else if (access & FILEACCESS_WRITE) {
+                if (access & FILEACCESS_READ) {
+                        // FILEACCESS_CREATE is ignored for read only, write only, and append
+                        // because C++ standard fopen's nonexistant file creation can only be
+                        // customized for files opened read+write
+                        if (access & FILEACCESS_CREATE)
+                                mode = "wb+";  // read+write, create if needed
+                        else
+                                mode = "rb+";  // read+write, but don't create
+                } else {
+                        mode = "wb";  // write only, create if needed
+                }
+        } else {  // neither write nor append, so default to read only
+                mode = "rb";  // read only, don't create
+        }
+
+        hFile = fopen(fullName.c_str(), mode);
+        bool success = hFile != 0;
+#endif
+
+#if HOST_IS_CASE_SENSITIVE
+        if (!success &&
+            !(access & FILEACCESS_APPEND) &&
+            !(access & FILEACCESS_CREATE) &&
+            !(access & FILEACCESS_WRITE))
+        {
+                if ( ! FixPathCase(basePath,fileName, FPC_PATH_MUST_EXIST) )
+                        return 0;  // or go on and attempt (for a better error code than just 0?)
+                fullName = GetLocalPath(basePath,fileName); 
+                const char* fullNameC = fullName.c_str();
+
+                DEBUG_LOG(FILESYS, "Case may have been incorrect, second try opening %s (%s)", fullNameC, fileName.c_str());
+
+                // And try again with the correct case this time
+#ifdef _WIN32
+                hFile = CreateFile(fullNameC, desired, sharemode, 0, openmode, 0, 0);
+                success = hFile != INVALID_HANDLE_VALUE;
+#else
+                hFile = fopen(fullNameC, mode);
+                success = hFile != 0;
+#endif
+        }
+#endif
+
+        return success;
+}
+
+size_t DirectoryFileHandle::Read(u8* pointer, s64 size)
+{
+        size_t bytesRead = 0;
+#ifdef _WIN32
+        ::ReadFile(hFile, (LPVOID)pointer, (DWORD)size, (LPDWORD)&bytesRead, 0);
+#else
+        bytesRead = fread(pointer, 1, size, hFile);
+#endif
+        return bytesRead;
+}
+
+size_t DirectoryFileHandle::Write(const u8* pointer, s64 size)
+{
+        size_t bytesWritten = 0;
+#ifdef _WIN32
+        ::WriteFile(hFile, (LPVOID)pointer, (DWORD)size, (LPDWORD)&bytesWritten, 0);
+#else
+        bytesWritten = fwrite(pointer, 1, size, hFile);
+#endif
+        return bytesWritten;
+}
+
+size_t DirectoryFileHandle::Seek(s32 position, FileMove type)
+{
+#ifdef _WIN32
+        DWORD moveMethod = 0;
+        switch (type) {
+        case FILEMOVE_BEGIN:    moveMethod = FILE_BEGIN;    break;
+        case FILEMOVE_CURRENT:  moveMethod = FILE_CURRENT;  break;
+        case FILEMOVE_END:      moveMethod = FILE_END;      break;
+        }
+        DWORD newPos = SetFilePointer(hFile, (LONG)position, 0, moveMethod);
+        return newPos;
+#else
+        int moveMethod = 0;
+        switch (type) {
+        case FILEMOVE_BEGIN:    moveMethod = SEEK_SET;  break;
+        case FILEMOVE_CURRENT:  moveMethod = SEEK_CUR;  break;
+        case FILEMOVE_END:      moveMethod = SEEK_END;  break;
+        }
+        fseek(hFile, position, moveMethod);
+        return ftell(hFile);
+#endif
+}
+
+void DirectoryFileHandle::Close()
+{
+#ifdef _WIN32
+        if (hFile != (HANDLE)-1)
+                CloseHandle(hFile);
+#else
+        if (hFile != 0)
+                fclose(hFile);
+#endif
+}
+
+DirectoryFileSystem::DirectoryFileSystem(IHandleAllocator *_hAlloc, std::string _basePath) : basePath(_basePath) {
+        File::CreateFullPath(basePath);
+        hAlloc = _hAlloc;
+}
+
+DirectoryFileSystem::~DirectoryFileSystem() {
+        for (auto iter = entries.begin(); iter != entries.end(); ++iter) {
+                iter->second.hFile.Close();
+        }
+}
+
+std::string DirectoryFileSystem::GetLocalPath(std::string localpath) {
+        if (localpath.empty())
+                return basePath;
+
+        if (localpath[0] == '/')
+                localpath.erase(0,1);
+        //Convert slashes
+#ifdef _WIN32
+        for (size_t i = 0; i < localpath.size(); i++) {
+                if (localpath[i] == '/')
+                        localpath[i] = '\\';
+        }
+#endif
+        return basePath + localpath;
+}
+
+bool DirectoryFileSystem::MkDir(const std::string &dirname) {
+#if HOST_IS_CASE_SENSITIVE
+        // Must fix case BEFORE attempting, because MkDir would create
+        // duplicate (different case) directories
+
+        std::string fixedCase = dirname;
+        if ( ! FixPathCase(basePath,fixedCase, FPC_PARTIAL_ALLOWED) )
+                return false;
+
+        return File::CreateFullPath(GetLocalPath(fixedCase));
+#else
+        return File::CreateFullPath(GetLocalPath(dirname));
+#endif
+}
+
+bool DirectoryFileSystem::RmDir(const std::string &dirname) {
+        std::string fullName = GetLocalPath(dirname);
+
+#if HOST_IS_CASE_SENSITIVE
+        // Maybe we're lucky?
+        if (File::DeleteDirRecursively(fullName))
+                return true;
+
+        // Nope, fix case and try again
+        fullName = dirname;
+        if ( ! FixPathCase(basePath,fullName, FPC_FILE_MUST_EXIST) )
+                return false;  // or go on and attempt (for a better error code than just false?)
+
+        fullName = GetLocalPath(fullName);
+#endif
+
+/*#ifdef _WIN32
+        return RemoveDirectory(fullName.c_str()) == TRUE;
+#else
+        return 0 == rmdir(fullName.c_str());
+#endif*/
+        return File::DeleteDirRecursively(fullName);
+}
+
+int DirectoryFileSystem::RenameFile(const std::string &from, const std::string &to) {
+        std::string fullTo = to;
+
+        // Rename ignores the path (even if specified) on to.
+        size_t chop_at = to.find_last_of('/');
+        if (chop_at != to.npos)
+                fullTo = to.substr(chop_at + 1);
+
+        // Now put it in the same directory as from.
+        size_t dirname_end = from.find_last_of('/');
+        if (dirname_end != from.npos)
+                fullTo = from.substr(0, dirname_end + 1) + fullTo;
+
+        // At this point, we should check if the paths match and give an already exists error.
+        if (from == fullTo)
+                return -1;//SCE_KERNEL_ERROR_ERRNO_FILE_ALREADY_EXISTS;
+
+        std::string fullFrom = GetLocalPath(from);
+
+#if HOST_IS_CASE_SENSITIVE
+        // In case TO should overwrite a file with different case
+        if ( ! FixPathCase(basePath,fullTo, FPC_PATH_MUST_EXIST) )
+                return -1;  // or go on and attempt (for a better error code than just false?)
+#endif
+
+        fullTo = GetLocalPath(fullTo);
+        const char * fullToC = fullTo.c_str();
+
+#ifdef _WIN32
+        bool retValue = (MoveFile(ConvertUTF8ToWString(fullFrom).c_str(), ConvertUTF8ToWString(fullToC).c_str()) == TRUE);
+#else
+        bool retValue = (0 == rename(fullFrom.c_str(), fullToC));
+#endif
+
+#if HOST_IS_CASE_SENSITIVE
+        if (! retValue)
+        {
+                // May have failed due to case sensitivity on FROM, so try again
+                fullFrom = from;
+                if ( ! FixPathCase(basePath,fullFrom, FPC_FILE_MUST_EXIST) )
+                        return -1;  // or go on and attempt (for a better error code than just false?)
+                fullFrom = GetLocalPath(fullFrom);
+
+#ifdef _WIN32
+                retValue = (MoveFile(fullFrom.c_str(), fullToC) == TRUE);
+#else
+                retValue = (0 == rename(fullFrom.c_str(), fullToC));
+#endif
+        }
+#endif
+
+        // TODO: Better error codes.
+        return retValue ? 0 : -1;//SCE_KERNEL_ERROR_ERRNO_FILE_ALREADY_EXISTS;
+}
+
+bool DirectoryFileSystem::RemoveFile(const std::string &filename) {
+        std::string fullName = GetLocalPath(filename);
+#ifdef _WIN32
+        bool retValue = (::DeleteFileA(fullName.c_str()) == TRUE);
+#else
+        bool retValue = (0 == unlink(fullName.c_str()));
+#endif
+
+#if HOST_IS_CASE_SENSITIVE
+        if (! retValue)
+        {
+                // May have failed due to case sensitivity, so try again
+                fullName = filename;
+                if ( ! FixPathCase(basePath,fullName, FPC_FILE_MUST_EXIST) )
+                        return false;  // or go on and attempt (for a better error code than just false?)
+                fullName = GetLocalPath(fullName);
+
+#ifdef _WIN32
+                retValue = (::DeleteFileA(fullName.c_str()) == TRUE);
+#else
+                retValue = (0 == unlink(fullName.c_str()));
+#endif
+        }
+#endif
+
+        return retValue;
+}
+
+u32 DirectoryFileSystem::OpenFile(std::string filename, FileAccess access, const char *devicename) {
+        OpenFileEntry entry;
+        bool success = entry.hFile.Open(basePath,filename,access);
+
+        if (!success) {
+#ifdef _WIN32
+                ERROR_LOG(FILESYS, "DirectoryFileSystem::OpenFile: FAILED, %i - access = %i", GetLastError(), (int)access);
+#else
+                ERROR_LOG(FILESYS, "DirectoryFileSystem::OpenFile: FAILED, access = %i", (int)access);
+#endif
+                //wwwwaaaaahh!!
+                return 0;
+        } else {
+#ifdef _WIN32
+                if (access & FILEACCESS_APPEND)
+                        entry.hFile.Seek(0,FILEMOVE_END);
+#endif
+
+                u32 newHandle = hAlloc->GetNewHandle();
+                entries[newHandle] = entry;
+
+                return newHandle;
+        }
+}
+
+void DirectoryFileSystem::CloseFile(u32 handle) {
+        EntryMap::iterator iter = entries.find(handle);
+        if (iter != entries.end()) {
+                hAlloc->FreeHandle(handle);
+                iter->second.hFile.Close();
+                entries.erase(iter);
+        } else {
+                //This shouldn't happen...
+                ERROR_LOG(FILESYS,"Cannot close file that hasn't been opened: %08x", handle);
+        }
+}
+
+bool DirectoryFileSystem::OwnsHandle(u32 handle) {
+        EntryMap::iterator iter = entries.find(handle);
+        return (iter != entries.end());
+}
+
+size_t DirectoryFileSystem::ReadFile(u32 handle, u8 *pointer, s64 size) {
+        EntryMap::iterator iter = entries.find(handle);
+        if (iter != entries.end())
+        {
+                size_t bytesRead = iter->second.hFile.Read(pointer,size);
+                return bytesRead;
+        } else {
+                //This shouldn't happen...
+                ERROR_LOG(FILESYS,"Cannot read file that hasn't been opened: %08x", handle);
+                return 0;
+        }
+}
+
+size_t DirectoryFileSystem::WriteFile(u32 handle, const u8 *pointer, s64 size) {
+        EntryMap::iterator iter = entries.find(handle);
+        if (iter != entries.end())
+        {
+                size_t bytesWritten = iter->second.hFile.Write(pointer,size);
+                return bytesWritten;
+        } else {
+                //This shouldn't happen...
+                ERROR_LOG(FILESYS,"Cannot write to file that hasn't been opened: %08x", handle);
+                return 0;
+        }
+}
+
+size_t DirectoryFileSystem::SeekFile(u32 handle, s32 position, FileMove type) {
+        EntryMap::iterator iter = entries.find(handle);
+        if (iter != entries.end()) {
+                return iter->second.hFile.Seek(position,type);
+        } else {
+                //This shouldn't happen...
+                ERROR_LOG(FILESYS,"Cannot seek in file that hasn't been opened: %08x", handle);
+                return 0;
+        }
+}
+
+FileInfo DirectoryFileSystem::GetFileInfo(std::string filename) {
+        FileInfo x;
+        x.name = filename;
+
+        std::string fullName = GetLocalPath(filename);
+        if (! File::Exists(fullName)) {
+#if HOST_IS_CASE_SENSITIVE
+                if (! FixPathCase(basePath,filename, FPC_FILE_MUST_EXIST))
+                        return x;
+                fullName = GetLocalPath(filename);
+
+                if (! File::Exists(fullName))
+                        return x;
+#else
+                return x;
+#endif
+        }
+        x.type = File::IsDirectory(fullName) ? FILETYPE_DIRECTORY : FILETYPE_NORMAL;
+        x.exists = true;
+
+        if (x.type != FILETYPE_DIRECTORY)
+        {
+#ifdef _WIN32
+                struct _stat64i32 s;
+                _wstat64i32(ConvertUTF8ToWString(fullName).c_str(), &s);
+#else
+                struct stat s;
+                stat(fullName.c_str(), &s);
+#endif
+
+                x.size = File::GetSize(fullName);
+                x.access = s.st_mode & 0x1FF;
+                localtime_r((time_t*)&s.st_atime,&x.atime);
+                localtime_r((time_t*)&s.st_ctime,&x.ctime);
+                localtime_r((time_t*)&s.st_mtime,&x.mtime);
+        }
+
+        return x;
+}
+
+bool DirectoryFileSystem::GetHostPath(const std::string &inpath, std::string &outpath) {
+        outpath = GetLocalPath(inpath);
+        return true;
+}
+
+#ifdef _WIN32
+#define FILETIME_FROM_UNIX_EPOCH_US 11644473600000000ULL
+
+static void tmFromFiletime(tm &dest, FILETIME &src)
+{
+        u64 from_1601_us = (((u64) src.dwHighDateTime << 32ULL) + (u64) src.dwLowDateTime) / 10ULL;
+        u64 from_1970_us = from_1601_us - FILETIME_FROM_UNIX_EPOCH_US;
+
+        time_t t = (time_t) (from_1970_us / 1000000UL);
+        localtime_r(&t, &dest);
+}
+#endif
+
+std::vector<FileInfo> DirectoryFileSystem::GetDirListing(std::string path) {
+        std::vector<FileInfo> myVector;
+#ifdef _WIN32
+        WIN32_FIND_DATA findData;
+        HANDLE hFind;
+
+        std::string w32path = GetLocalPath(path) + "\\*.*";
+
+        hFind = FindFirstFile(ConvertUTF8ToWString(w32path).c_str(), &findData);
+
+        if (hFind == INVALID_HANDLE_VALUE) {
+                return myVector; //the empty list
+        }
+
+        while (true) {
+                FileInfo entry;
+                if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+                        entry.type = FILETYPE_DIRECTORY;
+                else
+                        entry.type = FILETYPE_NORMAL;
+
+                // TODO: Make this more correct?
+                entry.access = entry.type == FILETYPE_NORMAL ? 0666 : 0777;
+                // TODO: is this just for .. or all subdirectories? Need to add a directory to the test
+                // to find out. Also why so different than the old test results?
+                if (!wcscmp(findData.cFileName, L"..") )
+                        entry.size = 4096;
+                else
+                        entry.size = findData.nFileSizeLow | ((u64)findData.nFileSizeHigh<<32);
+                entry.name = ConvertWStringToUTF8(findData.cFileName);
+                tmFromFiletime(entry.atime, findData.ftLastAccessTime);
+                tmFromFiletime(entry.ctime, findData.ftCreationTime);
+                tmFromFiletime(entry.mtime, findData.ftLastWriteTime);
+                myVector.push_back(entry);
+
+                int retval = FindNextFile(hFind, &findData);
+                if (!retval)
+                        break;
+        }
+#else
+        dirent *dirp;
+        std::string localPath = GetLocalPath(path);
+        DIR *dp = opendir(localPath.c_str());
+
+#if HOST_IS_CASE_SENSITIVE
+        if(dp == NULL && FixPathCase(basePath,path, FPC_FILE_MUST_EXIST)) {
+                // May have failed due to case sensitivity, try again
+                localPath = GetLocalPath(path);
+                dp = opendir(localPath.c_str());
+        }
+#endif
+
+        if (dp == NULL) {
+                ERROR_LOG(FILESYS,"Error opening directory %s\n",path.c_str());
+                return myVector;
+        }
+
+        while ((dirp = readdir(dp)) != NULL) {
+                FileInfo entry;
+                struct stat s;
+                std::string fullName = GetLocalPath(path) + "/"+dirp->d_name;
+                stat(fullName.c_str(), &s);
+                if (S_ISDIR(s.st_mode))
+                        entry.type = FILETYPE_DIRECTORY;
+                else
+                        entry.type = FILETYPE_NORMAL;
+                entry.access = s.st_mode & 0x1FF;
+                entry.name = dirp->d_name;
+                entry.size = s.st_size;
+                localtime_r((time_t*)&s.st_atime,&entry.atime);
+                localtime_r((time_t*)&s.st_ctime,&entry.ctime);
+                localtime_r((time_t*)&s.st_mtime,&entry.mtime);
+                myVector.push_back(entry);
+        }
+        closedir(dp);
+#endif
+        return myVector;
+}
+
+void DirectoryFileSystem::DoState(PointerWrap &p) {
+        if (!entries.empty()) {
+                p.SetError(p.ERROR_WARNING);
+                ERROR_LOG(FILESYS, "FIXME: Open files during savestate, could go badly.");
+        }
+}
diff --git a/src/core/file_sys/directory_file_system.h b/src/core/file_sys/directory_file_system.h
new file mode 100644
index 000000000..a11331a27
--- /dev/null
+++ b/src/core/file_sys/directory_file_system.h
@@ -0,0 +1,158 @@
+// Copyright (c) 2012- PPSSPP Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0 or later versions.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official git repository and contact information can be found at
+// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
+
+#ifndef CORE_FILE_SYS_DIRECTORY_H_
+#define CORE_FILE_SYS_DIRECTORY_H_
+
+// TODO: Remove the Windows-specific code, FILE is fine there too.
+
+#include <map>
+
+#include "file_sys.h"
+
+#ifdef _WIN32
+typedef void * HANDLE;
+#endif
+
+#if defined(__APPLE__)
+
+#if TARGET_OS_IPHONE
+#define HOST_IS_CASE_SENSITIVE 1
+#elif TARGET_IPHONE_SIMULATOR
+#define HOST_IS_CASE_SENSITIVE 0
+#else
+// Mac OSX case sensitivity defaults off, but is user configurable (when
+// creating a filesytem), so assume the worst:
+#define HOST_IS_CASE_SENSITIVE 1
+#endif
+
+#elif defined(_WIN32) || defined(__SYMBIAN32__)
+#define HOST_IS_CASE_SENSITIVE 0
+
+#else  // Android, Linux, BSD (and the rest?)
+#define HOST_IS_CASE_SENSITIVE 1
+
+#endif
+
+#if HOST_IS_CASE_SENSITIVE
+enum FixPathCaseBehavior {
+        FPC_FILE_MUST_EXIST,  // all path components must exist (rmdir, move from)
+        FPC_PATH_MUST_EXIST,  // all except the last one must exist - still tries to fix last one (fopen, move to)
+        FPC_PARTIAL_ALLOWED,  // don't care how many exist (mkdir recursive)
+};
+
+bool FixPathCase(std::string& basePath, std::string &path, FixPathCaseBehavior behavior);
+#endif
+
+struct DirectoryFileHandle
+{
+#ifdef _WIN32
+        HANDLE hFile;
+#else
+        FILE* hFile;
+#endif
+        DirectoryFileHandle()
+        {
+#ifdef _WIN32
+                hFile = (HANDLE)-1;
+#else
+                hFile = 0;
+#endif
+        }
+
+        std::string GetLocalPath(std::string& basePath, std::string localpath);
+        bool Open(std::string& basePath, std::string& fileName, FileAccess access);
+        size_t Read(u8* pointer, s64 size);
+        size_t Write(const u8* pointer, s64 size);
+        size_t Seek(s32 position, FileMove type);
+        void Close();
+};
+
+class DirectoryFileSystem : public IFileSystem {
+public:
+        DirectoryFileSystem(IHandleAllocator *_hAlloc, std::string _basePath);
+        ~DirectoryFileSystem();
+
+        void DoState(PointerWrap &p);
+        std::vector<FileInfo> GetDirListing(std::string path);
+        u32      OpenFile(std::string filename, FileAccess access, const char *devicename=NULL);
+        void     CloseFile(u32 handle);
+        size_t   ReadFile(u32 handle, u8 *pointer, s64 size);
+        size_t   WriteFile(u32 handle, const u8 *pointer, s64 size);
+        size_t   SeekFile(u32 handle, s32 position, FileMove type);
+        FileInfo GetFileInfo(std::string filename);
+        bool     OwnsHandle(u32 handle);
+
+        bool MkDir(const std::string &dirname);
+        bool RmDir(const std::string &dirname);
+        int  RenameFile(const std::string &from, const std::string &to);
+        bool RemoveFile(const std::string &filename);
+        bool GetHostPath(const std::string &inpath, std::string &outpath);
+
+private:
+        struct OpenFileEntry {
+                DirectoryFileHandle hFile;
+        };
+
+        typedef std::map<u32, OpenFileEntry> EntryMap;
+        EntryMap entries;
+        std::string basePath;
+        IHandleAllocator *hAlloc;
+
+        // In case of Windows: Translate slashes, etc.
+        std::string GetLocalPath(std::string localpath);
+};
+
+// VFSFileSystem: Ability to map in Android APK paths as well! Does not support all features, only meant for fonts.
+// Very inefficient - always load the whole file on open.
+class VFSFileSystem : public IFileSystem {
+public:
+        VFSFileSystem(IHandleAllocator *_hAlloc, std::string _basePath);
+        ~VFSFileSystem();
+
+        void DoState(PointerWrap &p);
+        std::vector<FileInfo> GetDirListing(std::string path);
+        u32      OpenFile(std::string filename, FileAccess access, const char *devicename=NULL);
+        void     CloseFile(u32 handle);
+        size_t   ReadFile(u32 handle, u8 *pointer, s64 size);
+        size_t   WriteFile(u32 handle, const u8 *pointer, s64 size);
+        size_t   SeekFile(u32 handle, s32 position, FileMove type);
+        FileInfo GetFileInfo(std::string filename);
+        bool     OwnsHandle(u32 handle);
+
+        bool MkDir(const std::string &dirname);
+        bool RmDir(const std::string &dirname);
+        int  RenameFile(const std::string &from, const std::string &to);
+        bool RemoveFile(const std::string &filename);
+        bool GetHostPath(const std::string &inpath, std::string &outpath);
+
+private:
+        struct OpenFileEntry {
+                u8 *fileData;
+                size_t size;
+                size_t seekPos;
+        };
+
+        typedef std::map<u32, OpenFileEntry> EntryMap;
+        EntryMap entries;
+        std::string basePath;
+        IHandleAllocator *hAlloc;
+
+        std::string GetLocalPath(std::string localpath);
+};
+
+#endif // CORE_FILE_SYS_DIRECTORY_H_
diff --git a/src/core/file_sys/file_sys.h b/src/core/file_sys/file_sys.h
new file mode 100644
index 000000000..b27e36c80
--- /dev/null
+++ b/src/core/file_sys/file_sys.h
@@ -0,0 +1,138 @@
+// Copyright (c) 2012- PPSSPP Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0 or later versions.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official git repository and contact information can be found at
+// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
+
+#pragma once
+
+#include "common.h"
+#include "chunk_file.h"
+
+enum FileAccess {
+        FILEACCESS_NONE=0,
+        FILEACCESS_READ=1,
+        FILEACCESS_WRITE=2,
+        FILEACCESS_APPEND=4,
+        FILEACCESS_CREATE=8
+};
+
+enum FileMove {
+        FILEMOVE_BEGIN=0,
+        FILEMOVE_CURRENT=1,
+        FILEMOVE_END=2
+};
+
+enum FileType {
+        FILETYPE_NORMAL=1,
+        FILETYPE_DIRECTORY=2
+};
+
+
+class IHandleAllocator {
+public:
+        virtual ~IHandleAllocator() {}
+        virtual u32 GetNewHandle() = 0;
+        virtual void FreeHandle(u32 handle) = 0;
+};
+
+class SequentialHandleAllocator : public IHandleAllocator {
+public:
+        SequentialHandleAllocator() : handle_(1) {}
+        virtual u32 GetNewHandle() { return handle_++; }
+        virtual void FreeHandle(u32 handle) {}
+private:
+        int handle_;
+};
+
+struct FileInfo {
+        FileInfo() 
+                : size(0), access(0), exists(false), type(FILETYPE_NORMAL), isOnSectorSystem(false), startSector(0), numSectors(0) {}
+
+        void DoState(PointerWrap &p) {
+                auto s = p.Section("FileInfo", 1);
+                if (!s)
+                        return;
+
+                p.Do(name);
+                p.Do(size);
+                p.Do(access);
+                p.Do(exists);
+                p.Do(type);
+                p.Do(atime);
+                p.Do(ctime);
+                p.Do(mtime);
+                p.Do(isOnSectorSystem);
+                p.Do(startSector);
+                p.Do(numSectors);
+                p.Do(sectorSize);
+        }
+
+        std::string name;
+        s64 size;
+        u32 access; //unix 777
+        bool exists;
+        FileType type;
+
+        tm atime;
+        tm ctime;
+        tm mtime;
+
+        bool isOnSectorSystem;
+        u32 startSector;
+        u32 numSectors;
+        u32 sectorSize;
+};
+
+
+class IFileSystem {
+public:
+        virtual ~IFileSystem() {}
+
+        virtual void DoState(PointerWrap &p) = 0;
+        virtual std::vector<FileInfo> GetDirListing(std::string path) = 0;
+        virtual u32      OpenFile(std::string filename, FileAccess access, const char *devicename=NULL) = 0;
+        virtual void     CloseFile(u32 handle) = 0;
+        virtual size_t   ReadFile(u32 handle, u8 *pointer, s64 size) = 0;
+        virtual size_t   WriteFile(u32 handle, const u8 *pointer, s64 size) = 0;
+        virtual size_t   SeekFile(u32 handle, s32 position, FileMove type) = 0;
+        virtual FileInfo GetFileInfo(std::string filename) = 0;
+        virtual bool     OwnsHandle(u32 handle) = 0;
+        virtual bool     MkDir(const std::string &dirname) = 0;
+        virtual bool     RmDir(const std::string &dirname) = 0;
+        virtual int      RenameFile(const std::string &from, const std::string &to) = 0;
+        virtual bool     RemoveFile(const std::string &filename) = 0;
+        virtual bool     GetHostPath(const std::string &inpath, std::string &outpath) = 0;
+};
+
+
+class EmptyFileSystem : public IFileSystem {
+public:
+        virtual void DoState(PointerWrap &p) {}
+        std::vector<FileInfo> GetDirListing(std::string path) {std::vector<FileInfo> vec; return vec;}
+        u32      OpenFile(std::string filename, FileAccess access, const char *devicename=NULL) {return 0;}
+        void     CloseFile(u32 handle) {}
+        size_t   ReadFile(u32 handle, u8 *pointer, s64 size) {return 0;}
+        size_t   WriteFile(u32 handle, const u8 *pointer, s64 size) {return 0;}
+        size_t   SeekFile(u32 handle, s32 position, FileMove type) {return 0;}
+        FileInfo GetFileInfo(std::string filename) {FileInfo f; return f;}
+        bool     OwnsHandle(u32 handle) {return false;}
+        virtual bool MkDir(const std::string &dirname) {return false;}
+        virtual bool RmDir(const std::string &dirname) {return false;}
+        virtual int RenameFile(const std::string &from, const std::string &to) {return -1;}
+        virtual bool RemoveFile(const std::string &filename) {return false;}
+        virtual bool GetHostPath(const std::string &inpath, std::string &outpath) {return false;}
+};
+
+
diff --git a/src/core/file_sys/meta_file_system.cpp b/src/core/file_sys/meta_file_system.cpp
new file mode 100644
index 000000000..f86c3cb18
--- /dev/null
+++ b/src/core/file_sys/meta_file_system.cpp
@@ -0,0 +1,520 @@
+// Copyright (c) 2012- PPSSPP Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0 or later versions.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official git repository and contact information can be found at
+// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
+
+#include <set>
+#include <algorithm>
+#include "string_util.h"
+#include "file_sys/meta_file_system.h"
+//#include "Core/HLE/sceKernelThread.h"
+//#include "Core/Reporting.h"
+
+static bool ApplyPathStringToComponentsVector(std::vector<std::string> &vector, const std::string &pathString)
+{
+        size_t len = pathString.length();
+        size_t start = 0;
+
+        while (start < len)
+        {
+                size_t i = pathString.find('/', start);
+                if (i == std::string::npos)
+                        i = len;
+
+                if (i > start)
+                {
+                        std::string component = pathString.substr(start, i - start);
+                        if (component != ".")
+                        {
+                                if (component == "..")
+                                {
+                                        if (vector.size() != 0)
+                                        {
+                                                vector.pop_back();
+                                        }
+                                        else
+                                        {
+                                                // The PSP silently ignores attempts to .. to parent of root directory
+                                                WARN_LOG(FILESYS, "RealPath: ignoring .. beyond root - root directory is its own parent: \"%s\"", pathString.c_str());
+                                        }
+                                }
+                                else
+                                {
+                                        vector.push_back(component);
+                                }
+                        }
+                }
+
+                start = i + 1;
+        }
+
+        return true;
+}
+
+/*
+ * Changes relative paths to absolute, removes ".", "..", and trailing "/"
+ * "drive:./blah" is absolute (ignore the dot) and "/blah" is relative (because it's missing "drive:")
+ * babel (and possibly other games) use "/directoryThatDoesNotExist/../directoryThatExists/filename"
+ */
+static bool RealPath(const std::string &currentDirectory, const std::string &inPath, std::string &outPath)
+{
+        size_t inLen = inPath.length();
+        if (inLen == 0)
+        {
+                WARN_LOG(FILESYS, "RealPath: inPath is empty");
+                outPath = currentDirectory;
+                return true;
+        }
+
+        size_t inColon = inPath.find(':');
+        if (inColon + 1 == inLen)
+        {
+                // There's nothing after the colon, e.g. umd0: - this is perfectly valid.
+                outPath = inPath;
+                return true;
+        }
+
+        bool relative = (inColon == std::string::npos);
+        
+        std::string prefix, inAfterColon;
+        std::vector<std::string> cmpnts;  // path components
+        size_t outPathCapacityGuess = inPath.length();
+
+        if (relative)
+        {
+                size_t curDirLen = currentDirectory.length();
+                if (curDirLen == 0)
+                {
+                        ERROR_LOG(FILESYS, "RealPath: inPath \"%s\" is relative, but current directory is empty", inPath.c_str());
+                        return false;
+                }
+                
+                size_t curDirColon = currentDirectory.find(':');
+                if (curDirColon == std::string::npos)
+                {
+                        ERROR_LOG(FILESYS, "RealPath: inPath \"%s\" is relative, but current directory \"%s\" has no prefix", inPath.c_str(), currentDirectory.c_str());
+                        return false;
+                }
+                if (curDirColon + 1 == curDirLen)
+                {
+                        ERROR_LOG(FILESYS, "RealPath: inPath \"%s\" is relative, but current directory \"%s\" is all prefix and no path. Using \"/\" as path for current directory.", inPath.c_str(), currentDirectory.c_str());
+                }
+                else
+                {
+                        const std::string curDirAfter = currentDirectory.substr(curDirColon + 1);
+                        if (! ApplyPathStringToComponentsVector(cmpnts, curDirAfter) )
+                        {
+                                ERROR_LOG(FILESYS,"RealPath: currentDirectory is not a valid path: \"%s\"", currentDirectory.c_str());
+                                return false;
+                        }
+
+                        outPathCapacityGuess += curDirLen;
+                }
+
+                prefix = currentDirectory.substr(0, curDirColon + 1);
+                inAfterColon = inPath;
+        }
+        else
+        {
+                prefix = inPath.substr(0, inColon + 1);
+                inAfterColon = inPath.substr(inColon + 1);
+        }
+
+        // Special case: "disc0:" is different from "disc0:/", so keep track of the single slash.
+        if (inAfterColon == "/")
+        {
+                outPath = prefix + inAfterColon;
+                return true;
+        }
+
+        if (! ApplyPathStringToComponentsVector(cmpnts, inAfterColon) )
+        {
+                WARN_LOG(FILESYS, "RealPath: inPath is not a valid path: \"%s\"", inPath.c_str());
+                return false;
+        }
+
+        outPath.clear();
+        outPath.reserve(outPathCapacityGuess);
+
+        outPath.append(prefix);
+
+        size_t numCmpnts = cmpnts.size();
+        for (size_t i = 0; i < numCmpnts; i++)
+        {
+                outPath.append(1, '/');
+                outPath.append(cmpnts[i]);
+        }
+
+        return true;
+}
+
+IFileSystem *MetaFileSystem::GetHandleOwner(u32 handle)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        for (size_t i = 0; i < fileSystems.size(); i++)
+        {
+                if (fileSystems[i].system->OwnsHandle(handle))
+                        return fileSystems[i].system; //got it!
+        }
+        //none found?
+        return 0;
+}
+
+bool MetaFileSystem::MapFilePath(const std::string &_inpath, std::string &outpath, MountPoint **system)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        std::string realpath;
+
+        // Special handling: host0:command.txt (as seen in Super Monkey Ball Adventures, for example)
+        // appears to mean the current directory on the UMD. Let's just assume the current directory.
+        std::string inpath = _inpath;
+        if (strncasecmp(inpath.c_str(), "host0:", strlen("host0:")) == 0) {
+                INFO_LOG(FILESYS, "Host0 path detected, stripping: %s", inpath.c_str());
+                inpath = inpath.substr(strlen("host0:"));
+        }
+
+        const std::string *currentDirectory = &startingDirectory;
+
+        _assert_msg_(FILESYS, false, "must implement equiv of __KernelGetCurThread");
+
+        int currentThread = 0;//__KernelGetCurThread();
+        currentDir_t::iterator it = currentDir.find(currentThread);
+        if (it == currentDir.end()) 
+        {
+                //Attempt to emulate SCE_KERNEL_ERROR_NOCWD / 8002032C: may break things requiring fixes elsewhere
+                if (inpath.find(':') == std::string::npos /* means path is relative */) 
+                {
+                        lastOpenError = -1;//SCE_KERNEL_ERROR_NOCWD;
+                        WARN_LOG(FILESYS, "Path is relative, but current directory not set for thread %i. returning 8002032C(SCE_KERNEL_ERROR_NOCWD) instead.", currentThread);
+                }
+        }
+        else
+        {
+                currentDirectory = &(it->second);
+        }
+
+        if ( RealPath(*currentDirectory, inpath, realpath) )
+        {
+                for (size_t i = 0; i < fileSystems.size(); i++)
+                {
+                        size_t prefLen = fileSystems[i].prefix.size();
+                        if (strncasecmp(fileSystems[i].prefix.c_str(), realpath.c_str(), prefLen) == 0)
+                        {
+                                outpath = realpath.substr(prefLen);
+                                *system = &(fileSystems[i]);
+
+                                INFO_LOG(FILESYS, "MapFilePath: mapped \"%s\" to prefix: \"%s\", path: \"%s\"", inpath.c_str(), fileSystems[i].prefix.c_str(), outpath.c_str());
+
+                                return true;
+                        }
+                }
+        }
+
+        DEBUG_LOG(FILESYS, "MapFilePath: failed mapping \"%s\", returning false", inpath.c_str());
+        return false;
+}
+
+void MetaFileSystem::Mount(std::string prefix, IFileSystem *system)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        MountPoint x;
+        x.prefix = prefix;
+        x.system = system;
+        fileSystems.push_back(x);
+}
+
+void MetaFileSystem::Unmount(std::string prefix, IFileSystem *system)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        MountPoint x;
+        x.prefix = prefix;
+        x.system = system;
+        fileSystems.erase(std::remove(fileSystems.begin(), fileSystems.end(), x), fileSystems.end());
+}
+
+void MetaFileSystem::Shutdown()
+{
+        std::lock_guard<std::mutex> guard(lock);
+        current = 6;
+
+        // Ownership is a bit convoluted. Let's just delete everything once.
+
+        std::set<IFileSystem *> toDelete;
+        for (size_t i = 0; i < fileSystems.size(); i++) {
+                toDelete.insert(fileSystems[i].system);
+        }
+
+        for (auto iter = toDelete.begin(); iter != toDelete.end(); ++iter)
+        {
+                delete *iter;
+        }
+
+        fileSystems.clear();
+        currentDir.clear();
+        startingDirectory = "";
+}
+
+u32 MetaFileSystem::OpenWithError(int &error, std::string filename, FileAccess access, const char *devicename)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        u32 h = OpenFile(filename, access, devicename);
+        error = lastOpenError;
+        return h;
+}
+
+u32 MetaFileSystem::OpenFile(std::string filename, FileAccess access, const char *devicename)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        lastOpenError = 0;
+        std::string of;
+        MountPoint *mount;
+        if (MapFilePath(filename, of, &mount))
+        {
+                return mount->system->OpenFile(of, access, mount->prefix.c_str());
+        }
+        else
+        {
+                return 0;
+        }
+}
+
+FileInfo MetaFileSystem::GetFileInfo(std::string filename)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        std::string of;
+        IFileSystem *system;
+        if (MapFilePath(filename, of, &system))
+        {
+                return system->GetFileInfo(of);
+        }
+        else
+        {
+                FileInfo bogus; // TODO
+                return bogus; 
+        }
+}
+
+bool MetaFileSystem::GetHostPath(const std::string &inpath, std::string &outpath)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        std::string of;
+        IFileSystem *system;
+        if (MapFilePath(inpath, of, &system)) {
+                return system->GetHostPath(of, outpath);
+        } else {
+                return false;
+        }
+}
+
+std::vector<FileInfo> MetaFileSystem::GetDirListing(std::string path)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        std::string of;
+        IFileSystem *system;
+        if (MapFilePath(path, of, &system))
+        {
+                return system->GetDirListing(of);
+        }
+        else
+        {
+                std::vector<FileInfo> empty;
+                return empty;
+        }
+}
+
+void MetaFileSystem::ThreadEnded(int threadID)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        currentDir.erase(threadID);
+}
+
+int MetaFileSystem::ChDir(const std::string &dir)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        // Retain the old path and fail if the arg is 1023 bytes or longer.
+        if (dir.size() >= 1023)
+                return -1;//SCE_KERNEL_ERROR_NAMETOOLONG;
+
+        _assert_msg_(FILESYS, false, "must implement equiv of __KernelGetCurThread");
+
+        int curThread = 0; //__KernelGetCurThread();
+        
+        std::string of;
+        MountPoint *mountPoint;
+        if (MapFilePath(dir, of, &mountPoint))
+        {
+                currentDir[curThread] = mountPoint->prefix + of;
+                return 0;
+        }
+        else
+        {
+                for (size_t i = 0; i < fileSystems.size(); i++)
+                {
+                        const std::string &prefix = fileSystems[i].prefix;
+                        if (strncasecmp(prefix.c_str(), dir.c_str(), prefix.size()) == 0)
+                        {
+                                // The PSP is completely happy with invalid current dirs as long as they have a valid device.
+                                WARN_LOG(FILESYS, "ChDir failed to map path \"%s\", saving as current directory anyway", dir.c_str());
+                                currentDir[curThread] = dir;
+                                return 0;
+                        }
+                }
+
+                WARN_LOG(FILESYS, "ChDir failed to map device for \"%s\", failing", dir.c_str());
+                return -1;//SCE_KERNEL_ERROR_NODEV;
+        }
+}
+
+bool MetaFileSystem::MkDir(const std::string &dirname)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        std::string of;
+        IFileSystem *system;
+        if (MapFilePath(dirname, of, &system))
+        {
+                return system->MkDir(of);
+        }
+        else
+        {
+                return false;
+        }
+}
+
+bool MetaFileSystem::RmDir(const std::string &dirname)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        std::string of;
+        IFileSystem *system;
+        if (MapFilePath(dirname, of, &system))
+        {
+                return system->RmDir(of);
+        }
+        else
+        {
+                return false;
+        }
+}
+
+int MetaFileSystem::RenameFile(const std::string &from, const std::string &to)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        std::string of;
+        std::string rf;
+        IFileSystem *osystem;
+        IFileSystem *rsystem = NULL;
+        if (MapFilePath(from, of, &osystem))
+        {
+                // If it's a relative path, it seems to always use from's filesystem.
+                if (to.find(":/") != to.npos)
+                {
+                        if (!MapFilePath(to, rf, &rsystem))
+                                return -1;
+                }
+                else
+                {
+                        rf = to;
+                        rsystem = osystem;
+                }
+
+                if (osystem != rsystem)
+                        return -1;//SCE_KERNEL_ERROR_XDEV;
+
+                return osystem->RenameFile(of, rf);
+        }
+        else
+        {
+                return -1;
+        }
+}
+
+bool MetaFileSystem::RemoveFile(const std::string &filename)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        std::string of;
+        IFileSystem *system;
+        if (MapFilePath(filename, of, &system))
+        {
+                return system->RemoveFile(of);
+        }
+        else
+        {
+                return false;
+        }
+}
+
+void MetaFileSystem::CloseFile(u32 handle)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        IFileSystem *sys = GetHandleOwner(handle);
+        if (sys)
+                sys->CloseFile(handle);
+}
+
+size_t MetaFileSystem::ReadFile(u32 handle, u8 *pointer, s64 size)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        IFileSystem *sys = GetHandleOwner(handle);
+        if (sys)
+                return sys->ReadFile(handle,pointer,size);
+        else
+                return 0;
+}
+
+size_t MetaFileSystem::WriteFile(u32 handle, const u8 *pointer, s64 size)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        IFileSystem *sys = GetHandleOwner(handle);
+        if (sys)
+                return sys->WriteFile(handle,pointer,size);
+        else
+                return 0;
+}
+
+size_t MetaFileSystem::SeekFile(u32 handle, s32 position, FileMove type)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        IFileSystem *sys = GetHandleOwner(handle);
+        if (sys)
+                return sys->SeekFile(handle,position,type);
+        else
+                return 0;
+}
+
+void MetaFileSystem::DoState(PointerWrap &p)
+{
+        std::lock_guard<std::mutex> guard(lock);
+        
+        auto s = p.Section("MetaFileSystem", 1);
+        if (!s)
+                return;
+
+        p.Do(current);
+
+        // Save/load per-thread current directory map
+        p.Do(currentDir);
+
+        u32 n = (u32) fileSystems.size();
+        p.Do(n);
+        if (n != (u32) fileSystems.size())
+        {
+                p.SetError(p.ERROR_FAILURE);
+                ERROR_LOG(FILESYS, "Savestate failure: number of filesystems doesn't match.");
+                return;
+        }
+
+        for (u32 i = 0; i < n; ++i)
+                fileSystems[i].system->DoState(p);
+}
+
diff --git a/src/core/file_sys/meta_file_system.h b/src/core/file_sys/meta_file_system.h
new file mode 100644
index 000000000..0de23d49c
--- /dev/null
+++ b/src/core/file_sys/meta_file_system.h
@@ -0,0 +1,109 @@
+// Copyright (c) 2012- PPSSPP Project.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, version 2.0 or later versions.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official git repository and contact information can be found at
+// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
+
+#pragma once
+
+#include "std_mutex.h"
+#include "file_sys.h"
+
+class MetaFileSystem : public IHandleAllocator, public IFileSystem
+{
+private:
+        u32 current;
+        struct MountPoint
+        {
+                std::string prefix;
+                IFileSystem *system;
+
+                bool operator == (const MountPoint &other) const
+                {
+                        return prefix == other.prefix && system == other.system;
+                }
+        };
+        std::vector<MountPoint> fileSystems;
+
+        typedef std::map<int, std::string> currentDir_t;
+        currentDir_t currentDir;
+
+        std::string startingDirectory;
+        int lastOpenError;
+        std::recursive_mutex lock;
+
+public:
+        MetaFileSystem()
+        {
+                current = 6;  // what?
+        }
+
+        void Mount(std::string prefix, IFileSystem *system);
+        void Unmount(std::string prefix, IFileSystem *system);
+
+        void ThreadEnded(int threadID);
+
+        void Shutdown();
+
+        u32 GetNewHandle() {return current++;}
+        void FreeHandle(u32 handle) {}
+
+        virtual void DoState(PointerWrap &p);
+
+        IFileSystem *GetHandleOwner(u32 handle);
+        bool MapFilePath(const std::string &inpath, std::string &outpath, MountPoint **system);
+
+        inline bool MapFilePath(const std::string &_inpath, std::string &outpath, IFileSystem **system)
+        {
+                MountPoint *mountPoint;
+                if (MapFilePath(_inpath, outpath, &mountPoint))
+                {
+                        *system = mountPoint->system;
+                        return true;
+                }
+
+                return false;
+        }
+
+        // Only possible if a file system is a DirectoryFileSystem or similar.
+        bool GetHostPath(const std::string &inpath, std::string &outpath);
+        
+        std::vector<FileInfo> GetDirListing(std::string path);
+        u32      OpenFile(std::string filename, FileAccess access, const char *devicename = NULL);
+        u32      OpenWithError(int &error, std::string filename, FileAccess access, const char *devicename = NULL);
+        void     CloseFile(u32 handle);
+        size_t   ReadFile(u32 handle, u8 *pointer, s64 size);
+        size_t   WriteFile(u32 handle, const u8 *pointer, s64 size);
+        size_t   SeekFile(u32 handle, s32 position, FileMove type);
+        FileInfo GetFileInfo(std::string filename);
+        bool     OwnsHandle(u32 handle) {return false;}
+        inline size_t GetSeekPos(u32 handle)
+        {
+                return SeekFile(handle, 0, FILEMOVE_CURRENT);
+        }
+
+        virtual int ChDir(const std::string &dir);
+
+        virtual bool MkDir(const std::string &dirname);
+        virtual bool RmDir(const std::string &dirname);
+        virtual int  RenameFile(const std::string &from, const std::string &to);
+        virtual bool RemoveFile(const std::string &filename);
+
+        // TODO: void IoCtl(...)
+
+        void SetStartingDirectory(const std::string &dir) {
+                std::lock_guard<std::mutex> guard(lock);
+                startingDirectory = dir;
+        }
+};