early-access version 3246EA-3246

7 files changed, 80 insertions, 60 deletions

diff --git a/README.md b/README.md
index d7a3ffc75..8146450f6 100755
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 yuzu emulator early access
 =============
 
-This is the source code for early-access 3244.
+This is the source code for early-access 3246.
 
 ## Legal Notice
 
diff --git a/src/core/hle/kernel/k_shared_memory.cpp b/src/core/hle/kernel/k_shared_memory.cpp
index b1856381d..659368e8d 100755
--- a/src/core/hle/kernel/k_shared_memory.cpp
+++ b/src/core/hle/kernel/k_shared_memory.cpp
@@ -6,6 +6,7 @@
 #include "core/hle/kernel/k_page_table.h"

 #include "core/hle/kernel/k_scoped_resource_reservation.h"

 #include "core/hle/kernel/k_shared_memory.h"

+#include "core/hle/kernel/k_system_resource.h"

 #include "core/hle/kernel/kernel.h"

 #include "core/hle/kernel/svc_results.h"

 

@@ -18,19 +19,19 @@ KSharedMemory::~KSharedMemory() {
 }

 

 Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,

-                                 KPageGroup&& page_list_, Svc::MemoryPermission owner_permission_,

-                                 Svc::MemoryPermission user_permission_, PAddr physical_address_,

-                                 std::size_t size_, std::string name_) {

+                                 Svc::MemoryPermission owner_permission_,

+                                 Svc::MemoryPermission user_permission_, std::size_t size_,

+                                 std::string name_) {

     // Set members.

     owner_process = owner_process_;

     device_memory = &device_memory_;

-    page_list = std::move(page_list_);

     owner_permission = owner_permission_;

     user_permission = user_permission_;

-    physical_address = physical_address_;

-    size = size_;

+    size = Common::AlignUp(size_, PageSize);

     name = std::move(name_);

 

+    const size_t num_pages = Common::DivideUp(size, PageSize);

+

     // Get the resource limit.

     KResourceLimit* reslimit = kernel.GetSystemResourceLimit();

 

@@ -39,6 +40,17 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* o
                                                   size_);

     R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);

 

+    // Allocate the memory.

+

+    //! HACK: Open continuous mapping from sysmodule pool.

+    auto option = KMemoryManager::EncodeOption(KMemoryManager::Pool::Secure,

+                                               KMemoryManager::Direction::FromBack);

+    physical_address = kernel.MemoryManager().AllocateAndOpenContinuous(num_pages, 1, option);

+    R_UNLESS(physical_address != 0, ResultOutOfMemory);

+

+    //! Insert the result into our page group.

+    page_group.emplace(physical_address, num_pages);

+

     // Commit our reservation.

     memory_reservation.Commit();

 

@@ -50,12 +62,23 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* o
     is_initialized = true;

 

     // Clear all pages in the memory.

-    std::memset(device_memory_.GetPointer<void>(physical_address_), 0, size_);

