fabi/Xenia-Canary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Renaming xe::fs to xe::filesystem and xe::kernel::fs to xe::vfs.

Browse Source 
Progress on #294.
This commit is contained in:
Ben Vanik
2015-06-27 13:31:21 -07:00
parent bc75b0ab87
commit 0716cf84c0
45 changed files with 374 additions and 428 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
libxenia.vcxproj
View File

@@ -28,8 +28,8 @@
<ClCompile Include="src\xenia\base\arena.cc" /> <ClCompile Include="src\xenia\base\arena.cc" />
<ClCompile Include="src\xenia\base\clock.cc" /> <ClCompile Include="src\xenia\base\clock.cc" />
<ClCompile Include="src\xenia\base\debugging_win.cc" /> <ClCompile Include="src\xenia\base\debugging_win.cc" />
<ClCompile Include="src\xenia\base\fs.cc" /> <ClCompile Include="src\xenia\base\filesystem.cc" />
<ClCompile Include="src\xenia\base\fs_win.cc" /> <ClCompile Include="src\xenia\base\filesystem_win.cc" />
<ClCompile Include="src\xenia\base\logging.cc" /> <ClCompile Include="src\xenia\base\logging.cc" />
<ClCompile Include="src\xenia\base\mapped_memory_win.cc" /> <ClCompile Include="src\xenia\base\mapped_memory_win.cc" />
<ClCompile Include="src\xenia\base\math.cc" /> <ClCompile Include="src\xenia\base\math.cc" />
@@ -135,20 +135,6 @@
<ClCompile Include="src\xenia\kernel\async_request.cc" /> <ClCompile Include="src\xenia\kernel\async_request.cc" />
<ClCompile Include="src\xenia\kernel\content_manager.cc" /> <ClCompile Include="src\xenia\kernel\content_manager.cc" />
<ClCompile Include="src\xenia\kernel\dispatcher.cc" /> <ClCompile Include="src\xenia\kernel\dispatcher.cc" />
<ClCompile Include="src\xenia\kernel\fs\device.cc" />
<ClCompile Include="src\xenia\kernel\fs\devices\disc_image_device.cc" />
<ClCompile Include="src\xenia\kernel\fs\devices\disc_image_entry.cc" />
<ClCompile Include="src\xenia\kernel\fs\devices\disc_image_file.cc" />
<ClCompile Include="src\xenia\kernel\fs\devices\host_path_device.cc" />
<ClCompile Include="src\xenia\kernel\fs\devices\host_path_entry.cc" />
<ClCompile Include="src\xenia\kernel\fs\devices\host_path_file.cc" />
<ClCompile Include="src\xenia\kernel\fs\devices\stfs_container_device.cc" />
<ClCompile Include="src\xenia\kernel\fs\devices\stfs_container_entry.cc" />
<ClCompile Include="src\xenia\kernel\fs\devices\stfs_container_file.cc" />
<ClCompile Include="src\xenia\kernel\fs\entry.cc" />
<ClCompile Include="src\xenia\kernel\fs\filesystem.cc" />
<ClCompile Include="src\xenia\kernel\fs\gdfx.cc" />
<ClCompile Include="src\xenia\kernel\fs\stfs.cc" />
<ClCompile Include="src\xenia\kernel\kernel_state.cc" /> <ClCompile Include="src\xenia\kernel\kernel_state.cc" />
<ClCompile Include="src\xenia\kernel\native_list.cc" /> <ClCompile Include="src\xenia\kernel\native_list.cc" />
<ClCompile Include="src\xenia\kernel\objects\xenumerator.cc" /> <ClCompile Include="src\xenia\kernel\objects\xenumerator.cc" />
@@ -207,6 +193,20 @@
<ClCompile Include="src\xenia\ui\win32\win32_loop.cc" /> <ClCompile Include="src\xenia\ui\win32\win32_loop.cc" />
<ClCompile Include="src\xenia\ui\win32\win32_menu_item.cc" /> <ClCompile Include="src\xenia\ui\win32\win32_menu_item.cc" />
<ClCompile Include="src\xenia\ui\win32\win32_window.cc" /> <ClCompile Include="src\xenia\ui\win32\win32_window.cc" />
<ClCompile Include="src\xenia\vfs\device.cc" />
<ClCompile Include="src\xenia\vfs\devices\disc_image_device.cc" />
<ClCompile Include="src\xenia\vfs\devices\disc_image_entry.cc" />
<ClCompile Include="src\xenia\vfs\devices\disc_image_file.cc" />
<ClCompile Include="src\xenia\vfs\devices\host_path_device.cc" />
<ClCompile Include="src\xenia\vfs\devices\host_path_entry.cc" />
<ClCompile Include="src\xenia\vfs\devices\host_path_file.cc" />
<ClCompile Include="src\xenia\vfs\devices\stfs_container_device.cc" />
<ClCompile Include="src\xenia\vfs\devices\stfs_container_entry.cc" />
<ClCompile Include="src\xenia\vfs\devices\stfs_container_file.cc" />
<ClCompile Include="src\xenia\vfs\entry.cc" />
<ClCompile Include="src\xenia\vfs\virtual_file_system.cc" />
<ClCompile Include="src\xenia\vfs\gdfx.cc" />
<ClCompile Include="src\xenia\vfs\stfs.cc" />
<ClCompile Include="third_party\beaengine\beaengineSources\BeaEngine.c" /> <ClCompile Include="third_party\beaengine\beaengineSources\BeaEngine.c" />
<ClCompile Include="third_party\capstone\arch\X86\X86Disassembler.c"> <ClCompile Include="third_party\capstone\arch\X86\X86Disassembler.c">
<CompileAs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">CompileAsCpp</CompileAs> <CompileAs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">CompileAsCpp</CompileAs>
@@ -284,7 +284,7 @@
<ClInclude Include="src\xenia\base\clock.h" /> <ClInclude Include="src\xenia\base\clock.h" />
<ClInclude Include="src\xenia\base\debugging.h" /> <ClInclude Include="src\xenia\base\debugging.h" />
<ClInclude Include="src\xenia\base\delegate.h" /> <ClInclude Include="src\xenia\base\delegate.h" />
<ClInclude Include="src\xenia\base\fs.h" /> <ClInclude Include="src\xenia\base\filesystem.h" />
<ClInclude Include="src\xenia\base\logging.h" /> <ClInclude Include="src\xenia\base\logging.h" />
<ClInclude Include="src\xenia\base\mapped_memory.h" /> <ClInclude Include="src\xenia\base\mapped_memory.h" />
<ClInclude Include="src\xenia\base\math.h" /> <ClInclude Include="src\xenia\base\math.h" />
@@ -406,20 +406,6 @@
<ClInclude Include="src\xenia\kernel\async_request.h" /> <ClInclude Include="src\xenia\kernel\async_request.h" />
<ClInclude Include="src\xenia\kernel\content_manager.h" /> <ClInclude Include="src\xenia\kernel\content_manager.h" />
<ClInclude Include="src\xenia\kernel\dispatcher.h" /> <ClInclude Include="src\xenia\kernel\dispatcher.h" />
<ClInclude Include="src\xenia\kernel\fs\device.h" />
<ClInclude Include="src\xenia\kernel\fs\devices\disc_image_device.h" />
<ClInclude Include="src\xenia\kernel\fs\devices\disc_image_entry.h" />
<ClInclude Include="src\xenia\kernel\fs\devices\disc_image_file.h" />
<ClInclude Include="src\xenia\kernel\fs\devices\host_path_device.h" />
<ClInclude Include="src\xenia\kernel\fs\devices\host_path_entry.h" />
<ClInclude Include="src\xenia\kernel\fs\devices\host_path_file.h" />
<ClInclude Include="src\xenia\kernel\fs\devices\stfs_container_device.h" />
<ClInclude Include="src\xenia\kernel\fs\devices\stfs_container_entry.h" />
<ClInclude Include="src\xenia\kernel\fs\devices\stfs_container_file.h" />
<ClInclude Include="src\xenia\kernel\fs\entry.h" />
<ClInclude Include="src\xenia\kernel\fs\filesystem.h" />
<ClInclude Include="src\xenia\kernel\fs\gdfx.h" />
<ClInclude Include="src\xenia\kernel\fs\stfs.h" />
<ClInclude Include="src\xenia\kernel\kernel.h" /> <ClInclude Include="src\xenia\kernel\kernel.h" />
<ClInclude Include="src\xenia\kernel\kernel_state.h" /> <ClInclude Include="src\xenia\kernel\kernel_state.h" />
<ClInclude Include="src\xenia\kernel\modules.h" /> <ClInclude Include="src\xenia\kernel\modules.h" />
@@ -462,6 +448,20 @@
<ClInclude Include="src\xenia\ui\win32\win32_menu_item.h" /> <ClInclude Include="src\xenia\ui\win32\win32_menu_item.h" />
<ClInclude Include="src\xenia\ui\win32\win32_window.h" /> <ClInclude Include="src\xenia\ui\win32\win32_window.h" />
<ClInclude Include="src\xenia\ui\window.h" /> <ClInclude Include="src\xenia\ui\window.h" />
<ClInclude Include="src\xenia\vfs\device.h" />
<ClInclude Include="src\xenia\vfs\devices\disc_image_device.h" />
<ClInclude Include="src\xenia\vfs\devices\disc_image_entry.h" />
<ClInclude Include="src\xenia\vfs\devices\disc_image_file.h" />
<ClInclude Include="src\xenia\vfs\devices\host_path_device.h" />
<ClInclude Include="src\xenia\vfs\devices\host_path_entry.h" />
<ClInclude Include="src\xenia\vfs\devices\host_path_file.h" />
<ClInclude Include="src\xenia\vfs\devices\stfs_container_device.h" />
<ClInclude Include="src\xenia\vfs\devices\stfs_container_entry.h" />
<ClInclude Include="src\xenia\vfs\devices\stfs_container_file.h" />
<ClInclude Include="src\xenia\vfs\entry.h" />
<ClInclude Include="src\xenia\vfs\virtual_file_system.h" />
<ClInclude Include="src\xenia\vfs\gdfx.h" />
<ClInclude Include="src\xenia\vfs\stfs.h" />
<ClInclude Include="src\xenia\xbox.h" /> <ClInclude Include="src\xenia\xbox.h" />
<ClInclude Include="third_party\beaengine\include\beaengine\basic_types.h" /> <ClInclude Include="third_party\beaengine\include\beaengine\basic_types.h" />
<ClInclude Include="third_party\beaengine\include\beaengine\BeaEngine.h" /> <ClInclude Include="third_party\beaengine\include\beaengine\BeaEngine.h" />

198
libxenia.vcxproj.filters
View File

