2014-05-09 19:11:18 -07:00
|
|
|
// Copyright 2014 Citra Emulator Project / PPSSPP Project
|
2014-12-16 21:38:14 -08:00
|
|
|
// Licensed under GPLv2 or any later version
|
2014-11-19 00:49:13 -08:00
|
|
|
// Refer to the license.txt file included.
|
2014-05-09 19:11:18 -07:00
|
|
|
|
2014-06-05 19:35:36 -07:00
|
|
|
#include <algorithm>
|
2018-02-13 21:33:15 -08:00
|
|
|
#include <cinttypes>
|
2014-08-17 20:03:22 -07:00
|
|
|
#include <vector>
|
2018-07-31 05:06:09 -07:00
|
|
|
|
|
|
|
#include <boost/optional.hpp>
|
|
|
|
#include <boost/range/algorithm_ext/erase.hpp>
|
|
|
|
|
2015-05-06 00:06:12 -07:00
|
|
|
#include "common/assert.h"
|
|
|
|
#include "common/common_types.h"
|
|
|
|
#include "common/logging/log.h"
|
2015-02-18 22:46:21 -08:00
|
|
|
#include "common/math_util.h"
|
2014-05-15 15:27:08 -07:00
|
|
|
#include "common/thread_queue_list.h"
|
2014-12-21 22:30:09 -08:00
|
|
|
#include "core/arm/arm_interface.h"
|
2014-05-13 19:00:11 -07:00
|
|
|
#include "core/core.h"
|
2018-08-31 09:21:34 -07:00
|
|
|
#include "core/core_cpu.h"
|
2015-01-07 07:10:58 -08:00
|
|
|
#include "core/core_timing.h"
|
2018-07-24 03:03:24 -07:00
|
|
|
#include "core/core_timing_util.h"
|
2017-05-21 00:11:36 -07:00
|
|
|
#include "core/hle/kernel/errors.h"
|
2017-05-29 16:45:42 -07:00
|
|
|
#include "core/hle/kernel/handle_table.h"
|
2018-08-28 09:30:33 -07:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
2018-08-01 19:40:00 -07:00
|
|
|
#include "core/hle/kernel/object.h"
|
2016-09-17 17:38:01 -07:00
|
|
|
#include "core/hle/kernel/process.h"
|
2018-08-31 09:21:34 -07:00
|
|
|
#include "core/hle/kernel/scheduler.h"
|
2016-09-20 23:52:38 -07:00
|
|
|
#include "core/hle/kernel/thread.h"
|
2014-10-22 20:20:01 -07:00
|
|
|
#include "core/hle/result.h"
|
2015-05-12 18:38:29 -07:00
|
|
|
#include "core/memory.h"
|
2014-05-09 19:11:18 -07:00
|
|
|
|
2014-05-20 16:37:46 -07:00
|
|
|
namespace Kernel {
|
2014-05-13 19:00:11 -07:00
|
|
|
|
2017-01-01 13:53:22 -08:00
|
|
|
bool Thread::ShouldWait(Thread* thread) const {
|
2018-07-19 18:39:05 -07:00
|
|
|
return status != ThreadStatus::Dead;
|
2014-12-21 22:32:03 -08:00
|
|
|
}
|
2014-05-09 19:11:18 -07:00
|
|
|
|
2017-01-01 13:53:22 -08:00
|
|
|
void Thread::Acquire(Thread* thread) {
|
|
|
|
ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
|
2015-01-17 19:23:49 -08:00
|
|
|
}
|
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
Thread::Thread(KernelCore& kernel) : WaitObject{kernel} {}
|
|
|
|
Thread::~Thread() = default;
|
2015-01-31 13:22:40 -08:00
|
|
|
|
2015-01-25 22:56:17 -08:00
|
|
|
void Thread::Stop() {
|
|
|
|
// Cancel any outstanding wakeup events for this thread
|
2018-08-28 09:30:33 -07:00
|
|
|
CoreTiming::UnscheduleEvent(kernel.ThreadWakeupCallbackEventType(), callback_handle);
|
|
|
|
kernel.ThreadWakeupCallbackHandleTable().Close(callback_handle);
|
2015-07-16 22:24:13 -07:00
|
|
|
callback_handle = 0;
|
2015-01-25 22:56:17 -08:00
|
|
|
|
|
|
|
// Clean up thread from ready queue
|
2018-08-28 09:30:33 -07:00
|
|
|
// This is only needed when the thread is terminated forcefully (SVC TerminateProcess)
|
2018-07-19 18:39:05 -07:00
|
|
|
if (status == ThreadStatus::Ready) {
|
2018-05-02 19:36:51 -07:00
|
|
|
scheduler->UnscheduleThread(this, current_priority);
|
2015-01-25 22:56:17 -08:00
|
|
|
}
|
|
|
|
|
2018-07-19 18:39:05 -07:00
|
|
|
status = ThreadStatus::Dead;
|
2015-05-25 11:34:09 -07:00
|
|
|
|
2015-01-20 15:20:47 -08:00
|
|
|
WakeupAllWaitingThreads();
|
2014-06-09 19:14:03 -07:00
|
|
|
|
2015-01-25 22:56:17 -08:00
|
|
|
// Clean up any dangling references in objects that this thread was waiting for
|
2015-01-31 17:26:16 -08:00
|
|
|
for (auto& wait_object : wait_objects) {
|
|
|
|
wait_object->RemoveWaitingThread(this);
|
|
|
|
}
|
2015-07-16 22:24:13 -07:00
|
|
|
wait_objects.clear();
|
2015-05-10 21:19:54 -07:00
|
|
|
|
2016-04-19 15:12:48 -07:00
|
|
|
// Mark the TLS slot in the thread's page as free.
|
2018-08-02 20:37:44 -07:00
|
|
|
const u64 tls_page = (tls_address - Memory::TLS_AREA_VADDR) / Memory::PAGE_SIZE;
|
|
|
|
const u64 tls_slot =
|
2016-09-17 17:38:01 -07:00
|
|
|
((tls_address - Memory::TLS_AREA_VADDR) % Memory::PAGE_SIZE) / Memory::TLS_ENTRY_SIZE;
|
2018-03-13 14:49:59 -07:00
|
|
|
Core::CurrentProcess()->tls_slots[tls_page].reset(tls_slot);
|
2014-05-13 19:00:11 -07:00
|
|
|
}
|
|
|
|
|
2015-01-18 10:56:40 -08:00
|
|
|
void WaitCurrentThread_Sleep() {
|
2015-01-16 23:03:44 -08:00
|
|
|
Thread* thread = GetCurrentThread();
|
2018-07-19 18:39:05 -07:00
|
|
|
thread->status = ThreadStatus::WaitSleep;
|
2015-01-16 23:03:44 -08:00
|
|
|
}
|
|
|
|
|
2016-12-17 03:08:38 -08:00
|
|
|
void ExitCurrentThread() {
|
|
|
|
Thread* thread = GetCurrentThread();
|
|
|
|
thread->Stop();
|
2018-05-02 19:36:51 -07:00
|
|
|
Core::System::GetInstance().CurrentScheduler().RemoveThread(thread);
|
2016-12-17 03:08:38 -08:00
|
|
|
}
|
|
|
|
|
2015-01-30 17:07:54 -08:00
|
|
|
void Thread::WakeAfterDelay(s64 nanoseconds) {
|
2015-01-07 13:40:08 -08:00
|
|
|
// Don't schedule a wakeup if the thread wants to wait forever
|
|
|
|
if (nanoseconds == -1)
|
|
|
|
return;
|
|
|
|
|
2018-08-12 15:47:15 -07:00
|
|
|
// This function might be called from any thread so we have to be cautious and use the
|
|
|
|
// thread-safe version of ScheduleEvent.
|
2018-08-28 09:30:33 -07:00
|
|
|
CoreTiming::ScheduleEventThreadsafe(CoreTiming::nsToCycles(nanoseconds),
|
|
|
|
kernel.ThreadWakeupCallbackEventType(), callback_handle);
|
2015-01-07 13:40:08 -08:00
|
|
|
}
|
|
|
|
|
2018-01-08 08:35:03 -08:00
|
|
|
void Thread::CancelWakeupTimer() {
|
2018-08-28 09:30:33 -07:00
|
|
|
CoreTiming::UnscheduleEventThreadsafe(kernel.ThreadWakeupCallbackEventType(), callback_handle);
|
2018-01-08 08:35:03 -08:00
|
|
|
}
|
|
|
|
|
2018-05-07 19:29:48 -07:00
|
|
|
static boost::optional<s32> GetNextProcessorId(u64 mask) {
|
|
|
|
for (s32 index = 0; index < Core::NUM_CPU_CORES; ++index) {
|
|
|
|
if (mask & (1ULL << index)) {
|
2018-07-18 15:10:06 -07:00
|
|
|
if (!Core::System::GetInstance().Scheduler(index)->GetCurrentThread()) {
|
2018-05-07 19:29:48 -07:00
|
|
|
// Core is enabled and not running any threads, use this one
|
|
|
|
return index;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2014-12-22 05:07:22 -08:00
|
|
|
void Thread::ResumeFromWait() {
|
2017-01-04 09:48:13 -08:00
|
|
|
ASSERT_MSG(wait_objects.empty(), "Thread is waking up while waiting for objects");
|
|
|
|
|
2015-01-25 22:56:17 -08:00
|
|
|
switch (status) {
|
2018-07-19 18:39:05 -07:00
|
|
|
case ThreadStatus::WaitSynchAll:
|
|
|
|
case ThreadStatus::WaitSynchAny:
|
|
|
|
case ThreadStatus::WaitHLEEvent:
|
|
|
|
case ThreadStatus::WaitSleep:
|
|
|
|
case ThreadStatus::WaitIPC:
|
|
|
|
case ThreadStatus::WaitMutex:
|
|
|
|
case ThreadStatus::WaitArb:
|
2016-09-17 17:38:01 -07:00
|
|
|
break;
|
|
|
|
|
2018-07-19 18:39:05 -07:00
|
|
|
case ThreadStatus::Ready:
|
2017-09-28 09:53:32 -07:00
|
|
|
// The thread's wakeup callback must have already been cleared when the thread was first
|
|
|
|
// awoken.
|
|
|
|
ASSERT(wakeup_callback == nullptr);
|
2016-09-17 17:38:01 -07:00
|
|
|
// If the thread is waiting on multiple wait objects, it might be awoken more than once
|
|
|
|
// before actually resuming. We can ignore subsequent wakeups if the thread status has
|
2018-07-19 18:39:05 -07:00
|
|
|
// already been set to ThreadStatus::Ready.
|
2016-09-17 17:38:01 -07:00
|
|
|
return;
|
|
|
|
|
2018-07-19 18:39:05 -07:00
|
|
|
case ThreadStatus::Running:
|
2018-04-27 04:54:05 -07:00
|
|
|
DEBUG_ASSERT_MSG(false, "Thread with object id {} has already resumed.", GetObjectId());
|
2016-09-17 17:38:01 -07:00
|
|
|
return;
|
2018-07-19 18:39:05 -07:00
|
|
|
case ThreadStatus::Dead:
|
2016-09-17 17:38:01 -07:00
|
|
|
// This should never happen, as threads must complete before being stopped.
|
2018-04-27 04:54:05 -07:00
|
|
|
DEBUG_ASSERT_MSG(false, "Thread with object id {} cannot be resumed because it's DEAD.",
|
2016-09-17 17:38:01 -07:00
|
|
|
GetObjectId());
|
|
|
|
return;
|
2014-05-20 16:37:46 -07:00
|
|
|
}
|
2015-05-25 11:34:09 -07:00
|
|
|
|
2017-09-28 09:53:32 -07:00
|
|
|
wakeup_callback = nullptr;
|
|
|
|
|
2018-07-19 18:39:05 -07:00
|
|
|
status = ThreadStatus::Ready;
|
2018-05-07 19:29:48 -07:00
|
|
|
|
2018-05-10 16:12:46 -07:00
|
|
|
boost::optional<s32> new_processor_id = GetNextProcessorId(affinity_mask);
|
2018-05-07 19:29:48 -07:00
|
|
|
if (!new_processor_id) {
|
|
|
|
new_processor_id = processor_id;
|
|
|
|
}
|
|
|
|
if (ideal_core != -1 &&
|
2018-07-18 15:10:06 -07:00
|
|
|
Core::System::GetInstance().Scheduler(ideal_core)->GetCurrentThread() == nullptr) {
|
2018-05-07 19:29:48 -07:00
|
|
|
new_processor_id = ideal_core;
|
|
|
|
}
|
|
|
|
|
|
|
|
ASSERT(*new_processor_id < 4);
|
|
|
|
|
|
|
|
// Add thread to new core's scheduler
|
2018-07-18 15:10:06 -07:00
|
|
|
auto& next_scheduler = Core::System::GetInstance().Scheduler(*new_processor_id);
|
2018-05-07 19:29:48 -07:00
|
|
|
|
|
|
|
if (*new_processor_id != processor_id) {
|
|
|
|
// Remove thread from previous core's scheduler
|
|
|
|
scheduler->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);
|
|
|
|
next_scheduler->ScheduleThread(this, current_priority);
|
|
|
|
|
|
|
|
// Change thread's scheduler
|
|
|
|
scheduler = next_scheduler;
|
|
|
|
|
2018-05-05 20:54:43 -07:00
|
|
|
Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
|
2014-05-20 16:37:46 -07:00
|
|
|
}
|
|
|
|
|
2016-04-19 15:12:48 -07:00
|
|
|
/**
|
|
|
|
* Finds a free location for the TLS section of a thread.
|
|
|
|
* @param tls_slots The TLS page array of the thread's owner process.
|
|
|
|
* Returns a tuple of (page, slot, alloc_needed) where:
|
|
|
|
* page: The index of the first allocated TLS page that has free slots.
|
|
|
|
* slot: The index of the first free slot in the indicated page.
|
|
|
|
* alloc_needed: Whether there's a need to allocate a new TLS page (All pages are full).
|
|
|
|
*/
|
2018-08-02 09:01:22 -07:00
|
|
|
static std::tuple<std::size_t, std::size_t, bool> GetFreeThreadLocalSlot(
|
2018-08-02 08:55:10 -07:00
|
|
|
const std::vector<std::bitset<8>>& tls_slots) {
|
2016-04-19 15:12:48 -07:00
|
|
|
// Iterate over all the allocated pages, and try to find one where not all slots are used.
|
2018-08-02 09:01:22 -07:00
|
|
|
for (std::size_t page = 0; page < tls_slots.size(); ++page) {
|
2016-04-19 15:12:48 -07:00
|
|
|
const auto& page_tls_slots = tls_slots[page];
|
|
|
|
if (!page_tls_slots.all()) {
|
|
|
|
// We found a page with at least one free slot, find which slot it is
|
2018-08-02 09:01:22 -07:00
|
|
|
for (std::size_t slot = 0; slot < page_tls_slots.size(); ++slot) {
|
2016-04-19 15:12:48 -07:00
|
|
|
if (!page_tls_slots.test(slot)) {
|
|
|
|
return std::make_tuple(page, slot, false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return std::make_tuple(0, 0, true);
|
|
|
|
}
|
|
|
|
|
2016-09-02 05:53:42 -07:00
|
|
|
/**
|
|
|
|
* Resets a thread context, making it ready to be scheduled and run by the CPU
|
|
|
|
* @param context Thread context to reset
|
|
|
|
* @param stack_top Address of the top of the stack
|
|
|
|
* @param entry_point Address of entry point for execution
|
|
|
|
* @param arg User argument for thread
|
|
|
|
*/
|
2018-08-24 18:43:32 -07:00
|
|
|
static void ResetThreadContext(Core::ARM_Interface::ThreadContext& context, VAddr stack_top,
|
2017-09-20 20:14:06 -07:00
|
|
|
VAddr entry_point, u64 arg) {
|
2018-08-24 18:43:32 -07:00
|
|
|
memset(&context, 0, sizeof(Core::ARM_Interface::ThreadContext));
|
2016-09-02 05:53:42 -07:00
|
|
|
|
|
|
|
context.cpu_registers[0] = arg;
|
|
|
|
context.pc = entry_point;
|
|
|
|
context.sp = stack_top;
|
2018-01-02 19:24:12 -08:00
|
|
|
context.cpsr = 0;
|
|
|
|
context.fpscr = 0;
|
2016-09-02 05:53:42 -07:00
|
|
|
}
|
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name, VAddr entry_point,
|
|
|
|
u32 priority, u64 arg, s32 processor_id,
|
|
|
|
VAddr stack_top, SharedPtr<Process> owner_process) {
|
2017-05-21 00:11:36 -07:00
|
|
|
// Check if priority is in ranged. Lowest priority -> highest priority id.
|
|
|
|
if (priority > THREADPRIO_LOWEST) {
|
2018-07-02 09:13:26 -07:00
|
|
|
LOG_ERROR(Kernel_SVC, "Invalid thread priority: {}", priority);
|
2018-09-12 01:25:53 -07:00
|
|
|
return ERR_INVALID_THREAD_PRIORITY;
|
2017-05-21 00:11:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (processor_id > THREADPROCESSORID_MAX) {
|
2018-07-02 09:13:26 -07:00
|
|
|
LOG_ERROR(Kernel_SVC, "Invalid processor id: {}", processor_id);
|
2018-09-12 01:25:53 -07:00
|
|
|
return ERR_INVALID_PROCESSOR_ID;
|
2017-05-21 00:11:36 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// TODO(yuriks): Other checks, returning 0xD9001BEA
|
2014-05-16 21:56:00 -07:00
|
|
|
|
2017-09-26 15:40:49 -07:00
|
|
|
if (!Memory::IsValidVirtualAddress(*owner_process, entry_point)) {
|
2018-07-02 09:13:26 -07:00
|
|
|
LOG_ERROR(Kernel_SVC, "(name={}): invalid entry {:016X}", name, entry_point);
|
2017-10-31 16:26:11 -07:00
|
|
|
// TODO (bunnei): Find the correct error code to use here
|
|
|
|
return ResultCode(-1);
|
2014-12-22 05:07:22 -08:00
|
|
|
}
|
2014-05-20 18:02:35 -07:00
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
SharedPtr<Thread> thread(new Thread(kernel));
|
2014-06-05 19:35:36 -07:00
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
thread->thread_id = kernel.CreateNewThreadID();
|
2018-07-19 18:39:05 -07:00
|
|
|
thread->status = ThreadStatus::Dormant;
|
2014-06-09 19:14:03 -07:00
|
|
|
thread->entry_point = entry_point;
|
|
|
|
thread->stack_top = stack_top;
|
2018-07-20 17:57:45 -07:00
|
|
|
thread->tpidr_el0 = 0;
|
2015-03-23 20:55:21 -07:00
|
|
|
thread->nominal_priority = thread->current_priority = priority;
|
|
|
|
thread->last_running_ticks = CoreTiming::GetTicks();
|
2014-06-09 19:14:03 -07:00
|
|
|
thread->processor_id = processor_id;
|
2018-05-07 18:57:42 -07:00
|
|
|
thread->ideal_core = processor_id;
|
2018-05-10 16:12:46 -07:00
|
|
|
thread->affinity_mask = 1ULL << processor_id;
|
2015-01-14 20:41:33 -08:00
|
|
|
thread->wait_objects.clear();
|
2018-04-20 10:01:14 -07:00
|
|
|
thread->mutex_wait_address = 0;
|
|
|
|
thread->condvar_wait_address = 0;
|
|
|
|
thread->wait_handle = 0;
|
2014-12-29 04:55:30 -08:00
|
|
|
thread->name = std::move(name);
|
2018-08-28 09:30:33 -07:00
|
|
|
thread->callback_handle = kernel.ThreadWakeupCallbackHandleTable().Create(thread).Unwrap();
|
2017-09-26 15:40:49 -07:00
|
|
|
thread->owner_process = owner_process;
|
2018-07-18 15:10:06 -07:00
|
|
|
thread->scheduler = Core::System::GetInstance().Scheduler(processor_id);
|
2018-05-02 19:36:51 -07:00
|
|
|
thread->scheduler->AddThread(thread, priority);
|
2015-05-10 21:19:54 -07:00
|
|
|
|
|
|
|
// Find the next available TLS index, and mark it as used
|
2017-09-26 15:40:49 -07:00
|
|
|
auto& tls_slots = owner_process->tls_slots;
|
2016-04-19 15:12:48 -07:00
|
|
|
|
2018-08-02 09:01:22 -07:00
|
|
|
auto [available_page, available_slot, needs_allocation] = GetFreeThreadLocalSlot(tls_slots);
|
2016-04-19 15:12:48 -07:00
|
|
|
if (needs_allocation) {
|
|
|
|
tls_slots.emplace_back(0); // The page is completely available at the start
|
2018-08-02 09:01:22 -07:00
|
|
|
available_page = tls_slots.size() - 1;
|
2016-04-19 15:12:48 -07:00
|
|
|
available_slot = 0; // Use the first slot in the new page
|
2018-08-03 17:45:39 -07:00
|
|
|
|
|
|
|
// Allocate some memory from the end of the linear heap for this region.
|
|
|
|
const size_t offset = thread->tls_memory->size();
|
|
|
|
thread->tls_memory->insert(thread->tls_memory->end(), Memory::PAGE_SIZE, 0);
|
|
|
|
|
|
|
|
auto& vm_manager = owner_process->vm_manager;
|
|
|
|
vm_manager.RefreshMemoryBlockMappings(thread->tls_memory.get());
|
|
|
|
|
|
|
|
vm_manager.MapMemoryBlock(Memory::TLS_AREA_VADDR + available_page * Memory::PAGE_SIZE,
|
|
|
|
thread->tls_memory, 0, Memory::PAGE_SIZE,
|
|
|
|
MemoryState::ThreadLocal);
|
2015-05-10 21:19:54 -07:00
|
|
|
}
|
2014-06-05 19:35:36 -07:00
|
|
|
|
2016-04-19 15:12:48 -07:00
|
|
|
// Mark the slot as used
|
|
|
|
tls_slots[available_page].set(available_slot);
|
2016-09-17 17:38:01 -07:00
|
|
|
thread->tls_address = Memory::TLS_AREA_VADDR + available_page * Memory::PAGE_SIZE +
|
|
|
|
available_slot * Memory::TLS_ENTRY_SIZE;
|
2015-05-10 16:43:59 -07:00
|
|
|
|
2015-01-25 22:56:17 -08:00
|
|
|
// TODO(peachum): move to ScheduleThread() when scheduler is added so selected core is used
|
|
|
|
// to initialize the context
|
2016-09-02 05:53:42 -07:00
|
|
|
ResetThreadContext(thread->context, stack_top, entry_point, arg);
|
2015-01-25 22:56:17 -08:00
|
|
|
|
2014-12-29 04:55:30 -08:00
|
|
|
return MakeResult<SharedPtr<Thread>>(std::move(thread));
|
2014-06-01 19:12:54 -07:00
|
|
|
}
|
|
|
|
|
2017-09-26 16:26:09 -07:00
|
|
|
void Thread::SetPriority(u32 priority) {
|
2017-01-11 09:08:10 -08:00
|
|
|
ASSERT_MSG(priority <= THREADPRIO_LOWEST && priority >= THREADPRIO_HIGHEST,
|
|
|
|
"Invalid priority value.");
|
2018-04-20 18:15:16 -07:00
|
|
|
nominal_priority = priority;
|
|
|
|
UpdatePriority();
|
2014-06-01 19:12:54 -07:00
|
|
|
}
|
|
|
|
|
2017-09-26 16:26:09 -07:00
|
|
|
void Thread::BoostPriority(u32 priority) {
|
2018-05-02 19:36:51 -07:00
|
|
|
scheduler->SetThreadPriority(this, priority);
|
2015-04-03 15:40:16 -07:00
|
|
|
current_priority = priority;
|
|
|
|
}
|
|
|
|
|
2018-08-28 09:30:33 -07:00
|
|
|
SharedPtr<Thread> SetupMainThread(KernelCore& kernel, VAddr entry_point, u32 priority,
|
2017-12-30 09:10:58 -08:00
|
|
|
SharedPtr<Process> owner_process) {
|
2017-10-09 20:56:20 -07:00
|
|
|
// Setup page table so we can write to memory
|
2018-03-13 14:49:59 -07:00
|
|
|
SetCurrentPageTable(&Core::CurrentProcess()->vm_manager.page_table);
|
2015-01-25 22:56:17 -08:00
|
|
|
|
2014-05-15 15:27:08 -07:00
|
|
|
// Initialize new "main" thread
|
2018-08-28 09:30:33 -07:00
|
|
|
auto thread_res = Thread::Create(kernel, "main", entry_point, priority, 0, THREADPROCESSORID_0,
|
2018-07-18 16:02:47 -07:00
|
|
|
Memory::STACK_AREA_VADDR_END, std::move(owner_process));
|
2015-01-25 22:56:17 -08:00
|
|
|
|
2017-06-18 19:03:15 -07:00
|
|
|
SharedPtr<Thread> thread = std::move(thread_res).Unwrap();
|
2014-11-19 00:49:13 -08:00
|
|
|
|
2017-12-30 09:10:58 -08:00
|
|
|
// Register 1 must be a handle to the main thread
|
2018-08-28 09:30:33 -07:00
|
|
|
thread->guest_handle = kernel.HandleTable().Create(thread).Unwrap();
|
2018-01-08 08:35:03 -08:00
|
|
|
|
2017-12-31 14:23:36 -08:00
|
|
|
thread->context.cpu_registers[1] = thread->guest_handle;
|
2016-05-14 06:45:04 -07:00
|
|
|
|
2017-12-30 09:05:10 -08:00
|
|
|
// Threads by default are dormant, wake up the main thread so it runs when the scheduler fires
|
|
|
|
thread->ResumeFromWait();
|
|
|
|
|
2014-12-22 05:07:22 -08:00
|
|
|
return thread;
|
2014-05-15 15:27:08 -07:00
|
|
|
}
|
2014-05-14 17:50:30 -07:00
|
|
|
|
2015-01-20 17:53:52 -08:00
|
|
|
void Thread::SetWaitSynchronizationResult(ResultCode result) {
|
|
|
|
context.cpu_registers[0] = result.raw;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Thread::SetWaitSynchronizationOutput(s32 output) {
|
|
|
|
context.cpu_registers[1] = output;
|
2015-01-16 23:03:44 -08:00
|
|
|
}
|
|
|
|
|
2017-01-04 07:53:01 -08:00
|
|
|
s32 Thread::GetWaitObjectIndex(WaitObject* object) const {
|
2017-01-04 09:48:13 -08:00
|
|
|
ASSERT_MSG(!wait_objects.empty(), "Thread is not waiting for anything");
|
2017-01-04 07:53:01 -08:00
|
|
|
auto match = std::find(wait_objects.rbegin(), wait_objects.rend(), object);
|
2017-09-26 16:26:09 -07:00
|
|
|
return static_cast<s32>(std::distance(match, wait_objects.rend()) - 1);
|
2017-01-04 07:53:01 -08:00
|
|
|
}
|
|
|
|
|
2017-09-29 12:47:52 -07:00
|
|
|
VAddr Thread::GetCommandBufferAddress() const {
|
|
|
|
// Offset from the start of TLS at which the IPC command buffer begins.
|
|
|
|
static constexpr int CommandHeaderOffset = 0x80;
|
|
|
|
return GetTLSAddress() + CommandHeaderOffset;
|
2017-01-04 07:53:01 -08:00
|
|
|
}
|
|
|
|
|
2018-04-20 18:15:16 -07:00
|
|
|
void Thread::AddMutexWaiter(SharedPtr<Thread> thread) {
|
2018-08-12 14:35:27 -07:00
|
|
|
if (thread->lock_owner == this) {
|
|
|
|
// If the thread is already waiting for this thread to release the mutex, ensure that the
|
|
|
|
// waiters list is consistent and return without doing anything.
|
|
|
|
auto itr = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
|
|
|
|
ASSERT(itr != wait_mutex_threads.end());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// A thread can't wait on two different mutexes at the same time.
|
|
|
|
ASSERT(thread->lock_owner == nullptr);
|
|
|
|
|
|
|
|
// Ensure that the thread is not already in the list of mutex waiters
|
|
|
|
auto itr = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
|
|
|
|
ASSERT(itr == wait_mutex_threads.end());
|
|
|
|
|
2018-04-20 18:15:16 -07:00
|
|
|
thread->lock_owner = this;
|
|
|
|
wait_mutex_threads.emplace_back(std::move(thread));
|
|
|
|
UpdatePriority();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Thread::RemoveMutexWaiter(SharedPtr<Thread> thread) {
|
2018-08-12 14:35:27 -07:00
|
|
|
ASSERT(thread->lock_owner == this);
|
|
|
|
|
|
|
|
// Ensure that the thread is in the list of mutex waiters
|
|
|
|
auto itr = std::find(wait_mutex_threads.begin(), wait_mutex_threads.end(), thread);
|
|
|
|
ASSERT(itr != wait_mutex_threads.end());
|
|
|
|
|
2018-04-20 18:15:16 -07:00
|
|
|
boost::remove_erase(wait_mutex_threads, thread);
|
|
|
|
thread->lock_owner = nullptr;
|
|
|
|
UpdatePriority();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Thread::UpdatePriority() {
|
|
|
|
// Find the highest priority among all the threads that are waiting for this thread's lock
|
|
|
|
u32 new_priority = nominal_priority;
|
|
|
|
for (const auto& thread : wait_mutex_threads) {
|
|
|
|
if (thread->nominal_priority < new_priority)
|
|
|
|
new_priority = thread->nominal_priority;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (new_priority == current_priority)
|
|
|
|
return;
|
|
|
|
|
2018-05-02 19:36:51 -07:00
|
|
|
scheduler->SetThreadPriority(this, new_priority);
|
2018-04-20 18:15:16 -07:00
|
|
|
|
|
|
|
current_priority = new_priority;
|
|
|
|
|
|
|
|
// Recursively update the priority of the thread that depends on the priority of this one.
|
|
|
|
if (lock_owner)
|
|
|
|
lock_owner->UpdatePriority();
|
|
|
|
}
|
|
|
|
|
2018-05-05 20:03:01 -07:00
|
|
|
void Thread::ChangeCore(u32 core, u64 mask) {
|
2018-05-07 19:29:48 -07:00
|
|
|
ideal_core = core;
|
2018-05-30 11:33:57 -07:00
|
|
|
affinity_mask = mask;
|
2018-05-05 20:03:01 -07:00
|
|
|
|
2018-07-19 18:39:05 -07:00
|
|
|
if (status != ThreadStatus::Ready) {
|
2018-05-05 20:03:01 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-05-30 11:33:57 -07:00
|
|
|
boost::optional<s32> new_processor_id{GetNextProcessorId(affinity_mask)};
|
2018-05-05 20:03:01 -07:00
|
|
|
|
2018-05-07 19:29:48 -07:00
|
|
|
if (!new_processor_id) {
|
|
|
|
new_processor_id = processor_id;
|
|
|
|
}
|
|
|
|
if (ideal_core != -1 &&
|
2018-07-18 15:10:06 -07:00
|
|
|
Core::System::GetInstance().Scheduler(ideal_core)->GetCurrentThread() == nullptr) {
|
2018-05-07 19:29:48 -07:00
|
|
|
new_processor_id = ideal_core;
|
|
|
|
}
|
|
|
|
|
2018-05-30 09:32:46 -07:00
|
|
|
ASSERT(*new_processor_id < 4);
|
2018-05-05 20:03:01 -07:00
|
|
|
|
|
|
|
// Add thread to new core's scheduler
|
2018-07-18 15:10:06 -07:00
|
|
|
auto& next_scheduler = Core::System::GetInstance().Scheduler(*new_processor_id);
|
2018-05-05 20:03:01 -07:00
|
|
|
|
2018-05-07 19:29:48 -07:00
|
|
|
if (*new_processor_id != processor_id) {
|
|
|
|
// Remove thread from previous core's scheduler
|
|
|
|
scheduler->RemoveThread(this);
|
|
|
|
next_scheduler->AddThread(this, current_priority);
|
2018-05-05 20:03:01 -07:00
|
|
|
}
|
|
|
|
|
2018-05-07 19:29:48 -07:00
|
|
|
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);
|
|
|
|
next_scheduler->ScheduleThread(this, current_priority);
|
2018-05-05 20:03:01 -07:00
|
|
|
|
|
|
|
// Change thread's scheduler
|
|
|
|
scheduler = next_scheduler;
|
2018-05-07 19:29:48 -07:00
|
|
|
|
|
|
|
Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
|
2018-05-05 20:03:01 -07:00
|
|
|
}
|
|
|
|
|
2014-05-16 21:56:00 -07:00
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
2014-05-15 15:27:08 -07:00
|
|
|
|
2018-02-18 12:17:16 -08:00
|
|
|
/**
|
|
|
|
* Gets the current thread
|
|
|
|
*/
|
|
|
|
Thread* GetCurrentThread() {
|
2018-05-02 19:36:51 -07:00
|
|
|
return Core::System::GetInstance().CurrentScheduler().GetCurrentThread();
|
2018-02-18 12:17:16 -08:00
|
|
|
}
|
|
|
|
|
2018-01-08 08:35:03 -08:00
|
|
|
} // namespace Kernel
|