Atmosphere/stratosphere/dmnt/source/dmnt_service_target_io.cpp

267 lines
8.9 KiB
C++
Raw Normal View History

/*
2019-04-08 02:00:49 +00:00
* Copyright (c) 2018-2019 Atmosphère-NX
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope 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 for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
2019-06-20 05:19:53 +00:00
#include <unordered_map>
#include "dmnt_service.hpp"
2019-10-18 04:18:27 +00:00
namespace std {
template<>
struct hash<sts::dmnt::TargetIOFileHandle> {
u64 operator()(sts::dmnt::TargetIOFileHandle const &handle) const noexcept {
return handle.GetValue();
}
};
}
2019-09-16 08:22:08 +00:00
namespace sts::dmnt {
2019-06-20 05:19:53 +00:00
2019-09-16 08:22:08 +00:00
namespace {
2019-09-16 08:22:08 +00:00
enum TIOCreateOption : u32 {
TIOCreateOption_CreateNew = 1,
TIOCreateOption_CreateAlways = 2,
TIOCreateOption_OpenExisting = 3,
TIOCreateOption_OpenAlways = 4,
TIOCreateOption_ResetSize = 5,
};
2019-06-20 05:19:53 +00:00
2019-09-16 08:22:08 +00:00
/* Nintendo uses actual pointers as file handles. We'll add a layer of indirection... */
bool g_sd_initialized = false;
2019-09-24 10:15:36 +00:00
os::Mutex g_sd_lock;
2019-09-16 08:22:08 +00:00
FsFileSystem g_sd_fs;
2019-09-24 10:15:36 +00:00
os::Mutex g_file_handle_lock;
2019-09-16 08:22:08 +00:00
u64 g_cur_fd;
2019-10-18 04:18:27 +00:00
std::unordered_map<TargetIOFileHandle, FsFile> g_file_handles;
2019-06-20 05:19:53 +00:00
2019-09-16 08:22:08 +00:00
Result EnsureSdInitialized() {
2019-09-24 10:15:36 +00:00
std::scoped_lock lk(g_sd_lock);
2019-09-16 08:22:08 +00:00
if (g_sd_initialized) {
return ResultSuccess;
}
R_TRY(fsOpenSdCardFileSystem(&g_sd_fs));
2019-09-16 08:22:08 +00:00
g_sd_initialized = true;
return ResultSuccess;
}
2019-06-20 05:19:53 +00:00
2019-10-18 04:18:27 +00:00
TargetIOFileHandle GetNewFileHandle(FsFile f) {
2019-09-24 10:15:36 +00:00
std::scoped_lock lk(g_file_handle_lock);
2019-06-20 05:19:53 +00:00
2019-10-18 04:18:27 +00:00
TargetIOFileHandle fd = { .value = g_cur_fd++ };
2019-09-16 08:22:08 +00:00
g_file_handles[fd] = f;
return fd;
}
2019-10-18 04:18:27 +00:00
Result GetFileByHandle(FsFile *out, TargetIOFileHandle handle) {
2019-09-24 10:15:36 +00:00
std::scoped_lock lk(g_file_handle_lock);
2019-06-20 05:19:53 +00:00
2019-09-16 08:22:08 +00:00
if (g_file_handles.find(handle) != g_file_handles.end()) {
*out = g_file_handles[handle];
return ResultSuccess;
}
2019-06-20 05:19:53 +00:00
2019-09-16 08:22:08 +00:00
return ResultFsInvalidArgument;
}
2019-06-20 05:19:53 +00:00
2019-10-18 04:18:27 +00:00
Result CloseFileByHandle(TargetIOFileHandle handle) {
2019-09-24 10:15:36 +00:00
std::scoped_lock lk(g_file_handle_lock);
2019-06-20 05:19:53 +00:00
2019-09-16 08:22:08 +00:00
if (g_file_handles.find(handle) != g_file_handles.end()) {
fsFileClose(&g_file_handles[handle]);
g_file_handles.erase(handle);
return ResultSuccess;
}
2019-09-16 08:22:08 +00:00
return ResultFsInvalidArgument;
}
2019-06-20 05:19:53 +00:00
2019-10-18 04:18:27 +00:00
void FixPath(char *dst, size_t dst_size, const sf::InBuffer &path) {
2019-09-16 08:22:08 +00:00
dst[dst_size - 1] = 0;
strncpy(dst, "/", dst_size - 1);
2019-10-18 04:18:27 +00:00
const char *src = reinterpret_cast<const char *>(path.GetPointer());
2019-09-16 08:22:08 +00:00
size_t src_idx = 0;
size_t dst_idx = 1;
2019-10-18 04:18:27 +00:00
while (src_idx < path.GetSize() && (src[src_idx] == '/' || src[src_idx] == '\\')) {
2019-09-16 08:22:08 +00:00
src_idx++;
}
2019-10-18 04:18:27 +00:00
while (src_idx < path.GetSize() && dst_idx < dst_size - 1 && src[src_idx] != 0) {
2019-09-16 08:22:08 +00:00
if (src[src_idx] == '\\') {
dst[dst_idx] = '/';
} else {
dst[dst_idx] = src[src_idx];
}
src_idx++;
dst_idx++;
}
if (dst_idx < dst_size) {
dst[dst_idx] = 0;
}
}
2019-06-20 05:19:53 +00:00
}
2019-06-20 05:19:53 +00:00
2019-10-18 04:18:27 +00:00
Result DebugMonitorService::TargetIO_FileOpen(sf::Out<TargetIOFileHandle> out_hnd, const sf::InBuffer &path, int open_mode, u32 create_mode) {
2019-09-16 08:22:08 +00:00
R_TRY(EnsureSdInitialized());
2019-06-20 05:19:53 +00:00
2019-09-16 08:22:08 +00:00
char fs_path[FS_MAX_PATH];
FixPath(fs_path, sizeof(fs_path), path);
2019-06-20 05:19:53 +00:00
2019-09-16 08:22:08 +00:00
/* Create file as required by mode. */
if (create_mode == TIOCreateOption_CreateAlways) {
fsFsDeleteFile(&g_sd_fs, fs_path);
R_TRY(fsFsCreateFile(&g_sd_fs, fs_path, 0, 0));
} else if (create_mode == TIOCreateOption_CreateNew) {
R_TRY(fsFsCreateFile(&g_sd_fs, fs_path, 0, 0));
} else if (create_mode == TIOCreateOption_OpenAlways) {
fsFsCreateFile(&g_sd_fs, fs_path, 0, 0);
}
2019-09-16 08:22:08 +00:00
/* Open the file, guard to prevent failure to close. */
FsFile f;
R_TRY(fsFsOpenFile(&g_sd_fs, fs_path, open_mode, &f));
auto file_guard = SCOPE_GUARD {
fsFileClose(&f);
};
/* Set size if needed. */
if (create_mode == TIOCreateOption_ResetSize) {
R_TRY(fsFileSetSize(&f, 0));
}
/* Cancel guard, output file handle. */
file_guard.Cancel();
2019-10-18 04:18:27 +00:00
out_hnd.SetValue(GetNewFileHandle(f));
2019-09-16 08:22:08 +00:00
return ResultSuccess;
}
2019-06-20 05:19:53 +00:00
2019-10-18 04:18:27 +00:00
Result DebugMonitorService::TargetIO_FileClose(TargetIOFileHandle hnd) {
return CloseFileByHandle(hnd);
}
2019-06-20 05:19:53 +00:00
2019-10-18 04:18:27 +00:00
Result DebugMonitorService::TargetIO_FileRead(TargetIOFileHandle hnd, const sf::OutNonSecureBuffer &out_data, sf::Out<u32> out_read, u64 offset) {
2019-09-16 08:22:08 +00:00
FsFile f;
size_t read = 0;
2019-06-20 05:19:53 +00:00
2019-10-18 04:18:27 +00:00
R_TRY(GetFileByHandle(&f, hnd));
R_TRY(fsFileRead(&f, offset, out_data.GetPointer(), out_data.GetSize(), FsReadOption_None, &read));
2019-09-16 08:22:08 +00:00
out_read.SetValue(static_cast<u32>(read));
return ResultSuccess;
}
2019-06-20 05:19:53 +00:00
2019-10-18 04:18:27 +00:00
Result DebugMonitorService::TargetIO_FileWrite(TargetIOFileHandle hnd, const sf::InNonSecureBuffer &data, sf::Out<u32> out_written, u64 offset) {
2019-09-16 08:22:08 +00:00
FsFile f;
2019-06-20 05:19:53 +00:00
2019-10-18 04:18:27 +00:00
R_TRY(GetFileByHandle(&f, hnd));
R_TRY(fsFileWrite(&f, offset, data.GetPointer(), data.GetSize(), FsWriteOption_None));
2019-10-18 04:18:27 +00:00
out_written.SetValue(data.GetSize());
2019-09-16 08:22:08 +00:00
return ResultSuccess;
}
2019-10-18 04:18:27 +00:00
Result DebugMonitorService::TargetIO_FileSetAttributes(const sf::InBuffer &path, const sf::InBuffer &attributes) {
2019-09-16 08:22:08 +00:00
/* I don't really know why this command exists, Horizon doesn't allow you to set any attributes. */
/* N just returns ResultSuccess unconditionally here. */
return ResultSuccess;
}
2019-06-20 05:19:53 +00:00
2019-10-18 04:18:27 +00:00
Result DebugMonitorService::TargetIO_FileGetInformation(const sf::InBuffer &path, const sf::OutArray<u64> &out_info, sf::Out<int> is_directory) {
2019-09-16 08:22:08 +00:00
R_TRY(EnsureSdInitialized());
2019-06-20 05:19:53 +00:00
2019-09-16 08:22:08 +00:00
char fs_path[FS_MAX_PATH];
FixPath(fs_path, sizeof(fs_path), path);
2019-06-20 05:19:53 +00:00
2019-10-18 04:18:27 +00:00
for (size_t i = 0; i < out_info.GetSize(); i++) {
2019-09-16 08:22:08 +00:00
out_info[i] = 0;
}
is_directory.SetValue(0);
2019-06-20 05:19:53 +00:00
2019-09-16 08:22:08 +00:00
FsFile f;
2019-10-18 04:18:27 +00:00
if (R_SUCCEEDED(fsFsOpenFile(&g_sd_fs, fs_path, FsOpenMode_Read, &f))) {
2019-09-16 08:22:08 +00:00
ON_SCOPE_EXIT { fsFileClose(&f); };
2019-06-20 05:19:53 +00:00
2019-09-16 08:22:08 +00:00
/* N doesn't check this return code. */
2019-10-18 04:18:27 +00:00
if (out_info.GetSize() > 0) {
fsFileGetSize(&f, &out_info[0]);
}
2019-06-20 05:19:53 +00:00
2019-09-16 08:22:08 +00:00
/* TODO: N does not call fsFsGetFileTimestampRaw here, but we possibly could. */
} else {
FsDir dir;
2019-10-18 04:18:27 +00:00
R_TRY(fsFsOpenDirectory(&g_sd_fs, fs_path, FsDirOpenMode_ReadFiles | FsDirOpenMode_ReadDirs, &dir));
2019-09-16 08:22:08 +00:00
fsDirClose(&dir);
is_directory.SetValue(1);
}
2019-09-16 08:22:08 +00:00
return ResultSuccess;
}
2019-10-18 04:18:27 +00:00
Result DebugMonitorService::TargetIO_FileSetTime(const sf::InBuffer &path, u64 create, u64 access, u64 modify) {
2019-09-16 08:22:08 +00:00
/* This is another function that doesn't really need to exist, because Horizon doesn't let you set anything. */
return ResultSuccess;
}
2019-06-20 05:19:53 +00:00
2019-10-18 04:18:27 +00:00
Result DebugMonitorService::TargetIO_FileSetSize(const sf::InBuffer &input, u64 size) {
2019-09-16 08:22:08 +00:00
/* Why does this function take in a path and not a file handle? */
2019-10-18 04:18:27 +00:00
R_TRY(EnsureSdInitialized());
2019-09-16 08:22:08 +00:00
/* We will try to be better than N, here. N only treats input as a path. */
2019-10-18 04:18:27 +00:00
FsFile f;
if (input.GetSize() == sizeof(TargetIOFileHandle)) {
if (R_SUCCEEDED(GetFileByHandle(&f, *reinterpret_cast<const TargetIOFileHandle *>(input.GetPointer())))) {
2019-09-16 08:22:08 +00:00
return fsFileSetSize(&f, size);
}
}
2019-06-20 05:19:53 +00:00
2019-09-16 08:22:08 +00:00
char fs_path[FS_MAX_PATH];
FixPath(fs_path, sizeof(fs_path), input);
2019-06-20 05:19:53 +00:00
2019-10-18 04:18:27 +00:00
R_TRY(fsFsOpenFile(&g_sd_fs, fs_path, FsOpenMode_Write, &f));
2019-09-16 08:22:08 +00:00
ON_SCOPE_EXIT { fsFileClose(&f); };
2019-06-20 05:19:53 +00:00
2019-09-16 08:22:08 +00:00
return fsFileSetSize(&f, size);
}
2019-10-18 04:18:27 +00:00
Result DebugMonitorService::TargetIO_FileDelete(const sf::InBuffer &path) {
2019-09-16 08:22:08 +00:00
R_TRY(EnsureSdInitialized());
2019-06-20 05:19:53 +00:00
2019-09-16 08:22:08 +00:00
char fs_path[FS_MAX_PATH];
FixPath(fs_path, sizeof(fs_path), path);
2019-06-20 05:19:53 +00:00
2019-09-16 08:22:08 +00:00
return fsFsDeleteFile(&g_sd_fs, fs_path);
}
2019-10-18 04:18:27 +00:00
Result DebugMonitorService::TargetIO_FileMove(const sf::InBuffer &src_path, const sf::InBuffer &dst_path) {
2019-09-16 08:22:08 +00:00
R_TRY(EnsureSdInitialized());
2019-06-20 05:19:53 +00:00
2019-10-18 04:18:27 +00:00
char fs_src_path[FS_MAX_PATH];
char fs_dst_path[FS_MAX_PATH];
FixPath(fs_src_path, sizeof(fs_src_path), src_path);
FixPath(fs_dst_path, sizeof(fs_dst_path), dst_path);
2019-09-16 08:22:08 +00:00
2019-10-18 04:18:27 +00:00
return fsFsRenameFile(&g_sd_fs, fs_src_path, fs_dst_path);
2019-09-16 08:22:08 +00:00
}
2019-06-20 05:19:53 +00:00
}