RPCSX/rpcsx
1
0
Fork 0
mirror of https://github.com/RPCSX/rpcsx.git synced 2025-03-04 08:37:33 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Implement thread names

Browse Source
This commit is contained in:
Ivan Chikish 2023-07-17 07:33:25 +03:00
parent a1a91bb557
commit 9462e12735
4 changed files with 44 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
orbis-kernel/include/orbis/thread/Thread.hpp
View File

@ -5,6 +5,7 @@
#include "types.hpp"
#include "../utils/SharedMutex.hpp"
#include <thread>
namespace orbis {
struct Process;
@ -17,12 +18,13 @@ struct Thread {
ptr<void> stackEnd;
uint64_t fsBase{};
uint64_t gsBase{};
char name[32];
char name[32]{};
uint64_t sigMask[4] = {0x7fff'ffff, 0};
lwpid_t tid = -1;
ThreadState state = ThreadState::INACTIVE;
std::thread handle;
// FIXME: implement thread destruction
void incRef() {}

13
orbis-kernel/include/orbis/utils/IdMap.hpp
View File

@ -338,6 +338,19 @@ struct OwningIdMap {
fullChunks.clear(chunk);
return true;
}
void walk(auto cb) {
for (std::size_t chunk = 0; chunk < ChunkCount; ++chunk) {
std::size_t index = chunks[chunk].mask.countr_zero();
while (index < ChunkSize) {
auto id = static_cast<IdT>(index + chunk * ChunkSize + MinId);
cb(id, chunks[chunk].get(id));
index = chunks[chunk].mask.countr_zero(index + 1);
}
}
}
};
} // namespace utils
} // namespace orbis

15
orbis-kernel/src/sys/sys_sce.cpp
View File

@ -488,6 +488,21 @@ orbis::SysResult orbis::sys_mname(Thread *thread, uint64_t addr, uint64_t len,
std::abort();
if (!thread->tproc->namedMem.count(addr))
std::abort();
std::lock_guard lock2(thread->tproc->mtx);
thread->tproc->threadsMap.walk([&](auto id, auto obj) {
if (obj->stackStart == (void *)addr) {
std::string name = std::to_string(obj->tid) + "_" + _name;
if (name.size() > 15)
name.resize(15);
ORBIS_LOG_NOTICE("sys_mname: setting thread name", obj->tid, name,
obj->handle.native_handle());
if (!pthread_setname_np(obj->handle.native_handle(), name.c_str())) {
perror("pthread_setname_np");
}
}
});
return {};
}
orbis::SysResult orbis::sys_dynlib_dlopen(Thread *thread /* TODO */) {

20
rpcsx-os/ops.cpp
View File

@ -477,6 +477,7 @@ SysResult thr_new(orbis::Thread *thread, orbis::ptr<thr_param> param,
}
auto proc = thread->tproc;
std::lock_guard lock(proc->mtx);
auto [baseId, childThread] = proc->threadsMap.emplace();
childThread->tproc = proc;
childThread->tid = proc->pid + baseId;
@ -493,11 +494,10 @@ SysResult thr_new(orbis::Thread *thread, orbis::ptr<thr_param> param,
// FIXME: implement scheduler
std::printf("Starting child thread %lu\n", (long)(proc->pid + baseId));
ORBIS_LOG_NOTICE("Starting child thread", childThread->tid,
childThread->stackStart);
std::thread{[=, childThread = Ref<Thread>(childThread)] {
pthread_setname_np(pthread_self(),
std::to_string(childThread->tid).c_str());
auto stdthr = std::thread{[=, childThread = Ref<Thread>(childThread)] {
stack_t ss;
auto sigStackSize = std::max<std::size_t>(
@ -506,7 +506,7 @@ SysResult thr_new(orbis::Thread *thread, orbis::ptr<thr_param> param,
ss.ss_sp = malloc(sigStackSize);
if (ss.ss_sp == NULL) {
perror("malloc");
exit(EXIT_FAILURE);
::exit(EXIT_FAILURE);
}
ss.ss_size = sigStackSize;
@ -514,7 +514,7 @@ SysResult thr_new(orbis::Thread *thread, orbis::ptr<thr_param> param,
if (sigaltstack(&ss, NULL) == -1) {
perror("sigaltstack");
exit(EXIT_FAILURE);
::exit(EXIT_FAILURE);
}
static_cast<void>(
@ -533,8 +533,14 @@ SysResult thr_new(orbis::Thread *thread, orbis::ptr<thr_param> param,
childThread->context = context;
childThread->state = orbis::ThreadState::RUNNING;
rx::thread::invoke(childThread.get());
}}.detach();
}};
if (pthread_setname_np(stdthr.native_handle(),
std::to_string(childThread->tid).c_str())) {
perror("pthread_setname_np");
}
childThread->handle = std::move(stdthr);
return {};
}
SysResult thr_exit(orbis::Thread *thread, orbis::ptr<orbis::slong> state) {