LV2/FS: Implement timeless file time

rpcs3/Emu/Cell/lv2/sys_fs.cpp

@@ -13,6 +13,7 @@
 #include "Emu/IdManager.h"
 #include "Emu/system_utils.hpp"
 #include "Emu/Cell/lv2/sys_process.h"
+#include "Emu/associative_map_file.h"
 
 #include <span>
 
@@ -121,6 +122,120 @@ bool verify_mself(const fs::file& mself_file)
 	return true;
 }
 
+void init_fxo_vfs();
+
+struct lv2_file_alternative_timestamps
+{
+	std::map<std::string, associative_map_file, std::less<>> m_map;
+
+	shared_mutex m_mutex;
+
+	lv2_file_alternative_timestamps() noexcept
+	{
+		init_fxo_vfs();
+		g_fxo->init<lv2_fs_mount_info_map>();
+	}
+
+	struct file_times
+	{
+		s64 atime;
+		s64 mtime;
+	};
+
+	static constexpr std::string_view s_version = "1";
+
+	std::pair<bool, file_times> get_times(std::string_view filename)
+	{
+		if (filename.empty())
+		{
+			return {};
+		}
+
+		auto [mp_times, file_key] = get_keys(filename);
+
+		if (!mp_times)
+		{
+			return {};
+		}
+
+		file_times times{};
+
+		const std::string data = mp_times->get_entry(file_key);
+
+		usz a_index = data.find("atime: "sv);
+		usz m_index = data.find("mtime: "sv);
+
+		if (a_index != umax)
+		{
+			if (std::from_chars(data.data() + a_index + std::size("atime: "sv), data.data() + data.size(), times.atime).ec != std::errc())
+			{
+				return {};
+			}
+		}
+
+		if (m_index != umax)
+		{
+			if (std::from_chars(data.data() + m_index + std::size("mtime: "sv), data.data() + data.size(), times.mtime).ec != std::errc())
+			{
+				return {};
+			}
+		}
+
+		times.ctime = file_times.mtime;
+		return {true, times};
+	}
+
+	bool set_times(std::string_view filename, file_times times)
+	{
+		if (filename.empty())
+		{
+			return false;
+		}
+
+		const auto [mp_times, file_key] = get_keys(filename);
+
+		if (!mp_times)
+		{
+			return false;
+		}
+
+		mp_times->set_entry(file_key, fmt::format("version: %s, mtime: %d, atime: %d.", s_version, times.mtime, times.atime));
+		return true;
+	}
+
+	std::pair<associative_map_file*, std::string> get_keys(std::string view filename) const
+	{
+		std::string root = lv2_fs_object::get_device_root(filename);
+		std::string vfs_root = vfs::get(root);
+
+		if (!m_map.contains(vfs_root))
+		{
+			m_map.emplace(vfs_root, associative_map_file(vfs_root + u8"/＄vfs-data"));
+		}
+
+		return {&m_map.at(vfs_root), "file-timestamp-" + vfs::get(filename).substr(vfs_root.size())};
+	}
+
+	bool move_times(std::string_view source, std::string_view dest)
+	{
+		const auto [mp_times_source, file_key_sorce] = get_keys(source);
+		const auto [mp_times_dest, file_key_dest] = get_keys(filename);
+
+		if (mp_times_dest != mp_times_source)
+		{
+			return false;
+		}
+
+		return mp_times_source->move_entries_with_prefix(source, dest);
+	}
+
+	bool remove_times(std::string_view filename)
+	{
+		const auto [mp_times, file_key] = get_keys(filename);
+		return mp_times->remove_entry(file_key);
+	}
+};
+
 lv2_fs_mount_info_map::lv2_fs_mount_info_map()
 {
 	for (auto mp = &g_mp_sys_dev_root; mp; mp = mp->next) // Scan and keep track of pre-mounted devices
@@ -838,6 +953,11 @@ lv2_file::open_raw_result_t lv2_file::open_raw(const std::string& local_path, s3
 		return {CELL_EIO};
 	}
 
+	if (open_mode & fs::trunc)
+	{
+		g_fxo->get<lv2_file_alternative_timestamps>().remove_times(vfs::retrieve(local_path));
+	}
+
 	if (flags & CELL_FS_O_MSELF && !verify_mself(file))
 	{
 		return {CELL_ENOTMSELF};
@@ -1059,6 +1179,13 @@ error_code sys_fs_read(ppu_thread& ppu, u32 fd, vm::ptr<void> buf, u64 nbytes, v
 
 	const u64 read_bytes = file->op_read(buf, nbytes);
 	const bool failure = !read_bytes && file->file.pos() < file->file.size();
+
+	if (read_bytes)
+	{
+		// TODO: Remove only atime
+		g_fxo->get<lv2_file_alternative_timestamps>().remove_times(vfs::retrieve(file->real_path));
+	}
+
 	lock.unlock();
 	ppu.check_state();
 
@@ -1149,6 +1276,12 @@ error_code sys_fs_write(ppu_thread& ppu, u32 fd, vm::cptr<void> buf, u64 nbytes,
 	}
 
 	const u64 written = file->op_write(buf, nbytes);
+
+	if (written)
+	{
+		g_fxo->get<lv2_file_alternative_timestamps>().remove_times(vfs::retrieve(file->real_path));
+	}
+
 	lock.unlock();
 	ppu.check_state();
 
@@ -1310,6 +1443,16 @@ error_code sys_fs_opendir(ppu_thread& ppu, vm::cptr<char> path, vm::ptr<u32> fd)
 				continue;
 			}
 
+			if (!mp.read_only)
+			{
+				if (auto [ok, times] = g_fxo->get<lv2_file_alternative_timestamps>().get_times(std::string(vpath) + "/" + data.back().name); ok)
+				{
+					data.back().atime = times.atime;
+					data.back().mtime = times.mtime;
+					data.back().ctime = times.mtime;
+				}
+			}
+
 			// Add additional entries for split file candidates (while ends with .66600)
 			while (data.back().name.ends_with(".66600"))
 			{
@@ -1504,6 +1647,16 @@ error_code sys_fs_stat(ppu_thread& ppu, vm::cptr<char> path, vm::ptr<CellFsStat>
 		}
 	}
 
+	if (!mp.read_only)
+	{
+		if (auto [ok, times] = g_fxo->get<lv2_file_alternative_timestamps>().get_times(vpath); ok)
+		{
+			info.atime = times.atime;
+			info.mtime = times.mtime;
+			info.ctime = times.mtime;
+		}
+	}
+
 	lock.unlock();
 	ppu.check_state();
 
@@ -1553,7 +1706,18 @@ error_code sys_fs_fstat(ppu_thread& ppu, u32 fd, vm::ptr<CellFsStat> sb)
 		return CELL_EIO;
 	}
 
-	const fs::stat_t info = file->file.stat();
+	fs::stat_t info = file->file.stat();
+
+	if (!mp.read_only)
+	{
+		if (auto [ok, times] = g_fxo->get<lv2_file_alternative_timestamps>().get_times(vfs::retrieve(vpath)); ok)
+		{
+			info.atime = times.atime;
+			info.mtime = times.mtime;
+			info.ctime = times.mtime;
+		}
+	}
+
 	lock.unlock();
 	ppu.check_state();
 
@@ -1687,10 +1851,9 @@ error_code sys_fs_rename(ppu_thread& ppu, vm::cptr<char> from, vm::cptr<char> to
 		return CELL_EROFS;
 	}
 
-	// Done in vfs::host::rename
-	//std::lock_guard lock(mp->mutex);
+	std::lock_guard lock(mp->mutex);
 
-	if (!vfs::host::rename(local_from, local_to, mp.mp, false))
+	if (!vfs::host::rename(local_from, local_to, mp.mp, false, false))
 	{
 		switch (auto error = fs::g_tls_error)
 		{
@@ -1702,6 +1865,8 @@ error_code sys_fs_rename(ppu_thread& ppu, vm::cptr<char> from, vm::cptr<char> to
 		return {CELL_EIO, from}; // ???
 	}
 
+	g_fxo->get<lv2_file_alternative_timestamps>().move_times(from, to);
+
 	sys_fs.notice("sys_fs_rename(): %s renamed to %s", from, to);
 	return CELL_OK;
 }
@@ -1753,6 +1918,8 @@ error_code sys_fs_rmdir(ppu_thread& ppu, vm::cptr<char> path)
 		return {CELL_EIO, path}; // ???
 	}
 
+	g_fxo->get<lv2_file_alternative_timestamps>().remove_times(vpath);
+
 	sys_fs.notice("sys_fs_rmdir(): directory %s removed", path);
 	return CELL_OK;
 }