+    for (const auto& block : page_group->Nodes()) {

+        std::memset(device_memory_.GetPointer<void>(block.GetAddress()), 0, block.GetSize());

+    }

 

     return ResultSuccess;

 }

 

 void KSharedMemory::Finalize() {

+    // Close and finalize the page group.

+    // page_group->Close();

+    // page_group->Finalize();

+

+    //! HACK: Manually close.

+    for (const auto& block : page_group->Nodes()) {

+        kernel.MemoryManager().Close(block.GetAddress(), block.GetNumPages());

+    }

+

     // Release the memory reservation.

     resource_limit->Release(LimitableResource::PhysicalMemoryMax, size);

     resource_limit->Close();

@@ -65,32 +88,28 @@ void KSharedMemory::Finalize() {
 }

 

 Result KSharedMemory::Map(KProcess& target_process, VAddr address, std::size_t map_size,

-                          Svc::MemoryPermission permissions) {

-    const u64 page_count{(map_size + PageSize - 1) / PageSize};

-

-    if (page_list.GetNumPages() != page_count) {

-        UNIMPLEMENTED_MSG("Page count does not match");

-    }

+                          Svc::MemoryPermission map_perm) {

+    // Validate the size.

+    R_UNLESS(size == map_size, ResultInvalidSize);

 

-    const Svc::MemoryPermission expected =

+    // Validate the permission.

+    const Svc::MemoryPermission test_perm =

         &target_process == owner_process ? owner_permission : user_permission;

-

-    if (permissions != expected) {

-        UNIMPLEMENTED_MSG("Permission does not match");

+    if (test_perm == Svc::MemoryPermission::DontCare) {

+        ASSERT(map_perm == Svc::MemoryPermission::Read || map_perm == Svc::MemoryPermission::Write);

+    } else {

+        R_UNLESS(map_perm == test_perm, ResultInvalidNewMemoryPermission);

     }

 

-    return target_process.PageTable().MapPages(address, page_list, KMemoryState::Shared,

-                                               ConvertToKMemoryPermission(permissions));

+    return target_process.PageTable().MapPages(address, *page_group, KMemoryState::Shared,

+                                               ConvertToKMemoryPermission(map_perm));

 }

 

 Result KSharedMemory::Unmap(KProcess& target_process, VAddr address, std::size_t unmap_size) {

-    const u64 page_count{(unmap_size + PageSize - 1) / PageSize};

-

-    if (page_list.GetNumPages() != page_count) {

-        UNIMPLEMENTED_MSG("Page count does not match");

-    }

+    // Validate the size.

+    R_UNLESS(size == unmap_size, ResultInvalidSize);

 

-    return target_process.PageTable().UnmapPages(address, page_list, KMemoryState::Shared);

+    return target_process.PageTable().UnmapPages(address, *page_group, KMemoryState::Shared);

 }

 

 } // namespace Kernel

diff --git a/src/core/hle/kernel/k_shared_memory.h b/src/core/hle/kernel/k_shared_memory.h
index de17fa449..9bed50530 100755
--- a/src/core/hle/kernel/k_shared_memory.h
+++ b/src/core/hle/kernel/k_shared_memory.h
@@ -3,6 +3,7 @@
 

 #pragma once

 

+#include <optional>

 #include <string>

 

 #include "common/common_types.h"

@@ -26,9 +27,8 @@ public:
     ~KSharedMemory() override;

 

     Result Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,

-                      KPageGroup&& page_list_, Svc::MemoryPermission owner_permission_,

-                      Svc::MemoryPermission user_permission_, PAddr physical_address_,

-                      std::size_t size_, std::string name_);

+                      Svc::MemoryPermission owner_permission_,