@@ -80,18 +80,12 @@
<Filter Include="src\xenia\kernel\apps"> <Filter Include="src\xenia\kernel\apps">
<UniqueIdentifier>{4e0349c4-b0bd-4595-9e83-cb3cbe11a172}</UniqueIdentifier> <UniqueIdentifier>{4e0349c4-b0bd-4595-9e83-cb3cbe11a172}</UniqueIdentifier>
</Filter> </Filter>
<Filter Include="src\xenia\kernel\fs">
<UniqueIdentifier>{65927db3-9314-4d02-a392-702b09fca341}</UniqueIdentifier>
</Filter>
<Filter Include="src\xenia\kernel\objects"> <Filter Include="src\xenia\kernel\objects">
<UniqueIdentifier>{bb86c40a-ad91-482e-a7c8-ef0a84280c8d}</UniqueIdentifier> <UniqueIdentifier>{bb86c40a-ad91-482e-a7c8-ef0a84280c8d}</UniqueIdentifier>
</Filter> </Filter>
<Filter Include="src\xenia\kernel\util"> <Filter Include="src\xenia\kernel\util">
<UniqueIdentifier>{447ef539-2dab-4969-a5b0-57c8d6f4c6ec}</UniqueIdentifier> <UniqueIdentifier>{447ef539-2dab-4969-a5b0-57c8d6f4c6ec}</UniqueIdentifier>
</Filter> </Filter>
<Filter Include="src\xenia\kernel\fs\devices">
<UniqueIdentifier>{cceab7bd-2f0a-4a27-a297-2f89170b8f6b}</UniqueIdentifier>
</Filter>
<Filter Include="third_party"> <Filter Include="third_party">
<UniqueIdentifier>{9194a1f4-9934-465e-adcb-3ac0e337dfe3}</UniqueIdentifier> <UniqueIdentifier>{9194a1f4-9934-465e-adcb-3ac0e337dfe3}</UniqueIdentifier>
</Filter> </Filter>
@@ -161,6 +155,12 @@
<Filter Include="third_party\capstone\arch\X86"> <Filter Include="third_party\capstone\arch\X86">
<UniqueIdentifier>{00596876-a323-4570-a5fb-71343024d429}</UniqueIdentifier> <UniqueIdentifier>{00596876-a323-4570-a5fb-71343024d429}</UniqueIdentifier>
</Filter> </Filter>
<Filter Include="src\xenia\vfs">
<UniqueIdentifier>{831bb630-c71e-43c7-abf0-bde923d10e9b}</UniqueIdentifier>
</Filter>
<Filter Include="src\xenia\vfs\devices">
<UniqueIdentifier>{82795389-e855-4cd6-a3b6-9580030cebf2}</UniqueIdentifier>
</Filter>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClCompile Include="src\xenia\emulator.cc"> <ClCompile Include="src\xenia\emulator.cc">
@@ -193,12 +193,6 @@
<ClCompile Include="src\xenia\base\debugging_win.cc"> <ClCompile Include="src\xenia\base\debugging_win.cc">
<Filter>src\xenia\base</Filter> <Filter>src\xenia\base</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="src\xenia\base\fs.cc">
<Filter>src\xenia\base</Filter>
</ClCompile>
<ClCompile Include="src\xenia\base\fs_win.cc">
<Filter>src\xenia\base</Filter>
</ClCompile>
<ClCompile Include="src\xenia\base\logging.cc"> <ClCompile Include="src\xenia\base\logging.cc">
<Filter>src\xenia\base</Filter> <Filter>src\xenia\base</Filter>
</ClCompile> </ClCompile>
@@ -529,48 +523,6 @@
<ClCompile Include="src\xenia\kernel\apps\xmp_app.cc"> <ClCompile Include="src\xenia\kernel\apps\xmp_app.cc">
<Filter>src\xenia\kernel\apps</Filter> <Filter>src\xenia\kernel\apps</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="src\xenia\kernel\fs\device.cc">
<Filter>src\xenia\kernel\fs</Filter>
</ClCompile>
<ClCompile Include="src\xenia\kernel\fs\entry.cc">
<Filter>src\xenia\kernel\fs</Filter>
</ClCompile>
<ClCompile Include="src\xenia\kernel\fs\filesystem.cc">
<Filter>src\xenia\kernel\fs</Filter>
</ClCompile>
<ClCompile Include="src\xenia\kernel\fs\gdfx.cc">
<Filter>src\xenia\kernel\fs</Filter>
</ClCompile>
<ClCompile Include="src\xenia\kernel\fs\stfs.cc">
<Filter>src\xenia\kernel\fs</Filter>
</ClCompile>
<ClCompile Include="src\xenia\kernel\fs\devices\disc_image_device.cc">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\kernel\fs\devices\disc_image_entry.cc">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\kernel\fs\devices\disc_image_file.cc">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\kernel\fs\devices\host_path_device.cc">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\kernel\fs\devices\host_path_entry.cc">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\kernel\fs\devices\host_path_file.cc">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\kernel\fs\devices\stfs_container_device.cc">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\kernel\fs\devices\stfs_container_entry.cc">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\kernel\fs\devices\stfs_container_file.cc">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\kernel\app.cc"> <ClCompile Include="src\xenia\kernel\app.cc">
<Filter>src\xenia\kernel</Filter> <Filter>src\xenia\kernel</Filter>
</ClCompile> </ClCompile>
@@ -781,6 +733,54 @@
<ClCompile Include="src\xenia\apu\nop\nop_apu_flags.cc"> <ClCompile Include="src\xenia\apu\nop\nop_apu_flags.cc">
<Filter>src\xenia\apu\nop</Filter> <Filter>src\xenia\apu\nop</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="src\xenia\base\filesystem.cc">
<Filter>src\xenia\base</Filter>
</ClCompile>
<ClCompile Include="src\xenia\base\filesystem_win.cc">
<Filter>src\xenia\base</Filter>
</ClCompile>
<ClCompile Include="src\xenia\vfs\device.cc">
<Filter>src\xenia\vfs</Filter>
</ClCompile>
<ClCompile Include="src\xenia\vfs\entry.cc">
<Filter>src\xenia\vfs</Filter>
</ClCompile>
<ClCompile Include="src\xenia\vfs\gdfx.cc">
<Filter>src\xenia\vfs</Filter>
</ClCompile>
<ClCompile Include="src\xenia\vfs\stfs.cc">
<Filter>src\xenia\vfs</Filter>
</ClCompile>
<ClCompile Include="src\xenia\vfs\devices\disc_image_device.cc">
<Filter>src\xenia\vfs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\vfs\devices\disc_image_entry.cc">
<Filter>src\xenia\vfs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\vfs\devices\disc_image_file.cc">
<Filter>src\xenia\vfs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\vfs\devices\host_path_device.cc">
<Filter>src\xenia\vfs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\vfs\devices\host_path_entry.cc">
<Filter>src\xenia\vfs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\vfs\devices\host_path_file.cc">
<Filter>src\xenia\vfs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\vfs\devices\stfs_container_device.cc">
<Filter>src\xenia\vfs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\vfs\devices\stfs_container_entry.cc">
<Filter>src\xenia\vfs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\vfs\devices\stfs_container_file.cc">
<Filter>src\xenia\vfs\devices</Filter>
</ClCompile>
<ClCompile Include="src\xenia\vfs\virtual_file_system.cc">
<Filter>src\xenia\vfs</Filter>
</ClCompile>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="src\xenia\emulator.h"> <ClInclude Include="src\xenia\emulator.h">
@@ -828,9 +828,6 @@
<ClInclude Include="src\xenia\base\delegate.h"> <ClInclude Include="src\xenia\base\delegate.h">
<Filter>src\xenia\base</Filter> <Filter>src\xenia\base</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="src\xenia\base\fs.h">
<Filter>src\xenia\base</Filter>
</ClInclude>
<ClInclude Include="src\xenia\base\logging.h"> <ClInclude Include="src\xenia\base\logging.h">
<Filter>src\xenia\base</Filter> <Filter>src\xenia\base</Filter>
</ClInclude> </ClInclude>
@@ -1206,48 +1203,6 @@
<ClInclude Include="src\xenia\kernel\apps\xmp_app.h"> <ClInclude Include="src\xenia\kernel\apps\xmp_app.h">
<Filter>src\xenia\kernel\apps</Filter> <Filter>src\xenia\kernel\apps</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="src\xenia\kernel\fs\device.h">
<Filter>src\xenia\kernel\fs</Filter>
</ClInclude>
<ClInclude Include="src\xenia\kernel\fs\entry.h">
<Filter>src\xenia\kernel\fs</Filter>
</ClInclude>
<ClInclude Include="src\xenia\kernel\fs\filesystem.h">
<Filter>src\xenia\kernel\fs</Filter>
</ClInclude>
<ClInclude Include="src\xenia\kernel\fs\gdfx.h">
<Filter>src\xenia\kernel\fs</Filter>
</ClInclude>
<ClInclude Include="src\xenia\kernel\fs\stfs.h">
<Filter>src\xenia\kernel\fs</Filter>
</ClInclude>
<ClInclude Include="src\xenia\kernel\fs\devices\disc_image_device.h">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\kernel\fs\devices\disc_image_entry.h">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\kernel\fs\devices\disc_image_file.h">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\kernel\fs\devices\host_path_device.h">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\kernel\fs\devices\host_path_entry.h">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\kernel\fs\devices\host_path_file.h">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\kernel\fs\devices\stfs_container_device.h">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\kernel\fs\devices\stfs_container_entry.h">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\kernel\fs\devices\stfs_container_file.h">
<Filter>src\xenia\kernel\fs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\kernel\app.h"> <ClInclude Include="src\xenia\kernel\app.h">
<Filter>src\xenia\kernel</Filter> <Filter>src\xenia\kernel</Filter>
</ClInclude> </ClInclude>
@@ -1488,6 +1443,51 @@
<ClInclude Include="src\xenia\hid\input.h"> <ClInclude Include="src\xenia\hid\input.h">
<Filter>src\xenia\hid</Filter> <Filter>src\xenia\hid</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="src\xenia\base\filesystem.h">
<Filter>src\xenia\base</Filter>
</ClInclude>
<ClInclude Include="src\xenia\vfs\device.h">
<Filter>src\xenia\vfs</Filter>
</ClInclude>
<ClInclude Include="src\xenia\vfs\entry.h">
<Filter>src\xenia\vfs</Filter>
</ClInclude>
<ClInclude Include="src\xenia\vfs\gdfx.h">
<Filter>src\xenia\vfs</Filter>
</ClInclude>
<ClInclude Include="src\xenia\vfs\stfs.h">
<Filter>src\xenia\vfs</Filter>
</ClInclude>
<ClInclude Include="src\xenia\vfs\devices\disc_image_device.h">
<Filter>src\xenia\vfs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\vfs\devices\disc_image_entry.h">
<Filter>src\xenia\vfs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\vfs\devices\disc_image_file.h">
<Filter>src\xenia\vfs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\vfs\devices\host_path_device.h">
<Filter>src\xenia\vfs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\vfs\devices\host_path_entry.h">
<Filter>src\xenia\vfs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\vfs\devices\host_path_file.h">
<Filter>src\xenia\vfs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\vfs\devices\stfs_container_device.h">
<Filter>src\xenia\vfs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\vfs\devices\stfs_container_entry.h">
<Filter>src\xenia\vfs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\vfs\devices\stfs_container_file.h">
<Filter>src\xenia\vfs\devices</Filter>
</ClInclude>
<ClInclude Include="src\xenia\vfs\virtual_file_system.h">
<Filter>src\xenia\vfs</Filter>
</ClInclude>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<None Include="src\xenia\cpu\backend\x64\x64_sequence.inl"> <None Include="src\xenia\cpu\backend\x64\x64_sequence.inl">

