Merge branch 'master' into master

Correct endianness of BRK

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -12,6 +12,7 @@
 #include "core/core.h"
 #include "core/core_cpu.h"
 #include "core/core_timing.h"
+#include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/svc.h"
 #include "core/memory.h"
@@ -79,6 +80,17 @@ public:
         case Dynarmic::A64::Exception::SendEventLocal:
         case Dynarmic::A64::Exception::Yield:
             return;
+        case Dynarmic::A64::Exception::Breakpoint:
+            if (GDBStub::IsServerEnabled()) {
+                parent.jit->HaltExecution();
+                parent.SetPC(pc);
+                Kernel::Thread* thread = Kernel::GetCurrentThread();
+                parent.SaveContext(thread->context);
+                GDBStub::Break();
+                GDBStub::SendTrap(thread, 5);
+                return;
+            }
+            [[fallthrough]];
         default:
             ASSERT_MSG(false, "ExceptionRaised(exception = {}, pc = {:X})",
                        static_cast<std::size_t>(exception), pc);

src/core/gdbstub/gdbstub.cpp

@@ -995,7 +995,7 @@ static bool CommitBreakpoint(BreakpointType type, VAddr addr, u64 len) {
     breakpoint.addr = addr;
     breakpoint.len = len;
     Memory::ReadBlock(addr, breakpoint.inst.data(), breakpoint.inst.size());
-    static constexpr std::array<u8, 4> btrap{{0xd4, 0x20, 0x7d, 0x0}};
+    static constexpr std::array<u8, 4> btrap{{0x00, 0x7d, 0x20, 0xd4}};
     Memory::WriteBlock(addr, btrap.data(), btrap.size());
     Core::System::GetInstance().InvalidateCpuInstructionCaches();
     p.insert({addr, breakpoint});

src/core/hle/kernel/thread.cpp

@@ -51,7 +51,8 @@ void Thread::Stop() {
     // Clean up thread from ready queue
     // This is only needed when the thread is terminated forcefully (SVC TerminateProcess)
     if (status == ThreadStatus::Ready) {
-        scheduler->UnscheduleThread(this, current_priority);
+        if (auto schlr = scheduler.lock())
+            schlr->UnscheduleThread(this, current_priority);
     }
 
     status = ThreadStatus::Dead;
@@ -161,14 +162,16 @@ void Thread::ResumeFromWait() {
 
     if (*new_processor_id != processor_id) {
         // Remove thread from previous core's scheduler
-        scheduler->RemoveThread(this);
+        if (auto schlr = scheduler.lock())
+            schlr->RemoveThread(this);
         next_scheduler->AddThread(this, current_priority);
     }
 
     processor_id = *new_processor_id;
 
     // If the thread was ready, unschedule from the previous core and schedule on the new core
-    scheduler->UnscheduleThread(this, current_priority);
+    if (auto schlr = scheduler.lock())
+        schlr->UnscheduleThread(this, current_priority);
     next_scheduler->ScheduleThread(this, current_priority);
 
     // Change thread's scheduler
@@ -263,7 +266,8 @@ ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name
     thread->callback_handle = kernel.ThreadWakeupCallbackHandleTable().Create(thread).Unwrap();
     thread->owner_process = owner_process;
     thread->scheduler = Core::System::GetInstance().Scheduler(processor_id);
-    thread->scheduler->AddThread(thread, priority);
+    if (auto s = thread->scheduler.lock())
+        s->AddThread(thread, priority);
 
     // Find the next available TLS index, and mark it as used
     auto& tls_slots = owner_process->tls_slots;
@@ -306,7 +310,8 @@ void Thread::SetPriority(u32 priority) {
 }
 
 void Thread::BoostPriority(u32 priority) {
-    scheduler->SetThreadPriority(this, priority);
+    if (auto schlr = scheduler.lock())
+        schlr->SetThreadPriority(this, priority);
     current_priority = priority;
 }
 
@@ -396,7 +401,8 @@ void Thread::UpdatePriority() {
     if (new_priority == current_priority)
         return;
 
-    scheduler->SetThreadPriority(this, new_priority);
+    if (auto schlr = scheduler.lock())
+        schlr->SetThreadPriority(this, new_priority);
 
     current_priority = new_priority;
 
@@ -430,14 +436,16 @@ void Thread::ChangeCore(u32 core, u64 mask) {
 
     if (*new_processor_id != processor_id) {
         // Remove thread from previous core's scheduler
-        scheduler->RemoveThread(this);
+        if (auto schlr = scheduler.lock())
+            schlr->RemoveThread(this);
         next_scheduler->AddThread(this, current_priority);
     }
 
     processor_id = *new_processor_id;
 
     // If the thread was ready, unschedule from the previous core and schedule on the new core
-    scheduler->UnscheduleThread(this, current_priority);
+    if (auto schlr = scheduler.lock())
+        schlr->UnscheduleThread(this, current_priority);
     next_scheduler->ScheduleThread(this, current_priority);
 
     // Change thread's scheduler

src/core/hle/kernel/thread.h

@@ -260,7 +260,7 @@ public:
     // available. In case of a timeout, the object will be nullptr.
     std::function<WakeupCallback> wakeup_callback;
 
-    std::shared_ptr<Scheduler> scheduler;
+    std::weak_ptr<Scheduler> scheduler;
 
     u32 ideal_core{0xFFFFFFFF};
     u64 affinity_mask{0x1};

src/core/hle/service/hid/hid.cpp

@@ -292,6 +292,8 @@ private:
 class Hid final : public ServiceFramework<Hid> {
 public:
     Hid() : ServiceFramework("hid") {
+        ReloadInputDevices();
+
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &Hid::CreateAppletResource, "CreateAppletResource"},

src/core/hle/service/service.cpp

@@ -99,14 +99,12 @@ ServiceFrameworkBase::ServiceFrameworkBase(const char* service_name, u32 max_ses
 ServiceFrameworkBase::~ServiceFrameworkBase() = default;
 
 void ServiceFrameworkBase::InstallAsService(SM::ServiceManager& service_manager) {
-    ASSERT(port == nullptr);
-    port = service_manager.RegisterService(service_name, max_sessions).Unwrap();
+    SharedPtr<ServerPort> port =
+        service_manager.RegisterService(service_name, max_sessions).Unwrap();
     port->SetHleHandler(shared_from_this());
 }
 
 void ServiceFrameworkBase::InstallAsNamedPort() {
-    ASSERT(port == nullptr);
-
     auto& kernel = Core::System::GetInstance().Kernel();
     SharedPtr<ServerPort> server_port;
     SharedPtr<ClientPort> client_port;
@@ -116,19 +114,6 @@ void ServiceFrameworkBase::InstallAsNamedPort() {
     kernel.AddNamedPort(service_name, std::move(client_port));
 }
 
-Kernel::SharedPtr<Kernel::ClientPort> ServiceFrameworkBase::CreatePort() {
-    ASSERT(port == nullptr);
-
-    auto& kernel = Core::System::GetInstance().Kernel();
-    Kernel::SharedPtr<Kernel::ServerPort> server_port;
-    Kernel::SharedPtr<Kernel::ClientPort> client_port;
-    std::tie(server_port, client_port) =
-        Kernel::ServerPort::CreatePortPair(kernel, max_sessions, service_name);
-    port = MakeResult<Kernel::SharedPtr<Kernel::ServerPort>>(std::move(server_port)).Unwrap();
-    port->SetHleHandler(shared_from_this());
-    return client_port;
-}
-
 void ServiceFrameworkBase::RegisterHandlersBase(const FunctionInfoBase* functions, std::size_t n) {
     handlers.reserve(handlers.size() + n);
     for (std::size_t i = 0; i < n; ++i) {

src/core/hle/service/service.h

@@ -60,8 +60,6 @@ public:
     void InstallAsService(SM::ServiceManager& service_manager);
     /// Creates a port pair and registers it on the kernel's global port registry.
     void InstallAsNamedPort();
-    /// Creates and returns an unregistered port for the service.
-    Kernel::SharedPtr<Kernel::ClientPort> CreatePort();
 
     void InvokeRequest(Kernel::HLERequestContext& ctx);
 
@@ -96,12 +94,6 @@ private:
     /// Maximum number of concurrent sessions that this service can handle.
     u32 max_sessions;
 
-    /**
-     * Port where incoming connections will be received. Only created when InstallAsService() or
-     * InstallAsNamedPort() are called.
-     */
-    Kernel::SharedPtr<Kernel::ServerPort> port;
-
     /// Function used to safely up-cast pointers to the derived class before invoking a handler.
     InvokerFn* handler_invoker;
     boost::container::flat_map<u32, FunctionInfoBase> handlers;

src/core/hle/service/sm/sm.cpp

@@ -37,11 +37,8 @@ static ResultCode ValidateServiceName(const std::string& name) {
 }
 
 void ServiceManager::InstallInterfaces(std::shared_ptr<ServiceManager> self) {
-    ASSERT(self->sm_interface.expired());
-
     auto sm = std::make_shared<SM>(self);
     sm->InstallAsNamedPort();
-    self->sm_interface = sm;
     self->controller_interface = std::make_unique<Controller>();
 }
 

src/core/hle/service/sm/sm.h

@@ -51,7 +51,6 @@ public:
     void InvokeControlRequest(Kernel::HLERequestContext& context);
 
 private:
-    std::weak_ptr<SM> sm_interface;
     std::unique_ptr<Controller> controller_interface;
 
     /// Map of registered services, retrieved using GetServicePort or ConnectToService.