fs.mitm: Make accesses to Boot0 sectored

stratosphere/fs_mitm/source/fs_istorage.hpp

@@ -120,7 +120,7 @@ class ProxyStorage : public IStorage {
         ProxyStorage(FsStorage s) {
             this->base_storage = new FsStorage(s);
         };
-        ~ProxyStorage() {
+        virtual ~ProxyStorage() {
             fsStorageClose(base_storage);
             delete base_storage;
         };
@@ -155,7 +155,7 @@ class ROProxyStorage : public IROStorage {
         ROProxyStorage(FsStorage s) {
             this->base_storage = new FsStorage(s);
         };
-        ~ROProxyStorage() {
+        virtual ~ROProxyStorage() {
             fsStorageClose(base_storage);
             delete base_storage;
         };

stratosphere/fs_mitm/source/fsmitm_boot0storage.hpp

@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2018 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/>.
+ */
+ 
+#pragma once
+#include <switch.h>
+#include <stratosphere.hpp>
+
+#include "fs_istorage.hpp"
+
+/* Represents a sectored storage. */
+template<u64 SectorSize> 
+class SectoredProxyStorage : public ProxyStorage {
+    private:
+        u64 cur_seek = 0;
+        u64 cur_sector = 0;
+        u64 cur_sector_ofs = 0;
+        u8  sector_buf[SectorSize];
+    private:
+        void Seek(u64 offset) {
+            this->cur_sector_ofs = offset % SectorSize;
+            this->cur_seek = offset - this->cur_sector_ofs;
+        }
+    public:
+        SectoredProxyStorage(FsStorage *s) : ProxyStorage(s) { }
+        SectoredProxyStorage(FsStorage s) : ProxyStorage(s) { }
+    public:
+        virtual Result Read(void *_buffer, size_t size, u64 offset) override {
+            Result rc = 0;
+            u8 *buffer = static_cast<u8 *>(_buffer);
+            this->Seek(offset);
+            
+            if (R_FAILED((rc = ProxyStorage::Read(this->sector_buf, SectorSize, this->cur_seek)))) {
+                return rc;
+            }
+            
+            if (size + this->cur_sector_ofs <= SectorSize) {
+                memcpy(buffer, sector_buf + this->cur_sector_ofs, size);
+            } else {
+                /* Leaving the sector... */
+                size_t ofs = SectorSize - this->cur_sector_ofs;
+                memcpy(buffer, sector_buf + this->cur_sector_ofs, ofs);
+                size -= ofs;
+                
+                /* We're guaranteed alignment, here. */
+                const size_t aligned_remaining_size = size - (size % SectorSize);
+                if (aligned_remaining_size) {
+                    if (R_FAILED((rc = ProxyStorage::Read(buffer + ofs, aligned_remaining_size, offset + ofs)))) {
+                        return rc;
+                    }
+                    ofs += aligned_remaining_size;
+                    size -= aligned_remaining_size;
+                }
+                
+                /* Read any leftover data. */
+                if (size) {
+                    if (R_FAILED((rc = ProxyStorage::Read(this->sector_buf, SectorSize, offset + ofs)))) {
+                        return rc;
+                    }
+                    memcpy(buffer + ofs, sector_buf, size);
+                }
+            }
+            
+            return rc;
+        };
+        virtual Result Write(void *_buffer, size_t size, u64 offset) override {
+            Result rc = 0;
+            u8 *buffer = static_cast<u8 *>(_buffer);
+            this->Seek(offset);
+            
+            if (R_FAILED((rc = ProxyStorage::Read(this->sector_buf, SectorSize, this->cur_seek)))) {
+                return rc;
+            }
+            
+            
+            if (size + this->cur_sector_ofs <= SectorSize) {
+                memcpy(this->sector_buf + this->cur_sector_ofs, buffer, size);
+                rc = ProxyStorage::Write(this->sector_buf, SectorSize, this->cur_seek);
+            } else {
+                /* Leaving the sector... */
+                size_t ofs = SectorSize - this->cur_sector_ofs;
+                memcpy(this->sector_buf + this->cur_sector_ofs, buffer, ofs);
+                if (R_FAILED((rc = ProxyStorage::Write(this->sector_buf, ofs, this->cur_seek)))) {
+                    return rc;
+                }
+                size -= ofs;
+                
+                /* We're guaranteed alignment, here. */
+                const size_t aligned_remaining_size = size - (size % SectorSize);
+                if (aligned_remaining_size) {
+                    if (R_FAILED((rc = ProxyStorage::Write(buffer + ofs, aligned_remaining_size, offset + ofs)))) {
+                        return rc;
+                    }
+                    ofs += aligned_remaining_size;
+                    size -= aligned_remaining_size;
+                }
+                
+                /* Write any leftover data. */
+                if (size) {
+                    if (R_FAILED((rc = ProxyStorage::Read(this->sector_buf, SectorSize, offset + ofs)))) {
+                        return rc;
+                    }
+                    memcpy(this->sector_buf, buffer + ofs, size);
+                    rc = ProxyStorage::Write(this->sector_buf, SectorSize, this->cur_seek);
+                }
+            }     
+            
+            return rc;
+        };
+};
+
+/* Represents an RCM-preserving BOOT0 partition. */
+class Boot0Storage : public SectoredProxyStorage<0x200> {
+    using Base = SectoredProxyStorage<0x200>;
+    private:
+        bool allow_writes;
+    private:
+        HosMutex *GetMutex() {
+            static HosMutex s_boot0_mutex;
+            return &s_boot0_mutex;
+        }
+    public:
+        Boot0Storage(FsStorage *s, bool w) : Base(s), allow_writes(w) { }
+        Boot0Storage(FsStorage s, bool w) : Base(s), allow_writes(w) { }
+        
+    public:
+        virtual Result Read(void *_buffer, size_t size, u64 offset) override {
+            GetMutex()->Lock();
+            ON_SCOPE_EXIT { GetMutex()->Unlock(); };
+            
+            return Base::Read(_buffer, size, offset);
+        }
+        
+        virtual Result Write(void *_buffer, size_t size, u64 offset) override {
+            GetMutex()->Lock();
+            ON_SCOPE_EXIT { GetMutex()->Unlock(); };
+            
+            if (!this->allow_writes) {
+                return 0x313802;
+            }
+            
+            return Base::Write(_buffer, size, offset);
+        }
+};

stratosphere/fs_mitm/source/fsmitm_romstorage.hpp

@@ -31,7 +31,7 @@ class RomFileStorage : public IROStorage {
         RomFileStorage(FsFile f) {
             this->base_file = new FsFile(f);
         };
-        ~RomFileStorage() {
+        virtual ~RomFileStorage() {
             fsFileClose(base_file);
             delete base_file;
         };

stratosphere/fs_mitm/source/fsmitm_service.cpp

@@ -24,6 +24,7 @@
 #include "fs_shim.h"
 
 #include "fsmitm_utils.hpp"
+#include "fsmitm_boot0storage.hpp"
 #include "fsmitm_romstorage.hpp"
 #include "fsmitm_layeredrom.hpp"
 
@@ -98,12 +99,17 @@ Result FsMitmService::OpenBisStorage(Out<std::shared_ptr<IStorageInterface>> out
         FsStorage bis_storage;
         rc = fsOpenBisStorageFwd(this->forward_service.get(), &bis_storage, bis_partition_id);
         if (R_SUCCEEDED(rc)) {
-            if (this->title_id >= 0x0100000000001000) {
+            const bool allow_writes = this->title_id < 0x0100000000001000;
+            if (bis_partition_id == BisStorageId_Boot0) {
+                storage = std::make_shared<IStorageInterface>(new Boot0Storage(bis_storage, allow_writes));
+            } else {
+                if (allow_writes) {
                     storage = std::make_shared<IStorageInterface>(new ROProxyStorage(bis_storage));
                 } else {
                     /* Sysmodules should still be allowed to read and write. */
                     storage = std::make_shared<IStorageInterface>(new ProxyStorage(bis_storage));
                 }
+            }
             if (out_storage.IsDomain()) {
                 out_domain_id = bis_storage.s.object_id;
             }