@@ -1812,6 +1979,8 @@ error_code sys_fs_unlink(ppu_thread& ppu, vm::cptr<char> path)
 		return {CELL_EIO, path}; // ???
 	}
 
+	ensure(g_fxo->get<lv2_file_alternative_timestamps>().remove_times(vpath));
+
 	sys_fs.notice("sys_fs_unlink(): file %s deleted", path);
 	return CELL_OK;
 }
@@ -1926,6 +2095,11 @@ error_code sys_fs_fcntl(ppu_thread& ppu, u32 fd, u32 op, vm::ptr<void> _arg, u32
 			? file->op_read(arg->buf, arg->size)
 			: file->op_write(arg->buf, arg->size);
 
+		if (!file->mp.read_only && arg->out_size)
+		{
+			g_fxo->get<lv2_file_alternative_timestamps>().remove_times(vfs::retrieve(file->real_path));
+		}
+
 		ensure(old_pos == file->file.seek(old_pos));
 
 		// TODO: EDATA corruption detection
@@ -2747,6 +2921,8 @@ error_code sys_fs_ftruncate(ppu_thread& ppu, u32 fd, u64 size)
 		return CELL_EIO; // ???
 	}
 
+	g_fxo->get<lv2_file_alternative_timestamps>().remove_times(vfs::retrieve(file->real_path));
+
 	return CELL_OK;
 }
 
