mirror of
https://github.com/RGBCube/serenity
synced 2025-07-27 22:17:44 +00:00
Kernel: Protect processes' master TLS with a fine-grained spinlock
This moves it out of the scope of the big process lock, and allows us to wean some syscalls off it, starting with sys$allocate_tls.
This commit is contained in:
parent
cd56ec6e5c
commit
6a4b93b3e0
7 changed files with 91 additions and 86 deletions
|
@ -431,9 +431,11 @@ Process::load(Memory::AddressSpace& new_space, NonnullRefPtr<OpenFileDescription
|
|||
|
||||
if (interpreter_description.is_null()) {
|
||||
auto load_result = TRY(load_elf_object(new_space, main_program_description, load_offset, ShouldAllocateTls::Yes, ShouldAllowSyscalls::No, minimum_stack_size));
|
||||
m_master_tls_region = load_result.tls_region;
|
||||
m_master_tls_size = load_result.tls_size;
|
||||
m_master_tls_alignment = load_result.tls_alignment;
|
||||
m_master_tls.with([&load_result](auto& master_tls) {
|
||||
master_tls.region = load_result.tls_region;
|
||||
master_tls.size = load_result.tls_size;
|
||||
master_tls.alignment = load_result.tls_alignment;
|
||||
});
|
||||
return load_result;
|
||||
}
|
||||
|
||||
|
@ -490,25 +492,26 @@ ErrorOr<void> Process::do_exec(NonnullRefPtr<OpenFileDescription> main_program_d
|
|||
|
||||
auto allocated_space = TRY(Memory::AddressSpace::try_create(*this, nullptr));
|
||||
OwnPtr<Memory::AddressSpace> old_space;
|
||||
auto old_master_tls_region = m_master_tls_region;
|
||||
auto old_master_tls_size = m_master_tls_size;
|
||||
auto old_master_tls_alignment = m_master_tls_alignment;
|
||||
auto old_master_tls = m_master_tls.with([](auto& master_tls) {
|
||||
auto old = master_tls;
|
||||
master_tls.region = nullptr;
|
||||
master_tls.size = 0;
|
||||
master_tls.alignment = 0;
|
||||
return old;
|
||||
});
|
||||
auto& new_space = m_space.with([&](auto& space) -> Memory::AddressSpace& {
|
||||
old_space = move(space);
|
||||
space = move(allocated_space);
|
||||
return *space;
|
||||
});
|
||||
m_master_tls_region = nullptr;
|
||||
m_master_tls_size = 0;
|
||||
m_master_tls_alignment = 0;
|
||||
ArmedScopeGuard space_guard([&]() {
|
||||
// If we failed at any point from now on we have to revert back to the old address space
|
||||
m_space.with([&](auto& space) {
|
||||
space = old_space.release_nonnull();
|
||||
});
|
||||
m_master_tls_region = old_master_tls_region;
|
||||
m_master_tls_size = old_master_tls_size;
|
||||
m_master_tls_alignment = old_master_tls_alignment;
|
||||
m_master_tls.with([&](auto& master_tls) {
|
||||
master_tls = old_master_tls;
|
||||
});
|
||||
Memory::MemoryManager::enter_process_address_space(*this);
|
||||
});
|
||||
|
||||
|
|
|
@ -158,21 +158,27 @@ ErrorOr<FlatPtr> Process::sys$fork(RegisterState& regs)
|
|||
#endif
|
||||
|
||||
TRY(address_space().with([&](auto& parent_space) {
|
||||
return child->address_space().with([&](auto& child_space) -> ErrorOr<void> {
|
||||
child_space->set_enforces_syscall_regions(parent_space->enforces_syscall_regions());
|
||||
for (auto& region : parent_space->region_tree().regions()) {
|
||||
dbgln_if(FORK_DEBUG, "fork: cloning Region '{}' @ {}", region.name(), region.vaddr());
|
||||
auto region_clone = TRY(region.try_clone());
|
||||
TRY(region_clone->map(child_space->page_directory(), Memory::ShouldFlushTLB::No));
|
||||
TRY(child_space->region_tree().place_specifically(*region_clone, region.range()));
|
||||
auto* child_region = region_clone.leak_ptr();
|
||||
return m_master_tls.with([&](auto& parent_master_tls) -> ErrorOr<void> {
|
||||
return child->address_space().with([&](auto& child_space) -> ErrorOr<void> {
|
||||
child_space->set_enforces_syscall_regions(parent_space->enforces_syscall_regions());
|
||||
for (auto& region : parent_space->region_tree().regions()) {
|
||||
dbgln_if(FORK_DEBUG, "fork: cloning Region '{}' @ {}", region.name(), region.vaddr());
|
||||
auto region_clone = TRY(region.try_clone());
|
||||
TRY(region_clone->map(child_space->page_directory(), Memory::ShouldFlushTLB::No));
|
||||
TRY(child_space->region_tree().place_specifically(*region_clone, region.range()));
|
||||
auto* child_region = region_clone.leak_ptr();
|
||||
|
||||
if (®ion == m_master_tls_region.unsafe_ptr()) {
|
||||
child->m_master_tls_region = TRY(child_region->try_make_weak_ptr());
|
||||
child->m_master_tls_size = m_master_tls_size;
|
||||
child->m_master_tls_alignment = m_master_tls_alignment;
|
||||
if (®ion == parent_master_tls.region.unsafe_ptr()) {
|
||||
TRY(child->m_master_tls.with([&](auto& child_master_tls) -> ErrorOr<void> {
|
||||
child_master_tls.region = TRY(child_region->try_make_weak_ptr());
|
||||
child_master_tls.size = parent_master_tls.size;
|
||||
child_master_tls.alignment = parent_master_tls.alignment;
|
||||
return {};
|
||||
}));
|
||||
}
|
||||
}
|
||||
}
|
||||
return {};
|
||||
});
|
||||
return {};
|
||||
});
|
||||
}));
|
||||
|
|
|
@ -524,50 +524,52 @@ ErrorOr<FlatPtr> Process::sys$mremap(Userspace<Syscall::SC_mremap_params const*>
|
|||
|
||||
ErrorOr<FlatPtr> Process::sys$allocate_tls(Userspace<char const*> initial_data, size_t size)
|
||||
{
|
||||
VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this);
|
||||
VERIFY_NO_PROCESS_BIG_LOCK(this);
|
||||
TRY(require_promise(Pledge::stdio));
|
||||
|
||||
if (!size || size % PAGE_SIZE != 0)
|
||||
return EINVAL;
|
||||
|
||||
if (!m_master_tls_region.is_null())
|
||||
return EEXIST;
|
||||
return m_master_tls.with([&](auto& master_tls) -> ErrorOr<FlatPtr> {
|
||||
if (!master_tls.region.is_null())
|
||||
return EEXIST;
|
||||
|
||||
if (thread_count() != 1)
|
||||
return EFAULT;
|
||||
if (thread_count() != 1)
|
||||
return EFAULT;
|
||||
|
||||
Thread* main_thread = nullptr;
|
||||
bool multiple_threads = false;
|
||||
for_each_thread([&main_thread, &multiple_threads](auto& thread) {
|
||||
if (main_thread)
|
||||
multiple_threads = true;
|
||||
main_thread = &thread;
|
||||
return IterationDecision::Break;
|
||||
});
|
||||
VERIFY(main_thread);
|
||||
Thread* main_thread = nullptr;
|
||||
bool multiple_threads = false;
|
||||
for_each_thread([&main_thread, &multiple_threads](auto& thread) {
|
||||
if (main_thread)
|
||||
multiple_threads = true;
|
||||
main_thread = &thread;
|
||||
return IterationDecision::Break;
|
||||
});
|
||||
VERIFY(main_thread);
|
||||
|
||||
if (multiple_threads)
|
||||
return EINVAL;
|
||||
if (multiple_threads)
|
||||
return EINVAL;
|
||||
|
||||
return address_space().with([&](auto& space) -> ErrorOr<FlatPtr> {
|
||||
auto* region = TRY(space->allocate_region(Memory::RandomizeVirtualAddress::Yes, {}, size, PAGE_SIZE, "Master TLS"sv, PROT_READ | PROT_WRITE));
|
||||
return address_space().with([&](auto& space) -> ErrorOr<FlatPtr> {
|
||||
auto* region = TRY(space->allocate_region(Memory::RandomizeVirtualAddress::Yes, {}, size, PAGE_SIZE, "Master TLS"sv, PROT_READ | PROT_WRITE));
|
||||
|
||||
m_master_tls_region = TRY(region->try_make_weak_ptr());
|
||||
m_master_tls_size = size;
|
||||
m_master_tls_alignment = PAGE_SIZE;
|
||||
master_tls.region = TRY(region->try_make_weak_ptr());
|
||||
master_tls.size = size;
|
||||
master_tls.alignment = PAGE_SIZE;
|
||||
|
||||
{
|
||||
Kernel::SmapDisabler disabler;
|
||||
void* fault_at;
|
||||
if (!Kernel::safe_memcpy((char*)m_master_tls_region.unsafe_ptr()->vaddr().as_ptr(), (char*)initial_data.ptr(), size, fault_at))
|
||||
return EFAULT;
|
||||
}
|
||||
{
|
||||
Kernel::SmapDisabler disabler;
|
||||
void* fault_at;
|
||||
if (!Kernel::safe_memcpy((char*)master_tls.region.unsafe_ptr()->vaddr().as_ptr(), (char*)initial_data.ptr(), size, fault_at))
|
||||
return EFAULT;
|
||||
}
|
||||
|
||||
TRY(main_thread->make_thread_specific_region({}));
|
||||
TRY(main_thread->make_thread_specific_region({}));
|
||||
|
||||
Processor::set_thread_specific_data(main_thread->thread_specific_data());
|
||||
Processor::set_thread_specific_data(main_thread->thread_specific_data());
|
||||
|
||||
return m_master_tls_region.unsafe_ptr()->vaddr().get();
|
||||
return master_tls.region.unsafe_ptr()->vaddr().get();
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue