[NevesHenry]

What

On Linux, scePthreadCreate ignored the requested stack size. Guest threads were started with std::thread, so every thread got the host default stack (RLIMIT_STACK, 8 MiB on most systems) whatever the title passed to scePthreadAttrSetstacksize / pthread_attr_setstacksize. Windows already honours it (_beginthreadex with the requested size).

• A thread that asks for more than the host default and uses it crashes with SIGSEGV. A thread that asks for 16 MiB and recurses through ~16 MiB dies on main.
• After the thread started, RunThread → SetStackFromHost replaced stackSize/stackAddress with the host range. scePthreadAttrGet then reported 8 MiB for every thread. guest_pthread_attr only passes because it usually reads the attributes before the new thread gets that far. Pinned to one CPU (taskset -c 0) it fails 2 times in 1000 on main.
• The host stack size also depended on the user's ulimit -s.

Change (Linux only, Pthread/src/Thread.cpp):

• Guest threads are created with pthread_create and pthread_attr_setstacksize. PthreadPrivate::_thr (std::thread) becomes pthread_t hostThread. Join and detach use pthread_join / pthread_detach.
• glibc carves static TLS and the thread control block out of the top of the thread's stack; FreeBSD allocates TLS separately. Asking glibc for exactly the requested size would leave the guest less than it asked for. With a large static TLS, a small request fails with EINVAL (a 16 KiB stack with 512 KiB of TLS). The host stack is therefore requested + reserve, rounded up to the page size. The reserve is everything glibc keeps above the start routine's frame. It is measured once with a probe thread, because it is constant within a process.
• The new thread records [top - reserve - size, top - reserve) as its guest stack, as Windows records [top - size, top). The creator waits until the range is set before scePthreadCreate returns, as on Windows. NativeThreadArgs is now shared by both platforms. scePthreadAttrGet and sceKernelIsStack report the requested size, and the race above is gone.
• Threads created without attributes now get DEFAULT_STACK_SIZE (1 MiB) on Linux, as on Windows, instead of the host default.

Not changed: an address passed with scePthreadAttrSetstack / scePthreadAttrSetstackaddr is still ignored on both platforms. The thread runs on a host-allocated stack of that size. This could be a follow-up.

Tested

Linux: WSL2, Ubuntu 22.04, glibc 2.35, GCC 13.4, Release, ulimit -s 8192. No title run.

• New guest_pthread_stack:
  • Setup: creates threads that request 16 KiB, 64 KiB, 1 MiB and 16 MiB, in a process with 512 KiB of thread_local data. Each thread checks that scePthreadAttrGet reports the requested size and that its frame is inside the reported range. It then recurses through the range down to 8 KiB above its start.
  • On main: it aborts at the first thread, where a 16 KiB thread reports 8 MiB. A variant without the size checks (16 MiB only) dies with SIGSEGV.
  • With this change: it passes. The usable stack below the thread function is requested - 616 bytes for all four sizes.
• Mutation: dropping the reserve (stack = requested size) fails with Creating guest thread: Invalid argument on the 16 KiB thread.
• guest_pthread_attr pinned to one CPU: 2/1000 failures on main, 0/3000 with this change.
• ctest:
  • All 287 tests outside agc_driver* / agc_write_tracking pass.
  • The thread, stack, mutex, condition and semaphore tests pass with --repeat until-fail:20.
  • On this machine's Vulkan device, agc_driver_emulated_color_compare and agc_driver_shader_clock fail and agc_driver_flat_store and agc_driver_global_vcc_base time out, with or without this change.
• tools/check_conventions.py --base origin/main and tools/check_test_registration.py build pass.
• Windows: not built (no MinGW GCC 15 here). The Windows code is unchanged; only the #ifdef around NativeThreadArgs moved. A MinGW GCC 10 syntax check of Thread.cpp gives the same errors as main (all from that toolchain's old headers).

Overlap: tools/pr_overlap.py needs git merge-tree --write-tree (git 2.38+), so I checked the open PRs that touch Thread.cpp / Pthread.hpp by hand with git merge-tree. No open PR changes the Linux stack size.

• feat(libkernel): deliver sceKernelRaiseException on Linux #1431, fix(libkernel): keep Unity GC delivery out of MinGW TLS waits #1562, fix(libkernel): prevent TLS nullptr crash in scePthreadCreate #1746 and fix(libkernel): reject exception redirects during thread teardown #1802 rewrite the same std::thread block in scePthreadCreate, so whichever lands second needs a rebase. The conflicts are mechanical: their code moves into StartNativeThread / around pthread_create.
• feat(libkernel): deliver sceKernelRaiseException on Linux #1431 and fix(libkernel): reject exception redirects during thread teardown #1802 add pthread_t hostThread next to _thr for pthread_kill. This PR uses that name for the thread handle, so their uses keep working.
• fix(libkernel): prevent TLS nullptr crash in scePthreadCreate #1746 also changes SetStackFromHost to report the requested size, but it still runs threads on the host default stack.

Checklist

• Based on current main; no other open PR implements the same functions
• One topic per PR; follow-ups go in a new PR
• No comments in code except technical debt
• Unimplemented paths throw (NotImplemented_nid_no_patch); silent stubs are listed in TechnicalDebt
• No notes, investigation .md files or images added to the repository (attach them to this PR)
• New third-party code is a submodule built from source
• Generic behaviour, not specific to one title
• Depends on: none
• AI-assisted: yes (Claude Code)

🤖 Generated with Claude Code

[MarcZX10]

I reviewed the complete four-file diff. The Linux pthread_create stack sizing, startup synchronization, reported guest range, and coverage for 16 KiB–16 MiB requests with large TLS are internally consistent, and the test exercises both stack membership and recursion. I do not see upstream checks attached to this head yet. Please run the standard Build and Conventions workflows before requesting final review; the Windows build is useful here too because the thread startup structure and conditional header changed even though the Windows path is intended to remain behaviorally unchanged.

[popcoder565]

Windows build check, since the description says Windows wasn't built. Setup: Windows 10 (19045), MinGW-w64 GCC 15.2.0 (WinLibs r7), Release. Merged onto main 745b775 together with #1926, #1950, #1260 and #1988. Full ctest: 507/507.

It builds, and guest_pthread_stack passes.

🤖 Addressed by Claude Code

[oneandonlydean]

This conflicts with main after today's merges; could you rebase? It passed testing and is otherwise ready.

[adriadam10]

Rebased on current main, as requested. Two mechanical changes of ours on top:

• Thread.cpp: main now keeps the current guest thread in CurrentGuestState().current; adapted RunThread and the Linux ThreadGuard accordingly (conflict with the new CMakeLists.txt test entry resolved by keeping both).
• PthreadStart.cpp (new on main) used _thr, which no longer exists; it now checks pthread_equal(hostThread, pthread_self()).

Checked: build and the guest pthread/mutex/cond/semaphore tests pass 10 times in a row; guest_pthread_stack fails without the Thread.cpp/Pthread.hpp changes. Windows ctest confirmed earlier by @popcoder565. Merging once CI is green.