8
src/xenia/base/fs.cc → src/xenia/base/filesystem.cc
View File

@@ -7,14 +7,12 @@
****************************************************************************** ******************************************************************************
*/ */
#include "xenia/base/fs.h" #include "xenia/base/filesystem.h"
#include <string>
#include <vector>
#include <algorithm> #include <algorithm>
namespace xe { namespace xe {
namespace fs { namespace filesystem {
std::string CanonicalizePath(const std::string& original_path) { std::string CanonicalizePath(const std::string& original_path) {
char path_sep('\\'); char path_sep('\\');
@@ -178,5 +176,5 @@ bool WildcardEngine::Match(const std::string& str) const {
return true; return true;
} }
} // namespace fs } // namespace filesystem
} // namespace xe } // namespace xe

15
src/xenia/base/fs.h → src/xenia/base/filesystem.h
View File

@@ -7,18 +7,17 @@
****************************************************************************** ******************************************************************************
*/ */
#ifndef XENIA_BASE_FS_H_ #ifndef XENIA_BASE_FILESYSTEM_H_
#define XENIA_BASE_FS_H_ #define XENIA_BASE_FILESYSTEM_H_
#include <iterator>
#include <string> #include <string>
#include <vector>
#include "xenia/base/string.h" #include "xenia/base/string.h"
#include <vector>
#include <iterator>
namespace xe { namespace xe {
namespace fs { namespace filesystem {
bool PathExists(const std::wstring& path); bool PathExists(const std::wstring& path);
@@ -73,7 +72,7 @@ class WildcardEngine {
void PreparePattern(const std::string& pattern); void PreparePattern(const std::string& pattern);
}; };
} // namespace fs } // namespace filesystem
} // namespace xe } // namespace xe
#endif // XENIA_BASE_FS_H_ #endif // XENIA_BASE_FILESYSTEM_H_

6
src/xenia/base/fs_win.cc → src/xenia/base/filesystem_win.cc
View File

@@ -7,7 +7,7 @@
****************************************************************************** ******************************************************************************
*/ */
#include "xenia/base/fs.h" #include "xenia/base/filesystem.h"
#include <shellapi.h> #include <shellapi.h>
@@ -16,7 +16,7 @@
#include "xenia/base/platform.h" #include "xenia/base/platform.h"
namespace xe { namespace xe {
namespace fs { namespace filesystem {
bool PathExists(const std::wstring& path) { bool PathExists(const std::wstring& path) {
DWORD attrib = GetFileAttributes(path.c_str()); DWORD attrib = GetFileAttributes(path.c_str());
@@ -73,5 +73,5 @@ std::vector<FileInfo> ListFiles(const std::wstring& path) {
return result; return result;
} }
} // namespace fs } // namespace filesystem
} // namespace xe } // namespace xe

4
src/xenia/debug/debugger.cc
View File

@@ -16,7 +16,7 @@
#include <mutex> #include <mutex>
#include "xenia/base/fs.h" #include "xenia/base/filesystem.h"
#include "xenia/base/logging.h" #include "xenia/base/logging.h"
#include "xenia/base/string.h" #include "xenia/base/string.h"
#include "xenia/base/threading.h" #include "xenia/base/threading.h"
@@ -73,7 +73,7 @@ bool Debugger::StartSession() {
auto session_path = xe::to_wstring(FLAGS_debug_session_path); auto session_path = xe::to_wstring(FLAGS_debug_session_path);
if (!session_path.empty()) { if (!session_path.empty()) {
session_path = xe::to_absolute_path(session_path); session_path = xe::to_absolute_path(session_path);
xe::fs::CreateFolder(session_path); xe::filesystem::CreateFolder(session_path);
} }
functions_path_ = xe::join_paths(session_path, L"functions"); functions_path_ = xe::join_paths(session_path, L"functions");

6
src/xenia/emulator.cc
View File

@@ -21,9 +21,9 @@
#include "xenia/kernel/kernel.h" #include "xenia/kernel/kernel.h"
#include "xenia/kernel/kernel_state.h" #include "xenia/kernel/kernel_state.h"
#include "xenia/kernel/modules.h" #include "xenia/kernel/modules.h"
#include "xenia/kernel/fs/filesystem.h"
#include "xenia/memory.h" #include "xenia/memory.h"
#include "xenia/ui/main_window.h" #include "xenia/ui/main_window.h"
#include "xenia/vfs/virtual_file_system.h"
DEFINE_double(time_scalar, 1.0, DEFINE_double(time_scalar, 1.0,
"Scalar used to speed or slow time (1x, 2x, 1/2x, etc)."); "Scalar used to speed or slow time (1x, 2x, 1/2x, etc).");
@@ -34,8 +34,8 @@ using namespace xe::apu;
using namespace xe::cpu; using namespace xe::cpu;
using namespace xe::gpu; using namespace xe::gpu;
using namespace xe::hid; using namespace xe::hid;
using namespace xe::kernel::fs;
using namespace xe::ui; using namespace xe::ui;
using namespace xe::vfs;
Emulator::Emulator(const std::wstring& command_line) Emulator::Emulator(const std::wstring& command_line)
: command_line_(command_line) {} : command_line_(command_line) {}
@@ -139,7 +139,7 @@ X_STATUS Emulator::Setup() {
} }
// Bring up the virtual filesystem used by the kernel. // Bring up the virtual filesystem used by the kernel.
file_system_ = std::make_unique<FileSystem>(); file_system_ = std::make_unique<VirtualFileSystem>();
// Shared kernel state. // Shared kernel state.
kernel_state_ = std::make_unique<kernel::KernelState>(this); kernel_state_ = std::make_unique<kernel::KernelState>(this);

5
src/xenia/emulator.h
View File

@@ -16,6 +16,7 @@
#include "xenia/kernel/kernel_state.h" #include "xenia/kernel/kernel_state.h"
#include "xenia/memory.h" #include "xenia/memory.h"
#include "xenia/ui/main_window.h" #include "xenia/ui/main_window.h"
#include "xenia/vfs/virtual_file_system.h"
#include "xenia/xbox.h" #include "xenia/xbox.h"
namespace xe { namespace xe {
@@ -65,7 +66,7 @@ class Emulator {
cpu::ExportResolver* export_resolver() const { cpu::ExportResolver* export_resolver() const {
return export_resolver_.get(); return export_resolver_.get();
} }
kernel::fs::FileSystem* file_system() const { return file_system_.get(); } vfs::VirtualFileSystem* file_system() const { return file_system_.get(); }
kernel::KernelState* kernel_state() const { return kernel_state_.get(); } kernel::KernelState* kernel_state() const { return kernel_state_.get(); }
@@ -95,7 +96,7 @@ class Emulator {
std::unique_ptr<hid::InputSystem> input_system_; std::unique_ptr<hid::InputSystem> input_system_;
std::unique_ptr<cpu::ExportResolver> export_resolver_; std::unique_ptr<cpu::ExportResolver> export_resolver_;
std::unique_ptr<kernel::fs::FileSystem> file_system_; std::unique_ptr<vfs::VirtualFileSystem> file_system_;
std::unique_ptr<kernel::KernelState> kernel_state_; std::unique_ptr<kernel::KernelState> kernel_state_;
}; };

4
src/xenia/gpu/gl4/gl4_shader.cc
View File

@@ -9,7 +9,7 @@
#include "xenia/gpu/gl4/gl4_shader.h" #include "xenia/gpu/gl4/gl4_shader.h"
#include "xenia/base/fs.h" #include "xenia/base/filesystem.h"
#include "xenia/base/logging.h" #include "xenia/base/logging.h"
#include "xenia/base/math.h" #include "xenia/base/math.h"
#include "xenia/gpu/gl4/gl4_gpu_flags.h" #include "xenia/gpu/gl4/gl4_gpu_flags.h"
@@ -363,7 +363,7 @@ bool GL4Shader::CompileProgram(std::string source) {
auto dump_shaders_path = xe::to_wstring(FLAGS_dump_shaders); auto dump_shaders_path = xe::to_wstring(FLAGS_dump_shaders);
if (!dump_shaders_path.empty()) { if (!dump_shaders_path.empty()) {
dump_shaders_path = xe::to_absolute_path(dump_shaders_path); dump_shaders_path = xe::to_absolute_path(dump_shaders_path);
xe::fs::CreateFolder(dump_shaders_path); xe::filesystem::CreateFolder(dump_shaders_path);
} }
// Note that we put the translated source first so we get good line numbers. // Note that we put the translated source first so we get good line numbers.

4
src/xenia/gpu/tracing.cc
View File

@@ -9,7 +9,7 @@
#include "xenia/gpu/tracing.h" #include "xenia/gpu/tracing.h"
#include "xenia/base/fs.h" #include "xenia/base/filesystem.h"
#include "xenia/base/string.h" #include "xenia/base/string.h"
namespace xe { namespace xe {
@@ -25,7 +25,7 @@ bool TraceWriter::Open(const std::wstring& path) {
auto canonical_path = xe::to_absolute_path(path); auto canonical_path = xe::to_absolute_path(path);
auto base_path = xe::find_base_path(canonical_path); auto base_path = xe::find_base_path(canonical_path);
xe::fs::CreateFolder(base_path); xe::filesystem::CreateFolder(base_path);
file_ = _wfopen(canonical_path.c_str(), L"wb"); file_ = _wfopen(canonical_path.c_str(), L"wb");
return file_ != nullptr; return file_ != nullptr;

26
src/xenia/kernel/content_manager.cc
View File

@@ -11,7 +11,7 @@
#include <string> #include <string>
#include "xenia/base/fs.h" #include "xenia/base/filesystem.h"
#include "xenia/kernel/kernel_state.h" #include "xenia/kernel/kernel_state.h"
#include "xenia/kernel/xobject.h" #include "xenia/kernel/xobject.h"
@@ -96,9 +96,9 @@ std::vector<XCONTENT_DATA> ContentManager::ListContent(uint32_t device_id,
// Search path: // Search path:
// content_root/title_id/type_name/* // content_root/title_id/type_name/*
auto package_root = ResolvePackageRoot(content_type); auto package_root = ResolvePackageRoot(content_type);
auto file_infos = xe::fs::ListFiles(package_root); auto file_infos = xe::filesystem::ListFiles(package_root);
for (const auto& file_info : file_infos) { for (const auto& file_info : file_infos) {
if (file_info.type != xe::fs::FileInfo::Type::kDirectory) { if (file_info.type != xe::filesystem::FileInfo::Type::kDirectory) {
// Directories only. // Directories only.
continue; continue;
} }
@@ -116,7 +116,7 @@ std::vector<XCONTENT_DATA> ContentManager::ListContent(uint32_t device_id,
std::unique_ptr<ContentPackage> ContentManager::ResolvePackage( std::unique_ptr<ContentPackage> ContentManager::ResolvePackage(
std::string root_name, const XCONTENT_DATA& data) { std::string root_name, const XCONTENT_DATA& data) {
auto package_path = ResolvePackagePath(data); auto package_path = ResolvePackagePath(data);
if (!xe::fs::PathExists(package_path)) { if (!xe::filesystem::PathExists(package_path)) {
return nullptr; return nullptr;
} }
@@ -129,7 +129,7 @@ std::unique_ptr<ContentPackage> ContentManager::ResolvePackage(
bool ContentManager::ContentExists(const XCONTENT_DATA& data) { bool ContentManager::ContentExists(const XCONTENT_DATA& data) {
auto path = ResolvePackagePath(data); auto path = ResolvePackagePath(data);
return xe::fs::PathExists(path); return xe::filesystem::PathExists(path);
} }
X_RESULT ContentManager::CreateContent(std::string root_name, X_RESULT ContentManager::CreateContent(std::string root_name,
@@ -142,12 +142,12 @@ X_RESULT ContentManager::CreateContent(std::string root_name,
} }
auto package_path = ResolvePackagePath(data); auto package_path = ResolvePackagePath(data);
if (xe::fs::PathExists(package_path)) { if (xe::filesystem::PathExists(package_path)) {
// Exists, must not! // Exists, must not!
return X_ERROR_ALREADY_EXISTS; return X_ERROR_ALREADY_EXISTS;
} }
if (!xe::fs::CreateFolder(package_path)) { if (!xe::filesystem::CreateFolder(package_path)) {
return X_ERROR_ACCESS_DENIED; return X_ERROR_ACCESS_DENIED;
} }
@@ -169,7 +169,7 @@ X_RESULT ContentManager::OpenContent(std::string root_name,
} }
auto package_path = ResolvePackagePath(data); auto package_path = ResolvePackagePath(data);
if (!xe::fs::PathExists(package_path)) { if (!xe::filesystem::PathExists(package_path)) {
// Does not exist, must be created. // Does not exist, must be created.
return X_ERROR_FILE_NOT_FOUND; return X_ERROR_FILE_NOT_FOUND;
} }
@@ -203,7 +203,7 @@ X_RESULT ContentManager::GetContentThumbnail(const XCONTENT_DATA& data,
std::lock_guard<xe::recursive_mutex> lock(content_mutex_); std::lock_guard<xe::recursive_mutex> lock(content_mutex_);
auto package_path = ResolvePackagePath(data); auto package_path = ResolvePackagePath(data);
auto thumb_path = xe::join_paths(package_path, kThumbnailFileName); auto thumb_path = xe::join_paths(package_path, kThumbnailFileName);
if (xe::fs::PathExists(thumb_path)) { if (xe::filesystem::PathExists(thumb_path)) {
auto file = _wfopen(thumb_path.c_str(), L"rb"); auto file = _wfopen(thumb_path.c_str(), L"rb");
fseek(file, 0, SEEK_END); fseek(file, 0, SEEK_END);
size_t file_len = ftell(file); size_t file_len = ftell(file);
@@ -221,8 +221,8 @@ X_RESULT ContentManager::SetContentThumbnail(const XCONTENT_DATA& data,
std::vector<uint8_t> buffer) { std::vector<uint8_t> buffer) {
std::lock_guard<xe::recursive_mutex> lock(content_mutex_); std::lock_guard<xe::recursive_mutex> lock(content_mutex_);
auto package_path = ResolvePackagePath(data); auto package_path = ResolvePackagePath(data);
xe::fs::CreateFolder(package_path); xe::filesystem::CreateFolder(package_path);
if (xe::fs::PathExists(package_path)) { if (xe::filesystem::PathExists(package_path)) {
auto thumb_path = xe::join_paths(package_path, kThumbnailFileName); auto thumb_path = xe::join_paths(package_path, kThumbnailFileName);
auto file = _wfopen(thumb_path.c_str(), L"wb"); auto file = _wfopen(thumb_path.c_str(), L"wb");
fwrite(buffer.data(), 1, buffer.size(), file); fwrite(buffer.data(), 1, buffer.size(), file);
@@ -237,8 +237,8 @@ X_RESULT ContentManager::DeleteContent(const XCONTENT_DATA& data) {
std::lock_guard<xe::recursive_mutex> lock(content_mutex_); std::lock_guard<xe::recursive_mutex> lock(content_mutex_);
auto package_path = ResolvePackagePath(data); auto package_path = ResolvePackagePath(data);
if (xe::fs::PathExists(package_path)) { if (xe::filesystem::PathExists(package_path)) {
xe::fs::DeleteFolder(package_path); xe::filesystem::DeleteFolder(package_path);
return X_ERROR_SUCCESS; return X_ERROR_SUCCESS;
} else { } else {
return X_ERROR_FILE_NOT_FOUND; return X_ERROR_FILE_NOT_FOUND;

6
src/xenia/kernel/kernel_state.h
View File

@@ -19,10 +19,10 @@
#include "xenia/cpu/export_resolver.h" #include "xenia/cpu/export_resolver.h"
#include "xenia/kernel/app.h" #include "xenia/kernel/app.h"
#include "xenia/kernel/content_manager.h" #include "xenia/kernel/content_manager.h"
#include "xenia/kernel/fs/filesystem.h"
#include "xenia/kernel/object_table.h" #include "xenia/kernel/object_table.h"
#include "xenia/kernel/user_profile.h" #include "xenia/kernel/user_profile.h"
#include "xenia/memory.h" #include "xenia/memory.h"
#include "xenia/vfs/virtual_file_system.h"
#include "xenia/xbox.h" #include "xenia/xbox.h"
namespace xe { namespace xe {
@@ -84,7 +84,7 @@ class KernelState {
Emulator* emulator() const { return emulator_; } Emulator* emulator() const { return emulator_; }
Memory* memory() const { return memory_; } Memory* memory() const { return memory_; }
cpu::Processor* processor() const { return processor_; } cpu::Processor* processor() const { return processor_; }
fs::FileSystem* file_system() const { return file_system_; } vfs::VirtualFileSystem* file_system() const { return file_system_; }
uint32_t title_id() const; uint32_t title_id() const;
@@ -140,7 +140,7 @@ class KernelState {
Emulator* emulator_; Emulator* emulator_;
Memory* memory_; Memory* memory_;
cpu::Processor* processor_; cpu::Processor* processor_;
fs::FileSystem* file_system_; vfs::VirtualFileSystem* file_system_;
Dispatcher* dispatcher_; Dispatcher* dispatcher_;

2
src/xenia/kernel/objects/xfile.cc
View File

@@ -15,7 +15,7 @@
namespace xe { namespace xe {
namespace kernel { namespace kernel {
XFile::XFile(KernelState* kernel_state, fs::Mode mode) XFile::XFile(KernelState* kernel_state, vfs::Mode mode)
: mode_(mode), position_(0), XObject(kernel_state, kTypeFile) { : mode_(mode), position_(0), XObject(kernel_state, kTypeFile) {
async_event_ = new XEvent(kernel_state); async_event_ = new XEvent(kernel_state);
async_event_->Initialize(false, false); async_event_->Initialize(false, false);

8
src/xenia/kernel/objects/xfile.h
View File

@@ -10,8 +10,8 @@
#ifndef XENIA_KERNEL_XBOXKRNL_XFILE_H_ #ifndef XENIA_KERNEL_XBOXKRNL_XFILE_H_
#define XENIA_KERNEL_XBOXKRNL_XFILE_H_ #define XENIA_KERNEL_XBOXKRNL_XFILE_H_
#include "xenia/kernel/fs/entry.h"
#include "xenia/kernel/xobject.h" #include "xenia/kernel/xobject.h"
#include "xenia/vfs/entry.h"
#include "xenia/xbox.h" #include "xenia/xbox.h"
@@ -139,7 +139,7 @@ class XFile : public XObject {
virtual const std::string& path() const = 0; virtual const std::string& path() const = 0;
virtual const std::string& name() const = 0; virtual const std::string& name() const = 0;
virtual fs::Device* device() const = 0; virtual vfs::Device* device() const = 0;
size_t position() const { return position_; } size_t position() const { return position_; }
void set_position(size_t value) { position_ = value; } void set_position(size_t value) { position_ = value; }
@@ -160,7 +160,7 @@ class XFile : public XObject {
virtual void* GetWaitHandle(); virtual void* GetWaitHandle();
protected: protected:
XFile(KernelState* kernel_state, fs::Mode mode); XFile(KernelState* kernel_state, vfs::Mode mode);
virtual X_STATUS ReadSync(void* buffer, size_t buffer_length, virtual X_STATUS ReadSync(void* buffer, size_t buffer_length,
size_t byte_offset, size_t* out_bytes_read) = 0; size_t byte_offset, size_t* out_bytes_read) = 0;
virtual X_STATUS WriteSync(const void* buffer, size_t buffer_length, virtual X_STATUS WriteSync(const void* buffer, size_t buffer_length,
@@ -169,7 +169,7 @@ class XFile : public XObject {
} }
private: private:
fs::Mode mode_; vfs::Mode mode_;
XEvent* async_event_; XEvent* async_event_;
// TODO(benvanik): create flags, open state, etc. // TODO(benvanik): create flags, open state, etc.

4
src/xenia/kernel/objects/xuser_module.cc
View File

@@ -51,7 +51,7 @@ X_STATUS XUserModule::LoadFromFile(std::string path) {
// If the FS supports mapping, map the file in and load from that. // If the FS supports mapping, map the file in and load from that.
if (fs_entry->can_map()) { if (fs_entry->can_map()) {
// Map. // Map.
auto mmap = fs_entry->CreateMemoryMapping(fs::Mode::READ, 0, 0); auto mmap = fs_entry->CreateMemoryMapping(vfs::Mode::READ, 0, 0);
if (!mmap) { if (!mmap) {
return result; return result;
} }
@@ -70,7 +70,7 @@ X_STATUS XUserModule::LoadFromFile(std::string path) {
// Open file for reading. // Open file for reading.
XFile* file_ptr = nullptr; XFile* file_ptr = nullptr;
result = kernel_state()->file_system()->Open( result = kernel_state()->file_system()->Open(
std::move(fs_entry), kernel_state(), fs::Mode::READ, false, &file_ptr); std::move(fs_entry), kernel_state(), vfs::Mode::READ, false, &file_ptr);
object_ref<XFile> file(file_ptr); object_ref<XFile> file(file_ptr);
if (result) { if (result) {
return result; return result;

16
src/xenia/kernel/xboxkrnl_io.cc
View File

@@ -12,18 +12,18 @@
#include "xenia/cpu/processor.h" #include "xenia/cpu/processor.h"
#include "xenia/kernel/async_request.h" #include "xenia/kernel/async_request.h"
#include "xenia/kernel/kernel_state.h" #include "xenia/kernel/kernel_state.h"
#include "xenia/kernel/fs/device.h"
#include "xenia/kernel/objects/xevent.h" #include "xenia/kernel/objects/xevent.h"
#include "xenia/kernel/objects/xfile.h" #include "xenia/kernel/objects/xfile.h"
#include "xenia/kernel/objects/xthread.h" #include "xenia/kernel/objects/xthread.h"
#include "xenia/kernel/util/shim_utils.h" #include "xenia/kernel/util/shim_utils.h"
#include "xenia/kernel/xboxkrnl_private.h" #include "xenia/kernel/xboxkrnl_private.h"
#include "xenia/vfs/device.h"
#include "xenia/xbox.h" #include "xenia/xbox.h"
namespace xe { namespace xe {
namespace kernel { namespace kernel {
using namespace xe::kernel::fs; using namespace xe::vfs;
// TODO(benvanik): replace X_OBJECT_ATTRIBUTES with new style and remove this. // TODO(benvanik): replace X_OBJECT_ATTRIBUTES with new style and remove this.
class X_ANSI_STRING_OLD { class X_ANSI_STRING_OLD {
@@ -127,7 +127,7 @@ X_STATUS NtCreateFile(PPCContext* ppc_context, KernelState* kernel_state,
uint32_t info = X_FILE_DOES_NOT_EXIST; uint32_t info = X_FILE_DOES_NOT_EXIST;
uint32_t handle; uint32_t handle;
FileSystem* fs = kernel_state->file_system(); auto fs = kernel_state->file_system();
std::unique_ptr<Entry> entry; std::unique_ptr<Entry> entry;
object_ref<XFile> root_file; object_ref<XFile> root_file;
@@ -165,13 +165,13 @@ X_STATUS NtCreateFile(PPCContext* ppc_context, KernelState* kernel_state,
info = X_FILE_DOES_NOT_EXIST; info = X_FILE_DOES_NOT_EXIST;
} else { } else {
// Open the file/directory. // Open the file/directory.
fs::Mode mode; vfs::Mode mode;
if (desired_access & FileAccess::X_FILE_APPEND_DATA) { if (desired_access & FileAccess::X_FILE_APPEND_DATA) {
mode = fs::Mode::READ_APPEND; mode = vfs::Mode::READ_APPEND;
} else if (wants_write) { } else if (wants_write) {
mode = fs::Mode::READ_WRITE; mode = vfs::Mode::READ_WRITE;
} else { } else {
mode = fs::Mode::READ; mode = vfs::Mode::READ;
} }
XFile* file_ptr = nullptr; XFile* file_ptr = nullptr;
result = fs->Open(std::move(entry), kernel_state, mode, result = fs->Open(std::move(entry), kernel_state, mode,
@@ -638,7 +638,7 @@ SHIM_CALL NtQueryFullAttributesFile_shim(PPCContext* ppc_context,
} }
// Resolve the file using the virtual file system. // Resolve the file using the virtual file system.
FileSystem* fs = kernel_state->file_system(); auto fs = kernel_state->file_system();
auto entry = fs->ResolvePath(object_name); auto entry = fs->ResolvePath(object_name);
if (entry) { if (entry) {
// Found. // Found.

6
src/xenia/ui/main_window.cc
View File

@@ -270,13 +270,13 @@ X_STATUS MainWindow::LaunchPath(std::wstring path) {
// NOTE: this blocks! // NOTE: this blocks!
auto file_system_type = emulator_->file_system()->InferType(path); auto file_system_type = emulator_->file_system()->InferType(path);
switch (file_system_type) { switch (file_system_type) {
case kernel::fs::FileSystemType::STFS_TITLE: case vfs::FileSystemType::STFS_TITLE:
result = emulator_->LaunchSTFSTitle(path); result = emulator_->LaunchSTFSTitle(path);
break; break;
case kernel::fs::FileSystemType::XEX_FILE: case vfs::FileSystemType::XEX_FILE:
result = emulator_->LaunchXexFile(path); result = emulator_->LaunchXexFile(path);
break; break;
case kernel::fs::FileSystemType::DISC_IMAGE: case vfs::FileSystemType::DISC_IMAGE:
result = emulator_->LaunchDiscImage(path); result = emulator_->LaunchDiscImage(path);
break; break;
} }

8
src/xenia/kernel/fs/device.cc → src/xenia/vfs/device.cc
View File

@@ -7,13 +7,12 @@
****************************************************************************** ******************************************************************************
*/ */
#include "xenia/kernel/fs/device.h" #include "xenia/vfs/device.h"
#include "xenia/kernel/objects/xfile.h" #include "xenia/kernel/objects/xfile.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
Device::Device(const std::string& path) : path_(path) {} Device::Device(const std::string& path) : path_(path) {}
@@ -69,6 +68,5 @@ X_STATUS Device::QueryAttributeInfo(X_FILE_FS_ATTRIBUTE_INFORMATION* out_info,
return X_STATUS_SUCCESS; return X_STATUS_SUCCESS;
} }
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe

14
src/xenia/kernel/fs/device.h → src/xenia/vfs/device.h
View File

@@ -7,17 +7,16 @@
****************************************************************************** ******************************************************************************
*/ */
#ifndef XENIA_KERNEL_FS_DEVICE_H_ #ifndef XENIA_VFS_DEVICE_H_
#define XENIA_KERNEL_FS_DEVICE_H_ #define XENIA_VFS_DEVICE_H_
#include <memory> #include <memory>
#include <string> #include <string>
#include "xenia/kernel/fs/entry.h" #include "xenia/vfs/entry.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
class Device { class Device {
public: public:
@@ -41,8 +40,7 @@ class Device {
std::string path_; std::string path_;
}; };
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe
#endif // XENIA_KERNEL_FS_DEVICE_H_ #endif // XENIA_VFS_DEVICE_H_

12
src/xenia/kernel/fs/devices/disc_image_device.cc → src/xenia/vfs/devices/disc_image_device.cc
View File

@@ -7,16 +7,15 @@
****************************************************************************** ******************************************************************************
*/ */
#include "xenia/kernel/fs/devices/disc_image_device.h" #include "xenia/vfs/devices/disc_image_device.h"
#include "xenia/base/logging.h" #include "xenia/base/logging.h"
#include "xenia/base/math.h" #include "xenia/base/math.h"
#include "xenia/kernel/fs/gdfx.h" #include "xenia/vfs/gdfx.h"
#include "xenia/kernel/fs/devices/disc_image_entry.h" #include "xenia/vfs/devices/disc_image_entry.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
DiscImageDevice::DiscImageDevice(const std::string& path, DiscImageDevice::DiscImageDevice(const std::string& path,
const std::wstring& local_path) const std::wstring& local_path)
@@ -65,6 +64,5 @@ std::unique_ptr<Entry> DiscImageDevice::ResolvePath(const char* path) {
return std::make_unique<DiscImageEntry>(this, path, mmap_.get(), gdfx_entry); return std::make_unique<DiscImageEntry>(this, path, mmap_.get(), gdfx_entry);
} }
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe

14
src/xenia/kernel/fs/devices/disc_image_device.h → src/xenia/vfs/devices/disc_image_device.h
View File

@@ -7,18 +7,17 @@
****************************************************************************** ******************************************************************************
*/ */
#ifndef XENIA_KERNEL_FS_DEVICES_DISC_IMAGE_DEVICE_H_ #ifndef XENIA_VFS_DEVICES_DISC_IMAGE_DEVICE_H_
#define XENIA_KERNEL_FS_DEVICES_DISC_IMAGE_DEVICE_H_ #define XENIA_VFS_DEVICES_DISC_IMAGE_DEVICE_H_
#include <memory> #include <memory>
#include <string> #include <string>
#include "xenia/base/mapped_memory.h" #include "xenia/base/mapped_memory.h"
#include "xenia/kernel/fs/device.h" #include "xenia/vfs/device.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
class GDFX; class GDFX;
@@ -37,8 +36,7 @@ class DiscImageDevice : public Device {
GDFX* gdfx_; GDFX* gdfx_;
}; };
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe
#endif // XENIA_KERNEL_FS_DEVICES_DISC_IMAGE_DEVICE_H_ #endif // XENIA_VFS_DEVICES_DISC_IMAGE_DEVICE_H_

10
src/xenia/kernel/fs/devices/disc_image_entry.cc → src/xenia/vfs/devices/disc_image_entry.cc
View File

@@ -7,16 +7,15 @@
****************************************************************************** ******************************************************************************
*/ */
#include "xenia/kernel/fs/devices/disc_image_entry.h" #include "xenia/vfs/devices/disc_image_entry.h"
#include <algorithm> #include <algorithm>
#include "xenia/base/math.h" #include "xenia/base/math.h"
#include "xenia/kernel/fs/devices/disc_image_file.h" #include "xenia/vfs/devices/disc_image_file.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
class DiscImageMemoryMapping : public MemoryMapping { class DiscImageMemoryMapping : public MemoryMapping {
public: public:
@@ -118,6 +117,5 @@ X_STATUS DiscImageEntry::Open(KernelState* kernel_state, Mode mode, bool async,
return X_STATUS_SUCCESS; return X_STATUS_SUCCESS;
} }
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe

20
src/xenia/kernel/fs/devices/disc_image_entry.h → src/xenia/vfs/devices/disc_image_entry.h
View File

@@ -7,19 +7,18 @@
****************************************************************************** ******************************************************************************
*/ */
#ifndef XENIA_KERNEL_FS_DEVICES_DISC_IMAGE_ENTRY_H_ #ifndef XENIA_VFS_DEVICES_DISC_IMAGE_ENTRY_H_
#define XENIA_KERNEL_FS_DEVICES_DISC_IMAGE_ENTRY_H_ #define XENIA_VFS_DEVICES_DISC_IMAGE_ENTRY_H_
#include <vector> #include <vector>
#include "xenia/base/fs.h" #include "xenia/base/filesystem.h"
#include "xenia/base/mapped_memory.h" #include "xenia/base/mapped_memory.h"
#include "xenia/kernel/fs/entry.h" #include "xenia/vfs/entry.h"
#include "xenia/kernel/fs/gdfx.h" #include "xenia/vfs/gdfx.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
class DiscImageEntry : public Entry { class DiscImageEntry : public Entry {
public: public:
@@ -45,12 +44,11 @@ class DiscImageEntry : public Entry {
MappedMemory* mmap_; MappedMemory* mmap_;
GDFXEntry* gdfx_entry_; GDFXEntry* gdfx_entry_;
xe::fs::WildcardEngine find_engine_; xe::filesystem::WildcardEngine find_engine_;
GDFXEntry::child_it_t it_; GDFXEntry::child_it_t it_;
}; };
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe
#endif // XENIA_KERNEL_FS_DEVICES_DISC_IMAGE_ENTRY_H_ #endif // XENIA_VFS_DEVICES_DISC_IMAGE_ENTRY_H_

14
src/xenia/kernel/fs/devices/disc_image_file.cc → src/xenia/vfs/devices/disc_image_file.cc
View File

@@ -7,17 +7,16 @@
****************************************************************************** ******************************************************************************
*/ */
#include "xenia/kernel/fs/devices/disc_image_file.h" #include "xenia/vfs/devices/disc_image_file.h"
#include <algorithm> #include <algorithm>
#include "xenia/kernel/fs/device.h" #include "xenia/vfs/device.h"
#include "xenia/kernel/fs/devices/disc_image_entry.h" #include "xenia/vfs/devices/disc_image_entry.h"
#include "xenia/kernel/fs/gdfx.h" #include "xenia/vfs/gdfx.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
DiscImageFile::DiscImageFile(KernelState* kernel_state, Mode mode, DiscImageFile::DiscImageFile(KernelState* kernel_state, Mode mode,
DiscImageEntry* entry) DiscImageEntry* entry)
@@ -54,6 +53,5 @@ X_STATUS DiscImageFile::ReadSync(void* buffer, size_t buffer_length,
return X_STATUS_SUCCESS; return X_STATUS_SUCCESS;
} }
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe

12
src/xenia/kernel/fs/devices/disc_image_file.h → src/xenia/vfs/devices/disc_image_file.h
View File

@@ -7,14 +7,13 @@
****************************************************************************** ******************************************************************************
*/ */
#ifndef XENIA_KERNEL_FS_DEVICES_DISC_IMAGE_FILE_H_ #ifndef XENIA_VFS_DEVICES_DISC_IMAGE_FILE_H_
#define XENIA_KERNEL_FS_DEVICES_DISC_IMAGE_FILE_H_ #define XENIA_VFS_DEVICES_DISC_IMAGE_FILE_H_
#include "xenia/kernel/objects/xfile.h" #include "xenia/kernel/objects/xfile.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
class DiscImageEntry; class DiscImageEntry;
@@ -41,8 +40,7 @@ class DiscImageFile : public XFile {
DiscImageEntry* entry_; DiscImageEntry* entry_;
}; };
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe
#endif // XENIA_KERNEL_FS_DEVICES_DISC_IMAGE_FILE_H_ #endif // XENIA_VFS_DEVICES_DISC_IMAGE_FILE_H_

14
src/xenia/kernel/fs/devices/host_path_device.cc → src/xenia/vfs/devices/host_path_device.cc
View File

@@ -7,16 +7,15 @@
****************************************************************************** ******************************************************************************
*/ */
#include "xenia/kernel/fs/devices/host_path_device.h" #include "xenia/vfs/devices/host_path_device.h"
#include "xenia/base/filesystem.h"
#include "xenia/base/logging.h" #include "xenia/base/logging.h"
#include "xenia/base/fs.h" #include "xenia/vfs/devices/host_path_entry.h"
#include "xenia/kernel/fs/devices/host_path_entry.h"
#include "xenia/kernel/objects/xfile.h" #include "xenia/kernel/objects/xfile.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
HostPathDevice::HostPathDevice(const std::string& path, HostPathDevice::HostPathDevice(const std::string& path,
const std::wstring& local_path, bool read_only) const std::wstring& local_path, bool read_only)
@@ -37,7 +36,7 @@ std::unique_ptr<Entry> HostPathDevice::ResolvePath(const char* path) {
// Only check the file exists when the device is read-only // Only check the file exists when the device is read-only
if (read_only_) { if (read_only_) {
if (!xe::fs::PathExists(full_path)) { if (!xe::filesystem::PathExists(full_path)) {
return nullptr; return nullptr;
} }
} }
@@ -48,6 +47,5 @@ std::unique_ptr<Entry> HostPathDevice::ResolvePath(const char* path) {
return std::make_unique<HostPathEntry>(this, path, full_path); return std::make_unique<HostPathEntry>(this, path, full_path);
} }
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe

14
src/xenia/kernel/fs/devices/host_path_device.h → src/xenia/vfs/devices/host_path_device.h
View File

@@ -7,16 +7,15 @@
****************************************************************************** ******************************************************************************
*/ */
#ifndef XENIA_KERNEL_FS_DEVICES_HOST_PATH_DEVICE_H_ #ifndef XENIA_VFS_DEVICES_HOST_PATH_DEVICE_H_
#define XENIA_KERNEL_FS_DEVICES_HOST_PATH_DEVICE_H_ #define XENIA_VFS_DEVICES_HOST_PATH_DEVICE_H_
#include <string> #include <string>
#include "xenia/kernel/fs/device.h" #include "xenia/vfs/device.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
class HostPathDevice : public Device { class HostPathDevice : public Device {
public: public:
@@ -33,8 +32,7 @@ class HostPathDevice : public Device {
bool read_only_; bool read_only_;
}; };
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe
#endif // XENIA_KERNEL_FS_DEVICES_HOST_PATH_DEVICE_H_ #endif // XENIA_VFS_DEVICES_HOST_PATH_DEVICE_H_

10
src/xenia/kernel/fs/devices/host_path_entry.cc → src/xenia/vfs/devices/host_path_entry.cc
View File

@@ -7,16 +7,15 @@
****************************************************************************** ******************************************************************************
*/ */
#include "xenia/kernel/fs/devices/host_path_entry.h" #include "xenia/vfs/devices/host_path_entry.h"
#include "xenia/base/mapped_memory.h" #include "xenia/base/mapped_memory.h"
#include "xenia/base/math.h" #include "xenia/base/math.h"
#include "xenia/base/string.h" #include "xenia/base/string.h"
#include "xenia/kernel/fs/devices/host_path_file.h" #include "xenia/vfs/devices/host_path_file.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
class HostPathMemoryMapping : public MemoryMapping { class HostPathMemoryMapping : public MemoryMapping {
public: public:
@@ -177,6 +176,5 @@ X_STATUS HostPathEntry::Open(KernelState* kernel_state, Mode mode, bool async,
return X_STATUS_SUCCESS; return X_STATUS_SUCCESS;
} }
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe

14
src/xenia/kernel/fs/devices/host_path_entry.h → src/xenia/vfs/devices/host_path_entry.h
View File

@@ -7,14 +7,13 @@
****************************************************************************** ******************************************************************************
*/ */
#ifndef XENIA_KERNEL_FS_DEVICES_HOST_PATH_ENTRY_H_ #ifndef XENIA_VFS_DEVICES_HOST_PATH_ENTRY_H_
#define XENIA_KERNEL_FS_DEVICES_HOST_PATH_ENTRY_H_ #define XENIA_VFS_DEVICES_HOST_PATH_ENTRY_H_
#include "xenia/kernel/fs/entry.h" #include "xenia/vfs/entry.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
class HostPathEntry : public Entry { class HostPathEntry : public Entry {
public: public:
@@ -40,8 +39,7 @@ class HostPathEntry : public Entry {
HANDLE find_file_; HANDLE find_file_;
}; };
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe
#endif // XENIA_KERNEL_FS_DEVICES_HOST_PATH_ENTRY_H_ #endif // XENIA_VFS_DEVICES_HOST_PATH_ENTRY_H_

12
src/xenia/kernel/fs/devices/host_path_file.cc → src/xenia/vfs/devices/host_path_file.cc
View File

@@ -7,14 +7,13 @@
****************************************************************************** ******************************************************************************
*/ */
#include "xenia/kernel/fs/devices/host_path_file.h" #include "xenia/vfs/devices/host_path_file.h"
#include "xenia/kernel/fs/device.h" #include "xenia/vfs/device.h"
#include "xenia/kernel/fs/devices/host_path_entry.h" #include "xenia/vfs/devices/host_path_entry.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
HostPathFile::HostPathFile(KernelState* kernel_state, Mode mode, HostPathFile::HostPathFile(KernelState* kernel_state, Mode mode,
HostPathEntry* entry, HANDLE file_handle) HostPathEntry* entry, HANDLE file_handle)
@@ -74,6 +73,5 @@ X_STATUS HostPathFile::WriteSync(const void* buffer, size_t buffer_length,
} }
} }
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe

12
src/xenia/kernel/fs/devices/host_path_file.h → src/xenia/vfs/devices/host_path_file.h
View File

@@ -7,16 +7,15 @@
****************************************************************************** ******************************************************************************
*/ */
#ifndef XENIA_KERNEL_FS_DEVICES_HOST_PATH_FILE_H_ #ifndef XENIA_VFS_DEVICES_HOST_PATH_FILE_H_
#define XENIA_KERNEL_FS_DEVICES_HOST_PATH_FILE_H_ #define XENIA_VFS_DEVICES_HOST_PATH_FILE_H_
#include <string> #include <string>
#include "xenia/kernel/objects/xfile.h" #include "xenia/kernel/objects/xfile.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
class HostPathEntry; class HostPathEntry;
@@ -46,8 +45,7 @@ class HostPathFile : public XFile {
HANDLE file_handle_; HANDLE file_handle_;
}; };
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe
#endif // XENIA_KERNEL_FS_DEVICES_HOST_PATH_FILE_H_ #endif // XENIA_VFS_DEVICES_HOST_PATH_FILE_H_

12
src/xenia/kernel/fs/devices/stfs_container_device.cc → src/xenia/vfs/devices/stfs_container_device.cc
View File

@@ -7,17 +7,16 @@
****************************************************************************** ******************************************************************************
*/ */
#include "xenia/kernel/fs/devices/stfs_container_device.h" #include "xenia/vfs/devices/stfs_container_device.h"
#include "xenia/base/logging.h" #include "xenia/base/logging.h"
#include "xenia/base/math.h" #include "xenia/base/math.h"
#include "xenia/kernel/fs/stfs.h" #include "xenia/vfs/stfs.h"
#include "xenia/kernel/fs/devices/stfs_container_entry.h" #include "xenia/vfs/devices/stfs_container_entry.h"
#include "xenia/kernel/objects/xfile.h" #include "xenia/kernel/objects/xfile.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
STFSContainerDevice::STFSContainerDevice(const std::string& path, STFSContainerDevice::STFSContainerDevice(const std::string& path,
const std::wstring& local_path) const std::wstring& local_path)
@@ -67,6 +66,5 @@ std::unique_ptr<Entry> STFSContainerDevice::ResolvePath(const char* path) {
stfs_entry); stfs_entry);
} }
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe

14
src/xenia/kernel/fs/devices/stfs_container_device.h → src/xenia/vfs/devices/stfs_container_device.h
View File

@@ -7,18 +7,17 @@
****************************************************************************** ******************************************************************************
*/ */
#ifndef XENIA_KERNEL_FS_DEVICES_STFS_CONTAINER_DEVICE_H_ #ifndef XENIA_VFS_DEVICES_STFS_CONTAINER_DEVICE_H_
#define XENIA_KERNEL_FS_DEVICES_STFS_CONTAINER_DEVICE_H_ #define XENIA_VFS_DEVICES_STFS_CONTAINER_DEVICE_H_
#include <memory> #include <memory>
#include <string> #include <string>
#include "xenia/base/mapped_memory.h" #include "xenia/base/mapped_memory.h"
#include "xenia/kernel/fs/device.h" #include "xenia/vfs/device.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
class STFS; class STFS;
@@ -37,8 +36,7 @@ class STFSContainerDevice : public Device {
STFS* stfs_; STFS* stfs_;
}; };
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe
#endif // XENIA_KERNEL_FS_DEVICES_STFS_CONTAINER_DEVICE_H_ #endif // XENIA_VFS_DEVICES_STFS_CONTAINER_DEVICE_H_

10
src/xenia/kernel/fs/devices/stfs_container_entry.cc → src/xenia/vfs/devices/stfs_container_entry.cc
View File

@@ -7,14 +7,13 @@
****************************************************************************** ******************************************************************************
*/ */
#include "xenia/kernel/fs/devices/stfs_container_entry.h" #include "xenia/vfs/devices/stfs_container_entry.h"
#include "xenia/base/math.h" #include "xenia/base/math.h"
#include "xenia/kernel/fs/devices/stfs_container_file.h" #include "xenia/vfs/devices/stfs_container_file.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
STFSContainerEntry::STFSContainerEntry(Device* device, const char* path, STFSContainerEntry::STFSContainerEntry(Device* device, const char* path,
MappedMemory* mmap, MappedMemory* mmap,
@@ -95,6 +94,5 @@ X_STATUS STFSContainerEntry::Open(KernelState* kernel_state, Mode mode,
return X_STATUS_SUCCESS; return X_STATUS_SUCCESS;
} }
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe

20
src/xenia/kernel/fs/devices/stfs_container_entry.h → src/xenia/vfs/devices/stfs_container_entry.h
View File

@@ -7,20 +7,19 @@
****************************************************************************** ******************************************************************************
*/ */
#ifndef XENIA_KERNEL_FS_DEVICES_STFS_CONTAINER_ENTRY_H_ #ifndef XENIA_VFS_DEVICES_STFS_CONTAINER_ENTRY_H_
#define XENIA_KERNEL_FS_DEVICES_STFS_CONTAINER_ENTRY_H_ #define XENIA_VFS_DEVICES_STFS_CONTAINER_ENTRY_H_
#include <vector> #include <vector>
#include <iterator> #include <iterator>
#include "xenia/base/fs.h" #include "xenia/base/filesystem.h"
#include "xenia/base/mapped_memory.h" #include "xenia/base/mapped_memory.h"
#include "xenia/kernel/fs/entry.h" #include "xenia/vfs/entry.h"
#include "xenia/kernel/fs/stfs.h" #include "xenia/vfs/stfs.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
class STFSContainerEntry : public Entry { class STFSContainerEntry : public Entry {
public: public:
@@ -42,12 +41,11 @@ class STFSContainerEntry : public Entry {
MappedMemory* mmap_; MappedMemory* mmap_;
STFSEntry* stfs_entry_; STFSEntry* stfs_entry_;
xe::fs::WildcardEngine find_engine_; xe::filesystem::WildcardEngine find_engine_;
STFSEntry::child_it_t it_; STFSEntry::child_it_t it_;
}; };
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe
#endif // XENIA_KERNEL_FS_DEVICES_STFS_CONTAINER_ENTRY_H_ #endif // XENIA_VFS_DEVICES_STFS_CONTAINER_ENTRY_H_

14
src/xenia/kernel/fs/devices/stfs_container_file.cc → src/xenia/vfs/devices/stfs_container_file.cc
View File

@@ -7,17 +7,16 @@
****************************************************************************** ******************************************************************************
*/ */
#include "xenia/kernel/fs/devices/stfs_container_file.h" #include "xenia/vfs/devices/stfs_container_file.h"
#include <algorithm> #include <algorithm>
#include "xenia/kernel/fs/device.h" #include "xenia/vfs/device.h"
#include "xenia/kernel/fs/devices/stfs_container_entry.h" #include "xenia/vfs/devices/stfs_container_entry.h"
#include "xenia/kernel/fs/stfs.h" #include "xenia/vfs/stfs.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
STFSContainerFile::STFSContainerFile(KernelState* kernel_state, Mode mode, STFSContainerFile::STFSContainerFile(KernelState* kernel_state, Mode mode,
STFSContainerEntry* entry) STFSContainerEntry* entry)
@@ -76,6 +75,5 @@ X_STATUS STFSContainerFile::ReadSync(void* buffer, size_t buffer_length,
return X_STATUS_SUCCESS; return X_STATUS_SUCCESS;
} }
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe

12
src/xenia/kernel/fs/devices/stfs_container_file.h → src/xenia/vfs/devices/stfs_container_file.h
View File

@@ -7,14 +7,13 @@
****************************************************************************** ******************************************************************************
*/ */
#ifndef XENIA_KERNEL_FS_DEVICES_STFS_CONTAINER_FILE_H_ #ifndef XENIA_VFS_DEVICES_STFS_CONTAINER_FILE_H_
#define XENIA_KERNEL_FS_DEVICES_STFS_CONTAINER_FILE_H_ #define XENIA_VFS_DEVICES_STFS_CONTAINER_FILE_H_
#include "xenia/kernel/objects/xfile.h" #include "xenia/kernel/objects/xfile.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
class STFSContainerEntry; class STFSContainerEntry;
@@ -41,8 +40,7 @@ class STFSContainerFile : public XFile {
STFSContainerEntry* entry_; STFSContainerEntry* entry_;
}; };
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe
#endif // XENIA_KERNEL_FS_DEVICES_STFS_CONTAINER_FILE_H_ #endif // XENIA_VFS_DEVICES_STFS_CONTAINER_FILE_H_

10
src/xenia/kernel/fs/entry.cc → src/xenia/vfs/entry.cc
View File

@@ -7,14 +7,13 @@
****************************************************************************** ******************************************************************************
*/ */
#include "xenia/kernel/fs/entry.h" #include "xenia/vfs/entry.h"
#include "xenia/base/string.h" #include "xenia/base/string.h"
#include "xenia/kernel/fs/device.h" #include "xenia/vfs/device.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
MemoryMapping::MemoryMapping(uint8_t* address, size_t length) MemoryMapping::MemoryMapping(uint8_t* address, size_t length)
: address_(address), length_(length) {} : address_(address), length_(length) {}
@@ -32,6 +31,5 @@ Entry::~Entry() = default;
bool Entry::is_read_only() const { return device_->is_read_only(); } bool Entry::is_read_only() const { return device_->is_read_only(); }
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe

14
src/xenia/kernel/fs/entry.h → src/xenia/vfs/entry.h
View File

@@ -7,8 +7,8 @@
****************************************************************************** ******************************************************************************
*/ */
#ifndef XENIA_KERNEL_FS_ENTRY_H_ #ifndef XENIA_VFS_ENTRY_H_
#define XENIA_KERNEL_FS_ENTRY_H_ #define XENIA_VFS_ENTRY_H_
#include <memory> #include <memory>
#include <string> #include <string>
@@ -28,8 +28,9 @@ class X_FILE_FS_VOLUME_INFORMATION;
} // namespace xe } // namespace xe
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
using namespace xe::kernel;
class Device; class Device;
@@ -86,8 +87,7 @@ class Entry {
std::string name_; std::string name_;
}; };
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe
#endif // XENIA_KERNEL_FS_ENTRY_H_ #endif // XENIA_VFS_ENTRY_H_

10
src/xenia/kernel/fs/gdfx.cc → src/xenia/vfs/gdfx.cc
View File

@@ -9,13 +9,12 @@
* - abgx360 * - abgx360
*/ */
#include "xenia/kernel/fs/gdfx.h" #include "xenia/vfs/gdfx.h"
#include "xenia/base/math.h" #include "xenia/base/math.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
const size_t kXESectorSize = 2048; const size_t kXESectorSize = 2048;
@@ -29,7 +28,7 @@ GDFXEntry::~GDFXEntry() {
} }
} }
GDFXEntry* GDFXEntry::GetChild(const xe::fs::WildcardEngine& engine, GDFXEntry* GDFXEntry::GetChild(const xe::filesystem::WildcardEngine& engine,
child_it_t& ref_it) { child_it_t& ref_it) {
GDFXEntry* child_entry(nullptr); GDFXEntry* child_entry(nullptr);
while (ref_it != children.end()) { while (ref_it != children.end()) {
@@ -202,6 +201,5 @@ bool GDFX::ReadEntry(ParseState& state, const uint8_t* buffer,
return true; return true;
} }
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe

19
src/xenia/kernel/fs/gdfx.h → src/xenia/vfs/gdfx.h
View File

@@ -7,19 +7,18 @@
****************************************************************************** ******************************************************************************
*/ */
#ifndef XENIA_KERNEL_FS_GDFX_H_ #ifndef XENIA_VFS_GDFX_H_
#define XENIA_KERNEL_FS_GDFX_H_ #define XENIA_VFS_GDFX_H_
#include <vector> #include <vector>
#include "xenia/base/fs.h" #include "xenia/base/filesystem.h"
#include "xenia/base/mapped_memory.h" #include "xenia/base/mapped_memory.h"
#include "xenia/kernel/fs/entry.h" #include "xenia/vfs/entry.h"
#include "xenia/xbox.h" #include "xenia/xbox.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
class GDFX; class GDFX;
@@ -31,7 +30,8 @@ class GDFXEntry {
typedef std::vector<GDFXEntry*> child_t; typedef std::vector<GDFXEntry*> child_t;
typedef child_t::iterator child_it_t; typedef child_t::iterator child_it_t;
GDFXEntry* GetChild(const xe::fs::WildcardEngine& engine, child_it_t& ref_it); GDFXEntry* GetChild(const xe::filesystem::WildcardEngine& engine,
child_it_t& ref_it);
GDFXEntry* GetChild(const char* name); GDFXEntry* GetChild(const char* name);
void Dump(int indent); void Dump(int indent);
@@ -90,8 +90,7 @@ class GDFX {
GDFXEntry* root_entry_; GDFXEntry* root_entry_;
}; };
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe
#endif // XENIA_KERNEL_FS_GDFX_H_ #endif // XENIA_VFS_GDFX_H_

10
src/xenia/kernel/fs/stfs.cc → src/xenia/vfs/stfs.cc
View File

@@ -9,15 +9,14 @@
* - free60 * - free60
*/ */
#include "xenia/kernel/fs/stfs.h" #include "xenia/vfs/stfs.h"
#include <algorithm> #include <algorithm>
#include "xenia/base/logging.h" #include "xenia/base/logging.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
#define XEGETUINT24BE(p) \ #define XEGETUINT24BE(p) \
(((uint32_t)xe::load_and_swap<uint8_t>((p) + 0) << 16) | \ (((uint32_t)xe::load_and_swap<uint8_t>((p) + 0) << 16) | \
@@ -102,7 +101,7 @@ STFSEntry::STFSEntry()
update_timestamp(0), update_timestamp(0),
access_timestamp(0) {} access_timestamp(0) {}
STFSEntry* STFSEntry::GetChild(const xe::fs::WildcardEngine& engine, STFSEntry* STFSEntry::GetChild(const xe::filesystem::WildcardEngine& engine,
child_it_t& ref_it) { child_it_t& ref_it) {
STFSEntry* child_entry(nullptr); STFSEntry* child_entry(nullptr);
while (ref_it != children.end()) { while (ref_it != children.end()) {
@@ -340,6 +339,5 @@ STFS::BlockHash_t STFS::GetBlockHash(const uint8_t* map_ptr,
return {next_block_index, info}; return {next_block_index, info};
} }
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe

19
src/xenia/kernel/fs/stfs.h → src/xenia/vfs/stfs.h
View File

@@ -7,20 +7,19 @@
****************************************************************************** ******************************************************************************
*/ */
#ifndef XENIA_KERNEL_FS_STFS_H_ #ifndef XENIA_VFS_STFS_H_
#define XENIA_KERNEL_FS_STFS_H_ #define XENIA_VFS_STFS_H_
#include <memory> #include <memory>
#include <vector> #include <vector>
#include "xenia/base/fs.h" #include "xenia/base/filesystem.h"
#include "xenia/base/mapped_memory.h" #include "xenia/base/mapped_memory.h"
#include "xenia/kernel/fs/entry.h" #include "xenia/vfs/entry.h"
#include "xenia/xbox.h" #include "xenia/xbox.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
class STFS; class STFS;
@@ -134,7 +133,8 @@ class STFSEntry {
typedef std::vector<std::unique_ptr<STFSEntry>> child_t; typedef std::vector<std::unique_ptr<STFSEntry>> child_t;
typedef child_t::iterator child_it_t; typedef child_t::iterator child_it_t;
STFSEntry* GetChild(const xe::fs::WildcardEngine& engine, child_it_t& ref_it); STFSEntry* GetChild(const xe::filesystem::WildcardEngine& engine,
child_it_t& ref_it);
STFSEntry* GetChild(const char* name); STFSEntry* GetChild(const char* name);
void Dump(int indent); void Dump(int indent);
@@ -194,8 +194,7 @@ class STFS {
std::unique_ptr<STFSEntry> root_entry_; std::unique_ptr<STFSEntry> root_entry_;
}; };
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe
#endif // XENIA_KERNEL_FS_STFS_H_ #endif // XENIA_VFS_STFS_H_

58
src/xenia/kernel/fs/filesystem.cc → src/xenia/vfs/virtual_file_system.cc
View File

@@ -7,22 +7,21 @@
****************************************************************************** ******************************************************************************
*/ */
#include "xenia/kernel/fs/filesystem.h" #include "xenia/vfs/virtual_file_system.h"
#include "xenia/base/fs.h" #include "xenia/base/filesystem.h"
#include "xenia/base/logging.h" #include "xenia/base/logging.h"
#include "xenia/base/string.h" #include "xenia/base/string.h"
#include "xenia/kernel/fs/devices/disc_image_device.h" #include "xenia/vfs/devices/disc_image_device.h"
#include "xenia/kernel/fs/devices/host_path_device.h" #include "xenia/vfs/devices/host_path_device.h"
#include "xenia/kernel/fs/devices/stfs_container_device.h" #include "xenia/vfs/devices/stfs_container_device.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
FileSystem::FileSystem() {} VirtualFileSystem::VirtualFileSystem() {}
FileSystem::~FileSystem() { VirtualFileSystem::~VirtualFileSystem() {
// Delete all devices. // Delete all devices.
// This will explode if anyone is still using data from them. // This will explode if anyone is still using data from them.
for (std::vector<Device*>::iterator it = devices_.begin(); for (std::vector<Device*>::iterator it = devices_.begin();
@@ -33,7 +32,7 @@ FileSystem::~FileSystem() {
symlinks_.clear(); symlinks_.clear();
} }
fs::FileSystemType FileSystem::InferType(const std::wstring& local_path) { FileSystemType VirtualFileSystem::InferType(const std::wstring& local_path) {
auto last_slash = local_path.find_last_of(xe::path_separator); auto last_slash = local_path.find_last_of(xe::path_separator);
auto last_dot = local_path.find_last_of('.'); auto last_dot = local_path.find_last_of('.');
if (last_dot < last_slash) { if (last_dot < last_slash) {
@@ -51,8 +50,8 @@ fs::FileSystemType FileSystem::InferType(const std::wstring& local_path) {
} }
} }
int FileSystem::InitializeFromPath(fs::FileSystemType type, int VirtualFileSystem::InitializeFromPath(FileSystemType type,
const std::wstring& local_path) { const std::wstring& local_path) {
switch (type) { switch (type) {
case FileSystemType::STFS_TITLE: { case FileSystemType::STFS_TITLE: {
// Register the container in the virtual filesystem. // Register the container in the virtual filesystem.
@@ -104,20 +103,20 @@ int FileSystem::InitializeFromPath(fs::FileSystemType type,
return 0; return 0;
} }
int FileSystem::RegisterDevice(const std::string& path, Device* device) { int VirtualFileSystem::RegisterDevice(const std::string& path, Device* device) {
devices_.push_back(device); devices_.push_back(device);
return 0; return 0;
} }
int FileSystem::RegisterHostPathDevice(const std::string& path, int VirtualFileSystem::RegisterHostPathDevice(const std::string& path,
const std::wstring& local_path, const std::wstring& local_path,
bool read_only) { bool read_only) {
Device* device = new HostPathDevice(path, local_path, read_only); Device* device = new HostPathDevice(path, local_path, read_only);
return RegisterDevice(path, device); return RegisterDevice(path, device);
} }
int FileSystem::RegisterDiscImageDevice(const std::string& path, int VirtualFileSystem::RegisterDiscImageDevice(const std::string& path,
const std::wstring& local_path) { const std::wstring& local_path) {
DiscImageDevice* device = new DiscImageDevice(path, local_path); DiscImageDevice* device = new DiscImageDevice(path, local_path);
if (device->Init()) { if (device->Init()) {
return 1; return 1;
@@ -125,8 +124,8 @@ int FileSystem::RegisterDiscImageDevice(const std::string& path,
return RegisterDevice(path, device); return RegisterDevice(path, device);
} }
int FileSystem::RegisterSTFSContainerDevice(const std::string& path, int VirtualFileSystem::RegisterSTFSContainerDevice(
const std::wstring& local_path) { const std::string& path, const std::wstring& local_path) {
STFSContainerDevice* device = new STFSContainerDevice(path, local_path); STFSContainerDevice* device = new STFSContainerDevice(path, local_path);
if (device->Init()) { if (device->Init()) {
return 1; return 1;
@@ -134,13 +133,13 @@ int FileSystem::RegisterSTFSContainerDevice(const std::string& path,
return RegisterDevice(path, device); return RegisterDevice(path, device);
} }
int FileSystem::CreateSymbolicLink(const std::string& path, int VirtualFileSystem::CreateSymbolicLink(const std::string& path,
const std::string& target) { const std::string& target) {
symlinks_.insert({path, target}); symlinks_.insert({path, target});
return 0; return 0;
} }
int FileSystem::DeleteSymbolicLink(const std::string& path) { int VirtualFileSystem::DeleteSymbolicLink(const std::string& path) {
auto& it = symlinks_.find(path); auto& it = symlinks_.find(path);
if (it == symlinks_.end()) { if (it == symlinks_.end()) {
return 1; return 1;
@@ -149,9 +148,9 @@ int FileSystem::DeleteSymbolicLink(const std::string& path) {
return 0; return 0;
} }
std::unique_ptr<Entry> FileSystem::ResolvePath(const std::string& path) { std::unique_ptr<Entry> VirtualFileSystem::ResolvePath(const std::string& path) {
// Resolve relative paths // Resolve relative paths
std::string normalized_path(xe::fs::CanonicalizePath(path)); std::string normalized_path(xe::filesystem::CanonicalizePath(path));
// Resolve symlinks. // Resolve symlinks.
std::string device_path; std::string device_path;
@@ -192,9 +191,9 @@ std::unique_ptr<Entry> FileSystem::ResolvePath(const std::string& path) {
return nullptr; return nullptr;
} }
X_STATUS FileSystem::Open(std::unique_ptr<Entry> entry, X_STATUS VirtualFileSystem::Open(std::unique_ptr<Entry> entry,
KernelState* kernel_state, Mode mode, bool async, KernelState* kernel_state, Mode mode,
XFile** out_file) { bool async, XFile** out_file) {
auto result = entry->Open(kernel_state, mode, async, out_file); auto result = entry->Open(kernel_state, mode, async, out_file);
if (XSUCCEEDED(result)) { if (XSUCCEEDED(result)) {
entry.release(); entry.release();
@@ -202,6 +201,5 @@ X_STATUS FileSystem::Open(std::unique_ptr<Entry> entry,
return result; return result;
} }
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe

20
src/xenia/kernel/fs/filesystem.h → src/xenia/vfs/virtual_file_system.h
View File

@@ -7,19 +7,18 @@
****************************************************************************** ******************************************************************************
*/ */
#ifndef XENIA_KERNEL_FS_FILESYSTEM_H_ #ifndef XENIA_VFS_VIRTUAL_FILE_SYSTEM_H_
#define XENIA_KERNEL_FS_FILESYSTEM_H_ #define XENIA_VFS_VIRTUAL_FILE_SYSTEM_H_
#include <memory> #include <memory>
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#include "xenia/kernel/fs/entry.h" #include "xenia/vfs/entry.h"
namespace xe { namespace xe {
namespace kernel { namespace vfs {
namespace fs {
class Device; class Device;
@@ -29,10 +28,10 @@ enum class FileSystemType {
XEX_FILE, XEX_FILE,
}; };
class FileSystem { class VirtualFileSystem {
public: public:
FileSystem(); VirtualFileSystem();
~FileSystem(); ~VirtualFileSystem();
FileSystemType InferType(const std::wstring& local_path); FileSystemType InferType(const std::wstring& local_path);
int InitializeFromPath(FileSystemType type, const std::wstring& local_path); int InitializeFromPath(FileSystemType type, const std::wstring& local_path);
@@ -57,8 +56,7 @@ class FileSystem {
std::unordered_map<std::string, std::string> symlinks_; std::unordered_map<std::string, std::string> symlinks_;
}; };
} // namespace fs } // namespace vfs
} // namespace kernel
} // namespace xe } // namespace xe
#endif // XENIA_KERNEL_FS_FILESYSTEM_H_ #endif // XENIA_VFS_VIRTUAL_FILE_SYSTEM_H_