+                      Svc::MemoryPermission user_permission_, std::size_t size_, std::string name_);

 

     /**

      * Maps a shared memory block to an address in the target process' address space

@@ -76,7 +76,7 @@ public:
 private:

     Core::DeviceMemory* device_memory{};

     KProcess* owner_process{};

-    KPageGroup page_list;

+    std::optional<KPageGroup> page_group{};

     Svc::MemoryPermission owner_permission{};

     Svc::MemoryPermission user_permission{};

     PAddr physical_address{};

diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index 2fa9464e3..f4b716a31 100755
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -94,6 +94,7 @@ struct KernelCore::Impl {
                                        pt_heap_region.GetSize());

         }

 

+        InitializeHackSharedMemory();

         RegisterHostThread(nullptr);

 

         default_service_thread = &CreateServiceThread(kernel, "DefaultServiceThread");

@@ -726,14 +727,14 @@ struct KernelCore::Impl {
     }

 

     void InitializeMemoryLayout() {

-        const auto system_pool = memory_layout->GetKernelSystemPoolRegionPhysicalExtents();

-

         // Initialize the memory manager.

         memory_manager = std::make_unique<KMemoryManager>(system);

         const auto& management_region = memory_layout->GetPoolManagementRegion();

         ASSERT(management_region.GetEndAddress() != 0);

         memory_manager->Initialize(management_region.GetAddress(), management_region.GetSize());

+    }

 

+    void InitializeHackSharedMemory() {

         // Setup memory regions for emulated processes

         // TODO(bunnei): These should not be hardcoded regions initialized within the kernel

         constexpr std::size_t hid_size{0x40000};

@@ -742,39 +743,23 @@ struct KernelCore::Impl {
         constexpr std::size_t time_size{0x1000};

         constexpr std::size_t hidbus_size{0x1000};

 

-        const PAddr hid_phys_addr{system_pool.GetAddress()};

-        const PAddr font_phys_addr{system_pool.GetAddress() + hid_size};

-        const PAddr irs_phys_addr{system_pool.GetAddress() + hid_size + font_size};

-        const PAddr time_phys_addr{system_pool.GetAddress() + hid_size + font_size + irs_size};

-        const PAddr hidbus_phys_addr{system_pool.GetAddress() + hid_size + font_size + irs_size +

-                                     time_size};

-

         hid_shared_mem = KSharedMemory::Create(system.Kernel());

         font_shared_mem = KSharedMemory::Create(system.Kernel());

         irs_shared_mem = KSharedMemory::Create(system.Kernel());

         time_shared_mem = KSharedMemory::Create(system.Kernel());

         hidbus_shared_mem = KSharedMemory::Create(system.Kernel());

 

-        hid_shared_mem->Initialize(system.DeviceMemory(), nullptr,

-                                   {hid_phys_addr, hid_size / PageSize},

-                                   Svc::MemoryPermission::None, Svc::MemoryPermission::Read,

-                                   hid_phys_addr, hid_size, "HID:SharedMemory");

-        font_shared_mem->Initialize(system.DeviceMemory(), nullptr,

-                                    {font_phys_addr, font_size / PageSize},

-                                    Svc::MemoryPermission::None, Svc::MemoryPermission::Read,

-                                    font_phys_addr, font_size, "Font:SharedMemory");

-        irs_shared_mem->Initialize(system.DeviceMemory(), nullptr,

-                                   {irs_phys_addr, irs_size / PageSize},

-                                   Svc::MemoryPermission::None, Svc::MemoryPermission::Read,

-                                   irs_phys_addr, irs_size, "IRS:SharedMemory");

-        time_shared_mem->Initialize(system.DeviceMemory(), nullptr,

-                                    {time_phys_addr, time_size / PageSize},

-                                    Svc::MemoryPermission::None, Svc::MemoryPermission::Read,

-                                    time_phys_addr, time_size, "Time:SharedMemory");

-        hidbus_shared_mem->Initialize(system.DeviceMemory(), nullptr,

-                                      {hidbus_phys_addr, hidbus_size / PageSize},

-                                      Svc::MemoryPermission::None, Svc::MemoryPermission::Read,

-                                      hidbus_phys_addr, hidbus_size, "HidBus:SharedMemory");

+        hid_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,

+                                   Svc::MemoryPermission::Read, hid_size, "HID:SharedMemory");

+        font_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,

+                                    Svc::MemoryPermission::Read, font_size, "Font:SharedMemory");

+        irs_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,

+                                   Svc::MemoryPermission::Read, irs_size, "IRS:SharedMemory");

+        time_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,

+                                    Svc::MemoryPermission::Read, time_size, "Time:SharedMemory");

+        hidbus_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,

+                                      Svc::MemoryPermission::Read, hidbus_size,

+                                      "HidBus:SharedMemory");

     }

 

     KClientPort* CreateNamedServicePort(std::string name) {

diff --git a/src/yuzu/bootmanager.h b/src/yuzu/bootmanager.h
index e972acfe7..212587eee 100755
--- a/src/yuzu/bootmanager.h
+++ b/src/yuzu/bootmanager.h
@@ -80,7 +80,7 @@ public:
      * @return True if the emulation thread is running, otherwise false

      */

     bool IsRunning() const {

-        return m_is_running.load();

+        return m_is_running.load() || m_should_run;

     }

 

     /**

diff --git a/src/yuzu_cmd/CMakeLists.txt b/src/yuzu_cmd/CMakeLists.txt
index 772a6fc7f..5340fe836 100755
--- a/src/yuzu_cmd/CMakeLists.txt
+++ b/src/yuzu_cmd/CMakeLists.txt
@@ -49,6 +49,15 @@ if(UNIX AND NOT APPLE)
     install(TARGETS yuzu-cmd)

 endif()

 

+if(WIN32)

+    # compile as a win32 gui application instead of a console application

+    if(MSVC)

+        set_target_properties(yuzu-cmd PROPERTIES LINK_FLAGS_RELEASE "/SUBSYSTEM:WINDOWS /ENTRY:mainCRTStartup")

+    elseif(MINGW)

+        set_target_properties(yuzu-cmd PROPERTIES LINK_FLAGS_RELEASE "-Wl,--subsystem,windows")

+    endif()

+endif()

+

 if (MSVC)

     include(CopyYuzuSDLDeps)

     copy_yuzu_SDL_deps(yuzu-cmd)

diff --git a/src/yuzu_cmd/yuzu.cpp b/src/yuzu_cmd/yuzu.cpp
index 9ac8e9cca..19da46319 100755
--- a/src/yuzu_cmd/yuzu.cpp
+++ b/src/yuzu_cmd/yuzu.cpp
@@ -174,6 +174,13 @@ static void OnStatusMessageReceived(const Network::StatusMessageEntry& msg) {
 

 /// Application entry point

 int main(int argc, char** argv) {

+#ifdef _WIN32

+    if (AttachConsole(ATTACH_PARENT_PROCESS)) {

+        freopen("CONOUT$", "wb", stdout);

+        freopen("CONOUT$", "wb", stderr);

+    }

+#endif

+

     Common::Log::Initialize();

     Common::Log::SetColorConsoleBackendEnabled(true);

     Common::Log::Start();