disable hdd->hdd threading. only open log write on write to allow for reads. log fw/ams version.

hdd->hdd threading is disabled due to a bug in libusbhsfs which causes a deadlock if 2 fs calls happen at the same time.

sphaira/include/fs.hpp

@@ -12,10 +12,14 @@ namespace fs {
 
 struct FsPath {
     FsPath() = default;
-    constexpr FsPath(const auto& str) { From(str); }
+
+    constexpr FsPath(const FsPath& p) { From(p); }
+    constexpr FsPath(const char* str) { From(str); }
+    constexpr FsPath(const std::string& str) { From(str); }
+    constexpr FsPath(const std::string_view& str) { From(str); }
 
     constexpr void From(const FsPath& p) {
-        *this = p;
+        From(p.s);
     }
 
     constexpr void From(const char* str) {
@@ -40,6 +44,10 @@ struct FsPath {
         return s;
     }
 
+    constexpr auto starts_with(std::string_view str) const -> bool {
+        return !strncasecmp(s, str.data(), str.length());
+    }
+
     constexpr auto empty() const {
         return s[0] == '\0';
     }
@@ -65,6 +73,11 @@ struct FsPath {
     constexpr char& operator[](std::size_t idx) { return s[idx]; }
     constexpr const char& operator[](std::size_t idx) const { return s[idx]; }
 
+    constexpr FsPath& operator=(const FsPath& p) noexcept {
+        From(p.s);
+        return *this;
+    }
+
     constexpr FsPath operator+(const FsPath& v) const noexcept {
         FsPath r{*this};
         return r += v;
@@ -186,9 +199,6 @@ struct File {
     FsFile m_native{};
     std::FILE* m_stdio{};
     s64 m_stdio_off{};
-    // sadly, fatfs doesn't support fstat, so we have to manually
-    // stat the file to get it's size.
-    FsPath m_path{};
 };
 
 struct Dir {

sphaira/include/log.hpp

@@ -12,6 +12,8 @@ extern "C" {
 bool log_file_init();
 bool log_nxlink_init();
 void log_file_exit();
+bool log_is_init();
+
 void log_nxlink_exit();
 void log_write(const char* s, ...) __attribute__ ((format (printf, 1, 2)));
 void log_write_arg(const char* s, va_list* v);

sphaira/include/threaded_file_transfer.hpp

@@ -40,17 +40,17 @@ Result TransferPull(ui::ProgressBox* pbox, s64 size, ReadCallback rfunc, StartCa
 
 // helper for extract zips.
 // this will multi-thread unzip if size >= 512KiB, otherwise it'll single pass.
-Result TransferUnzip(ui::ProgressBox* pbox, void* zfile, fs::Fs* fs, const fs::FsPath& path, s64 size, u32 crc32 = 0);
+Result TransferUnzip(ui::ProgressBox* pbox, void* zfile, fs::Fs* fs, const fs::FsPath& path, s64 size, u32 crc32 = 0, Mode mode = Mode::SingleThreadedIfSmaller);
 
 // same as above but for zipping files.
-Result TransferZip(ui::ProgressBox* pbox, void* zfile, fs::Fs* fs, const fs::FsPath& path, u32* crc32 = nullptr);
+Result TransferZip(ui::ProgressBox* pbox, void* zfile, fs::Fs* fs, const fs::FsPath& path, u32* crc32 = nullptr, Mode mode = Mode::SingleThreadedIfSmaller);
 
 // passes the name inside the zip an final output path.
 using UnzipAllFilter = std::function<bool(const fs::FsPath& name, fs::FsPath& path)>;
 
 // helper all-in-one unzip function that unzips a zip (either open or path provided).
 // the filter function can be used to modify the path and filter out unwanted files.
-Result TransferUnzipAll(ui::ProgressBox* pbox, void* zfile, fs::Fs* fs, const fs::FsPath& base_path, UnzipAllFilter filter = nullptr);
-Result TransferUnzipAll(ui::ProgressBox* pbox, const fs::FsPath& zip_out, fs::Fs* fs, const fs::FsPath& base_path, UnzipAllFilter filter = nullptr);
+Result TransferUnzipAll(ui::ProgressBox* pbox, void* zfile, fs::Fs* fs, const fs::FsPath& base_path, UnzipAllFilter filter = nullptr, Mode mode = Mode::SingleThreadedIfSmaller);
+Result TransferUnzipAll(ui::ProgressBox* pbox, const fs::FsPath& zip_out, fs::Fs* fs, const fs::FsPath& base_path, UnzipAllFilter filter = nullptr, Mode mode = Mode::SingleThreadedIfSmaller);
 
 } // namespace sphaira::thread

sphaira/include/ui/progress_box.hpp

@@ -39,9 +39,9 @@ struct ProgressBox final : Widget {
     auto ShouldExitResult() -> Result;
 
     // helper functions
-    auto CopyFile(fs::Fs* fs_src, fs::Fs* fs_dst, const fs::FsPath& src, const fs::FsPath& dst) -> Result;
-    auto CopyFile(fs::Fs* fs, const fs::FsPath& src, const fs::FsPath& dst) -> Result;
-    auto CopyFile(const fs::FsPath& src, const fs::FsPath& dst) -> Result;
+    auto CopyFile(fs::Fs* fs_src, fs::Fs* fs_dst, const fs::FsPath& src, const fs::FsPath& dst, bool single_threaded = false) -> Result;
+    auto CopyFile(fs::Fs* fs, const fs::FsPath& src, const fs::FsPath& dst, bool single_threaded = false) -> Result;
+    auto CopyFile(const fs::FsPath& src, const fs::FsPath& dst, bool single_threaded = false) -> Result;
     void Yield();
 
     auto GetCpuId() const {