@@ -2884,22 +3060,25 @@ error_code sys_fs_utime(ppu_thread& ppu, vm::cptr<char> path, vm::cptr<CellFsUti
 		return {CELL_EROFS, path};
 	}
 
+	const s64 actime = timep->actime;
+	const s64 modtime = timep->modtime;
+
 	std::lock_guard lock(mp->mutex);
 
-	if (!fs::utime(local_path, timep->actime, timep->modtime))
+	// Not actually required to succeed
+	if (fs::utime(local_path, actime, modtime))
 	{
-		switch (auto error = fs::g_tls_error)
-		{
-		case fs::error::noent:
-		{
-			return {mp == &g_mp_sys_dev_hdd1 ? sys_fs.warning : sys_fs.error, CELL_ENOENT, path};
-		}
-		default: sys_fs.error("sys_fs_utime(): unknown error %s", error);
-		}
+		g_fxo->get<lv2_file_alternative_timestamps>().remove_times(vpath);
+		return CELL_OK;
+	}
 
-		return {CELL_EIO, path}; // ???
+	if (!fs::exists(local_path))
+	{
+		return {mp == &g_mp_sys_dev_hdd1 ? sys_fs.warning : sys_fs.erro, CELL_ENOENT, path};
 	}
 
+	ensure(g_fxo->get<lv2_file_alternative_timestamps>().set_times(vpath, {.atime = actime, .mtime =  modtime}));
+
 	return CELL_OK;
 }
 

rpcs3/Emu/VFS.cpp

@@ -35,6 +35,11 @@ struct vfs_manager
 	SAVESTATE_INIT_POS(48);
 };
 
+extern void init_fxo_vfs()
+{
+	g_fxo->need<vfs_manager>();
+}
+
 bool vfs::mount(std::string_view vpath, std::string_view path, bool is_dir)
 {
 	if (vpath.empty())
@@ -927,13 +932,16 @@ std::string vfs::host::hash_path(const std::string& path, const std::string& dev
 	return fmt::format(u8"%s/＄%s%s", dev_root, fmt::base57(std::hash<std::string>()(path)), fmt::base57(utils::get_unique_tsc()));
 }
 
-bool vfs::host::rename(const std::string& from, const std::string& to, const lv2_fs_mount_point* mp, bool overwrite)
+bool vfs::host::rename(const std::string& from, const std::string& to, const lv2_fs_mount_point* mp, bool overwrite, bool unlocked) noexcept
 {
 	// Lock mount point, close file descriptors, retry
 	const auto from0 = std::string_view(from).substr(0, from.find_last_not_of(fs::delim) + 1);
 	const auto escaped_from = Emu.GetCallbacks().resolve_path(from);
 
-	std::lock_guard lock(mp->mutex);
+	if (!unlocked)
+	{
+		mp->mutex.lock();
+	}
 
 	auto check_path = [&](std::string_view path)
 	{
@@ -1007,6 +1015,11 @@ bool vfs::host::rename(const std::string& from, const std::string& to, const lv2
 		}
 	});
 
+	if (!unlocked)
+	{
+		mp->mutex.unlock();
+	}
+
 	fs::g_tls_error = fs_error;
 	return res;
 }

rpcs3/Emu/VFS.h

@@ -34,7 +34,7 @@ namespace vfs
 		std::string hash_path(const std::string& path, const std::string& dev_root);
 
 		// Call fs::rename with retry on access error
-		bool rename(const std::string& from, const std::string& to, const lv2_fs_mount_point* mp, bool overwrite);
+		bool rename(const std::string& from, const std::string& to, const lv2_fs_mount_point* mp, bool overwrite, bool unlocked = false);
 
 		// Delete file without deleting its contents, emulated with MoveFileEx on Windows
 		bool unlink(const std::string& path, const std::string& dev_root);