RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 05:07:35 +00:00
Code Issues Activity Actions

Kernel: PID/TID typing

Browse source 
This compiles, and contains exactly the same bugs as before.
The regex 'FIXME: PID/' should reveal all markers that I left behind, including:
- Incomplete conversion
- Issues or things that look fishy
- Actual bugs that will go wrong during runtime
This commit is contained in:
Ben Wiederhake 2020-08-08 17:32:34 +02:00 • committed by Andreas Kling
parent f225321184
commit f5744a6f2f
26 changed files with 136 additions and 111 deletions
Download patch file Download diff file Expand all files Collapse all files

22
Kernel/FileSystem/ProcFS.cpp
View file

@ -123,7 +123,7 @@ enum ProcFileType {
FI_MaxStaticFileIndex, FI_MaxStaticFileIndex,
}; };
static inline pid_t to_pid(const InodeIdentifier& identifier) static inline ProcessID to_pid(const InodeIdentifier& identifier)
{ {
#ifdef PROCFS_DEBUG #ifdef PROCFS_DEBUG
dbg() << "to_pid, index=" << String::format("%08x", identifier.index()) << " -> " << (identifier.index() >> 16); dbg() << "to_pid, index=" << String::format("%08x", identifier.index()) << " -> " << (identifier.index() >> 16);
@ -154,14 +154,14 @@ static inline size_t to_sys_index(const InodeIdentifier& identifier)
return identifier.index() >> 16u; return identifier.index() >> 16u;
} }
static inline InodeIdentifier to_identifier(unsigned fsid, ProcParentDirectory parent, pid_t pid, ProcFileType proc_file_type) static inline InodeIdentifier to_identifier(unsigned fsid, ProcParentDirectory parent, ProcessID pid, ProcFileType proc_file_type)
{ {
return { fsid, ((unsigned)parent << 12u) | ((unsigned)pid << 16u) | (unsigned)proc_file_type }; return { fsid, ((unsigned)parent << 12u) | ((unsigned)pid.value() << 16u) | (unsigned)proc_file_type };
} }
static inline InodeIdentifier to_identifier_with_fd(unsigned fsid, pid_t pid, int fd) static inline InodeIdentifier to_identifier_with_fd(unsigned fsid, ProcessID pid, int fd)
{ {
return { fsid, (PDI_PID_fd << 12u) | ((unsigned)pid << 16u) | (FI_MaxStaticFileIndex + fd) }; return { fsid, (PDI_PID_fd << 12u) | ((unsigned)pid.value() << 16u) | (FI_MaxStaticFileIndex + fd) };
} }
static inline InodeIdentifier sys_var_to_identifier(unsigned fsid, unsigned index) static inline InodeIdentifier sys_var_to_identifier(unsigned fsid, unsigned index)
@ -663,7 +663,7 @@ Optional<KBuffer> procfs$pid_root(InodeIdentifier identifier)
Optional<KBuffer> procfs$self(InodeIdentifier) Optional<KBuffer> procfs$self(InodeIdentifier)
{ {
char buffer[16]; char buffer[16];
sprintf(buffer, "%u", Process::current()->pid()); sprintf(buffer, "%d", Process::current()->pid().value());
return KBuffer::copy((const u8*)buffer, strlen(buffer)); return KBuffer::copy((const u8*)buffer, strlen(buffer));
} }
@ -821,13 +821,13 @@ Optional<KBuffer> procfs$all(InodeIdentifier)
break; break;
} }
process_object.add("pid", process.pid()); process_object.add("pid", process.pid().value());
process_object.add("pgid", process.tty() ? process.tty()->pgid() : 0); process_object.add("pgid", process.tty() ? process.tty()->pgid() : 0);
process_object.add("pgp", process.pgid()); process_object.add("pgp", process.pgid());
process_object.add("sid", process.sid()); process_object.add("sid", process.sid());
process_object.add("uid", process.uid()); process_object.add("uid", process.uid());
process_object.add("gid", process.gid()); process_object.add("gid", process.gid());
process_object.add("ppid", process.ppid()); process_object.add("ppid", process.ppid().value());
process_object.add("nfds", process.number_of_open_file_descriptors()); process_object.add("nfds", process.number_of_open_file_descriptors());
process_object.add("name", process.name()); process_object.add("name", process.name());
process_object.add("tty", process.tty() ? process.tty()->tty_name() : "notty"); process_object.add("tty", process.tty() ? process.tty()->tty_name() : "notty");
@ -842,7 +842,7 @@ Optional<KBuffer> procfs$all(InodeIdentifier)
auto thread_array = process_object.add_array("threads"); auto thread_array = process_object.add_array("threads");
process.for_each_thread([&](const Thread& thread) { process.for_each_thread([&](const Thread& thread) {
auto thread_object = thread_array.add_object(); auto thread_object = thread_array.add_object();
thread_object.add("tid", thread.tid()); thread_object.add("tid", thread.tid().value());
thread_object.add("name", thread.name()); thread_object.add("name", thread.name());
thread_object.add("times_scheduled", thread.times_scheduled()); thread_object.add("times_scheduled", thread.times_scheduled());
thread_object.add("ticks", thread.ticks()); thread_object.add("ticks", thread.ticks());
@ -1227,7 +1227,7 @@ KResult ProcFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntr
} }
for (auto pid_child : Process::all_pids()) { for (auto pid_child : Process::all_pids()) {
char name[16]; char name[16];
size_t name_length = (size_t)sprintf(name, "%u", pid_child); size_t name_length = (size_t)sprintf(name, "%d", pid_child.value());
callback({ name, name_length, to_identifier(fsid(), PDI_Root, pid_child, FI_PID), 0 }); callback({ name, name_length, to_identifier(fsid(), PDI_Root, pid_child, FI_PID), 0 });
} }
break; break;
@ -1270,7 +1270,7 @@ KResult ProcFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntr
if (!description) if (!description)
continue; continue;
char name[16]; char name[16];
size_t name_length = (size_t)sprintf(name, "%u", i); size_t name_length = (size_t)sprintf(name, "%d", i);
callback({ name, name_length, to_identifier_with_fd(fsid(), pid, i), 0 }); callback({ name, name_length, to_identifier_with_fd(fsid(), pid, i), 0 });
} }
} break; } break;

4
Kernel/Net/Socket.cpp
View file

@ -56,7 +56,7 @@ Socket::Socket(int domain, int type, int protocol)
, m_protocol(protocol) , m_protocol(protocol)
{ {
auto& process = *Process::current(); auto& process = *Process::current();
m_origin = { process.pid(), process.uid(), process.gid() }; m_origin = { process.pid().value(), process.uid(), process.gid() };
} }
Socket::~Socket() Socket::~Socket()
@ -83,7 +83,7 @@ RefPtr<Socket> Socket::accept()
auto client = m_pending.take_first(); auto client = m_pending.take_first();
ASSERT(!client->is_connected()); ASSERT(!client->is_connected());
auto& process = *Process::current(); auto& process = *Process::current();
client->m_acceptor = { process.pid(), process.uid(), process.gid() }; client->m_acceptor = { process.pid().value(), process.uid(), process.gid() };
client->m_connected = true; client->m_connected = true;
client->m_role = Role::Accepted; client->m_role = Role::Accepted;
return client; return client;

4
Kernel/PerformanceEventBuffer.cpp
View file

@ -94,12 +94,12 @@ PerformanceEvent& PerformanceEventBuffer::at(size_t index)
return events[index]; return events[index];
} }
KBuffer PerformanceEventBuffer::to_json(pid_t pid, const String& executable_path) const KBuffer PerformanceEventBuffer::to_json(ProcessID pid, const String& executable_path) const
{ {
KBufferBuilder builder; KBufferBuilder builder;
JsonObjectSerializer object(builder); JsonObjectSerializer object(builder);
object.add("pid", pid); object.add("pid", pid.value());
object.add("executable", executable_path); object.add("executable", executable_path);
auto array = object.add_array("events"); auto array = object.add_array("events");

2
Kernel/PerformanceEventBuffer.h
View file

@ -68,7 +68,7 @@ public:
return const_cast<PerformanceEventBuffer&>(*this).at(index); return const_cast<PerformanceEventBuffer&>(*this).at(index);
} }
KBuffer to_json(pid_t, const String& executable_path) const; KBuffer to_json(ProcessID, const String& executable_path) const;
private: private:
PerformanceEvent& at(size_t index); PerformanceEvent& at(size_t index);

29
Kernel/Process.cpp
View file

@ -95,8 +95,12 @@ Lock* g_hostname_lock;
VirtualAddress g_return_to_ring3_from_signal_trampoline; VirtualAddress g_return_to_ring3_from_signal_trampoline;
HashMap<String, OwnPtr<Module>>* g_modules; HashMap<String, OwnPtr<Module>>* g_modules;
pid_t Process::allocate_pid() ProcessID Process::allocate_pid()
{ {
// Overflow is UB, and negative PIDs wreck havoc.
// TODO: Handle PID overflow
// For example: Use an Atomic<u32>, mask the most significant bit,
// retry if PID is already taken as a PID, taken as a TID, or zero.
return next_pid.fetch_add(1, AK::MemoryOrder::memory_order_acq_rel); return next_pid.fetch_add(1, AK::MemoryOrder::memory_order_acq_rel);
} }
@ -112,9 +116,9 @@ void Process::initialize()
create_signal_trampolines(); create_signal_trampolines();
} }
Vector<pid_t> Process::all_pids() Vector<ProcessID> Process::all_pids()
{ {
Vector<pid_t> pids; Vector<ProcessID> pids;
ScopedSpinLock lock(g_processes_lock); ScopedSpinLock lock(g_processes_lock);
pids.ensure_capacity((int)g_processes->size_slow()); pids.ensure_capacity((int)g_processes->size_slow());
for (auto& process : *g_processes) for (auto& process : *g_processes)
@ -286,7 +290,7 @@ void Process::kill_all_threads()
}); });
} }
RefPtr<Process> Process::create_user_process(Thread*& first_thread, const String& path, uid_t uid, gid_t gid, pid_t parent_pid, int& error, Vector<String>&& arguments, Vector<String>&& environment, TTY* tty) RefPtr<Process> Process::create_user_process(Thread*& first_thread, const String& path, uid_t uid, gid_t gid, ProcessID parent_pid, int& error, Vector<String>&& arguments, Vector<String>&& environment, TTY* tty)
{ {
auto parts = path.split('/'); auto parts = path.split('/');
if (arguments.is_empty()) { if (arguments.is_empty()) {
@ -334,7 +338,7 @@ RefPtr<Process> Process::create_user_process(Thread*& first_thread, const String
NonnullRefPtr<Process> Process::create_kernel_process(Thread*& first_thread, String&& name, void (*e)(), u32 affinity) NonnullRefPtr<Process> Process::create_kernel_process(Thread*& first_thread, String&& name, void (*e)(), u32 affinity)
{ {
auto process = adopt(*new Process(first_thread, move(name), (uid_t)0, (gid_t)0, (pid_t)0, Ring0)); auto process = adopt(*new Process(first_thread, move(name), (uid_t)0, (gid_t)0, ProcessID(0), Ring0));
first_thread->tss().eip = (FlatPtr)e; first_thread->tss().eip = (FlatPtr)e;
if (process->pid() != 0) { if (process->pid() != 0) {
@ -348,7 +352,7 @@ NonnullRefPtr<Process> Process::create_kernel_process(Thread*& first_thread, Str
return process; return process;
} }
Process::Process(Thread*& first_thread, const String& name, uid_t uid, gid_t gid, pid_t ppid, RingLevel ring, RefPtr<Custody> cwd, RefPtr<Custody> executable, TTY* tty, Process* fork_parent) Process::Process(Thread*& first_thread, const String& name, uid_t uid, gid_t gid, ProcessID ppid, RingLevel ring, RefPtr<Custody> cwd, RefPtr<Custody> executable, TTY* tty, Process* fork_parent)
: m_name(move(name)) : m_name(move(name))
, m_pid(allocate_pid()) , m_pid(allocate_pid())
, m_euid(uid) , m_euid(uid)
@ -473,10 +477,11 @@ void Process::crash(int signal, u32 eip, bool out_of_memory)
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
} }
RefPtr<Process> Process::from_pid(pid_t pid) RefPtr<Process> Process::from_pid(ProcessID pid)
{ {
ScopedSpinLock lock(g_processes_lock); ScopedSpinLock lock(g_processes_lock);
for (auto& process : *g_processes) { for (auto& process : *g_processes) {
process.pid();
if (process.pid() == pid) if (process.pid() == pid)
return &process; return &process;
} }
@ -553,7 +558,7 @@ siginfo_t Process::reap(Process& process)
siginfo_t siginfo; siginfo_t siginfo;
memset(&siginfo, 0, sizeof(siginfo)); memset(&siginfo, 0, sizeof(siginfo));
siginfo.si_signo = SIGCHLD; siginfo.si_signo = SIGCHLD;
siginfo.si_pid = process.pid(); siginfo.si_pid = process.pid().value();
siginfo.si_uid = process.uid(); siginfo.si_uid = process.uid();
if (process.m_termination_signal) { if (process.m_termination_signal) {
@ -566,7 +571,7 @@ siginfo_t Process::reap(Process& process)
ASSERT(g_processes_lock.is_locked()); ASSERT(g_processes_lock.is_locked());
if (process.ppid()) { if (!!process.ppid()) {
auto parent = Process::from_pid(process.ppid()); auto parent = Process::from_pid(process.ppid());
if (parent) { if (parent) {
parent->m_ticks_in_user_for_dead_children += process.m_ticks_in_user + process.m_ticks_in_user_for_dead_children; parent->m_ticks_in_user_for_dead_children += process.m_ticks_in_user + process.m_ticks_in_user_for_dead_children;
@ -654,7 +659,8 @@ void Process::finalize()
disown_all_shared_buffers(); disown_all_shared_buffers();
{ {
InterruptDisabler disabler; InterruptDisabler disabler;
if (auto* parent_thread = Thread::from_tid(m_ppid)) { // FIXME: PID/TID BUG
if (auto* parent_thread = Thread::from_tid(m_ppid.value())) {
if (parent_thread->m_signal_action_data[SIGCHLD].flags & SA_NOCLDWAIT) { if (parent_thread->m_signal_action_data[SIGCHLD].flags & SA_NOCLDWAIT) {
// NOTE: If the parent doesn't care about this process, let it go. // NOTE: If the parent doesn't care about this process, let it go.
m_ppid = 0; m_ppid = 0;
@ -783,7 +789,8 @@ void Process::terminate_due_to_signal(u8 signal)
KResult Process::send_signal(u8 signal, Process* sender) KResult Process::send_signal(u8 signal, Process* sender)
{ {
InterruptDisabler disabler; InterruptDisabler disabler;
if (auto* thread = Thread::from_tid(m_pid)) { // FIXME: PID/TID BUG
if (auto* thread = Thread::from_tid(m_pid.value())) {
thread->send_signal(signal, sender); thread->send_signal(signal, sender);
return KSuccess; return KSuccess;
} }

41
Kernel/Process.h
View file

@ -126,10 +126,10 @@ public:
} }
static NonnullRefPtr<Process> create_kernel_process(Thread*& first_thread, String&& name, void (*entry)(), u32 affinity = THREAD_AFFINITY_DEFAULT); static NonnullRefPtr<Process> create_kernel_process(Thread*& first_thread, String&& name, void (*entry)(), u32 affinity = THREAD_AFFINITY_DEFAULT);
static RefPtr<Process> create_user_process(Thread*& first_thread, const String& path, uid_t, gid_t, pid_t ppid, int& error, Vector<String>&& arguments = Vector<String>(), Vector<String>&& environment = Vector<String>(), TTY* = nullptr); static RefPtr<Process> create_user_process(Thread*& first_thread, const String& path, uid_t, gid_t, ProcessID ppid, int& error, Vector<String>&& arguments = Vector<String>(), Vector<String>&& environment = Vector<String>(), TTY* = nullptr);
~Process(); ~Process();
static Vector<pid_t> all_pids(); static Vector<ProcessID> all_pids();
static AK::NonnullRefPtrVector<Process> all_processes(); static AK::NonnullRefPtrVector<Process> all_processes();
Thread* create_kernel_thread(void (*entry)(), u32 priority, const String& name, u32 affinity = THREAD_AFFINITY_DEFAULT, bool joinable = true); Thread* create_kernel_thread(void (*entry)(), u32 priority, const String& name, u32 affinity = THREAD_AFFINITY_DEFAULT, bool joinable = true);
@ -152,10 +152,10 @@ public:
PageDirectory& page_directory() { return *m_page_directory; } PageDirectory& page_directory() { return *m_page_directory; }
const PageDirectory& page_directory() const { return *m_page_directory; } const PageDirectory& page_directory() const { return *m_page_directory; }
static RefPtr<Process> from_pid(pid_t); static RefPtr<Process> from_pid(ProcessID);
const String& name() const { return m_name; } const String& name() const { return m_name; }
pid_t pid() const { return m_pid; } ProcessID pid() const { return m_pid; }
pid_t sid() const { return m_sid; } pid_t sid() const { return m_sid; }
pid_t pgid() const { return m_pgid; } pid_t pgid() const { return m_pgid; }
const FixedArray<gid_t>& extra_gids() const { return m_extra_gids; } const FixedArray<gid_t>& extra_gids() const { return m_extra_gids; }
@ -165,9 +165,9 @@ public:
gid_t gid() const { return m_gid; } gid_t gid() const { return m_gid; }
uid_t suid() const { return m_suid; } uid_t suid() const { return m_suid; }
gid_t sgid() const { return m_sgid; } gid_t sgid() const { return m_sgid; }
pid_t ppid() const { return m_ppid; } ProcessID ppid() const { return m_ppid; }
pid_t exec_tid() const { return m_exec_tid; } ThreadID exec_tid() const { return m_exec_tid; }
mode_t umask() const { return m_umask; } mode_t umask() const { return m_umask; }
@ -224,7 +224,7 @@ public:
int sys$fstat(int fd, stat*); int sys$fstat(int fd, stat*);
int sys$stat(Userspace<const Syscall::SC_stat_params*>); int sys$stat(Userspace<const Syscall::SC_stat_params*>);
int sys$lseek(int fd, off_t, int whence); int sys$lseek(int fd, off_t, int whence);
int sys$kill(pid_t pid, int sig); int sys$kill(pid_t pid_or_pgid, int sig);
[[noreturn]] void sys$exit(int status); [[noreturn]] void sys$exit(int status);
int sys$sigreturn(RegisterState& registers); int sys$sigreturn(RegisterState& registers);
pid_t sys$waitid(Userspace<const Syscall::SC_waitid_params*>); pid_t sys$waitid(Userspace<const Syscall::SC_waitid_params*>);
@ -263,7 +263,7 @@ public:
int sys$getgroups(ssize_t, gid_t*); int sys$getgroups(ssize_t, gid_t*);
int sys$setgroups(ssize_t, const gid_t*); int sys$setgroups(ssize_t, const gid_t*);
int sys$pipe(int pipefd[2], int flags); int sys$pipe(int pipefd[2], int flags);
int sys$killpg(int pgrp, int sig); int sys$killpg(pid_t pgrp, int sig);
int sys$seteuid(uid_t); int sys$seteuid(uid_t);
int sys$setegid(gid_t); int sys$setegid(gid_t);
int sys$setuid(uid_t); int sys$setuid(uid_t);
@ -338,7 +338,7 @@ public:
int sys$sendfd(int sockfd, int fd); int sys$sendfd(int sockfd, int fd);
int sys$recvfd(int sockfd); int sys$recvfd(int sockfd);
long sys$sysconf(int name); long sys$sysconf(int name);
int sys$disown(pid_t); int sys$disown(ProcessID);
template<bool sockname, typename Params> template<bool sockname, typename Params>
int get_sock_or_peer_name(const Params&); int get_sock_or_peer_name(const Params&);
@ -574,8 +574,8 @@ private:
friend class Scheduler; friend class Scheduler;
friend class Region; friend class Region;
Process(Thread*& first_thread, const String& name, uid_t, gid_t, pid_t ppid, RingLevel, RefPtr<Custody> cwd = nullptr, RefPtr<Custody> executable = nullptr, TTY* = nullptr, Process* fork_parent = nullptr); Process(Thread*& first_thread, const String& name, uid_t, gid_t, ProcessID ppid, RingLevel, RefPtr<Custody> cwd = nullptr, RefPtr<Custody> executable = nullptr, TTY* = nullptr, Process* fork_parent = nullptr);
static pid_t allocate_pid(); static ProcessID allocate_pid();
Range allocate_range(VirtualAddress, size_t, size_t alignment = PAGE_SIZE); Range allocate_range(VirtualAddress, size_t, size_t alignment = PAGE_SIZE);
@ -607,7 +607,7 @@ private:
} }
KResultOr<String> get_syscall_path_argument(const Syscall::StringArgument&) const; KResultOr<String> get_syscall_path_argument(const Syscall::StringArgument&) const;
bool has_tracee_thread(int tracer_pid) const; bool has_tracee_thread(ProcessID tracer_pid) const;
RefPtr<PageDirectory> m_page_directory; RefPtr<PageDirectory> m_page_directory;
@ -616,7 +616,7 @@ private:
String m_name; String m_name;
pid_t m_pid { 0 }; ProcessID m_pid { 0 };
pid_t m_sid { 0 }; pid_t m_sid { 0 };
pid_t m_pgid { 0 }; pid_t m_pgid { 0 };
@ -627,7 +627,7 @@ private:
uid_t m_suid { 0 }; uid_t m_suid { 0 };
gid_t m_sgid { 0 }; gid_t m_sgid { 0 };
pid_t m_exec_tid { 0 }; ThreadID m_exec_tid { 0 };
FlatPtr m_load_offset { 0U }; FlatPtr m_load_offset { 0U };
FlatPtr m_entry_eip { 0U }; FlatPtr m_entry_eip { 0U };
@ -677,7 +677,7 @@ private:
}; };
RegionLookupCache m_region_lookup_cache; RegionLookupCache m_region_lookup_cache;
pid_t m_ppid { 0 }; ProcessID m_ppid { 0 };
mode_t m_umask { 022 }; mode_t m_umask { 022 };
FixedArray<gid_t> m_extra_gids; FixedArray<gid_t> m_extra_gids;
@ -732,11 +732,12 @@ template<typename Callback>
inline void Process::for_each_child(Callback callback) inline void Process::for_each_child(Callback callback)
{ {
ASSERT_INTERRUPTS_DISABLED(); ASSERT_INTERRUPTS_DISABLED();
pid_t my_pid = pid(); ProcessID my_pid = pid();
ScopedSpinLock lock(g_processes_lock); ScopedSpinLock lock(g_processes_lock);
for (auto* process = g_processes->head(); process;) { for (auto* process = g_processes->head(); process;) {
auto* next_process = process->next(); auto* next_process = process->next();
if (process->ppid() == my_pid || process->has_tracee_thread(m_pid)) { // FIXME: PID/TID BUG
if (process->ppid() == my_pid || process->has_tracee_thread(m_pid.value())) {
if (callback(*process) == IterationDecision::Break) if (callback(*process) == IterationDecision::Break)
break; break;
} }
@ -748,7 +749,7 @@ template<typename Callback>
inline void Process::for_each_thread(Callback callback) const inline void Process::for_each_thread(Callback callback) const
{ {
InterruptDisabler disabler; InterruptDisabler disabler;
pid_t my_pid = pid(); ProcessID my_pid = pid();
if (my_pid == 0) { if (my_pid == 0) {
// NOTE: Special case the colonel process, since its main thread is not in the global thread table. // NOTE: Special case the colonel process, since its main thread is not in the global thread table.
@ -800,14 +801,14 @@ inline bool InodeMetadata::may_execute(const Process& process) const
return may_execute(process.euid(), process.egid(), process.extra_gids()); return may_execute(process.euid(), process.egid(), process.extra_gids());
} }
inline int Thread::pid() const inline ProcessID Thread::pid() const
{ {
return m_process->pid(); return m_process->pid();
} }
inline const LogStream& operator<<(const LogStream& stream, const Process& process) inline const LogStream& operator<<(const LogStream& stream, const Process& process)
{ {
return stream << process.name() << '(' << process.pid() << ')'; return stream << process.name() << '(' << process.pid().value() << ')';
} }
inline u32 Thread::effective_priority() const inline u32 Thread::effective_priority() const

2
Kernel/Profiling.cpp
View file

@ -61,7 +61,7 @@ void start(Process& process)
executable_path() = process.executable()->absolute_path().impl(); executable_path() = process.executable()->absolute_path().impl();
else else
executable_path() = {}; executable_path() = {};
s_pid = process.pid(); s_pid = process.pid().value(); // FIXME: PID/TID INCOMPLETE
if (!s_profiling_buffer) { if (!s_profiling_buffer) {
s_profiling_buffer = RefPtr<KBufferImpl>(KBuffer::create_with_size(8 * MB).impl()).leak_ref(); s_profiling_buffer = RefPtr<KBufferImpl>(KBuffer::create_with_size(8 * MB).impl()).leak_ref();

2
Kernel/Ptrace.cpp
View file

@ -43,7 +43,7 @@ KResultOr<u32> handle_syscall(const Kernel::Syscall::SC_ptrace_params& params, P
return KSuccess; return KSuccess;
} }
if (params.pid == caller.pid()) if (params.pid == caller.pid().value())
return KResult(-EINVAL); return KResult(-EINVAL);
Thread* peer = nullptr; Thread* peer = nullptr;

16
Kernel/Scheduler.cpp
View file

@ -136,7 +136,7 @@ Thread::WriteBlocker::WriteBlocker(const FileDescription& description)
timespec* Thread::WriteBlocker::override_timeout(timespec* timeout) timespec* Thread::WriteBlocker::override_timeout(timespec* timeout)
{ {
auto& description = blocked_description(); auto& description = blocked_description();
if (description.is_socket()) { if (description.is_socket()) {
auto& socket = *description.socket(); auto& socket = *description.socket();
if (socket.has_send_timeout()) { if (socket.has_send_timeout()) {
@ -227,7 +227,7 @@ bool Thread::SelectBlocker::should_unblock(Thread& thread)
return false; return false;
} }
Thread::WaitBlocker::WaitBlocker(int wait_options, pid_t& waitee_pid) Thread::WaitBlocker::WaitBlocker(int wait_options, ProcessID& waitee_pid)
: m_wait_options(wait_options) : m_wait_options(wait_options)
, m_waitee_pid(waitee_pid) , m_waitee_pid(waitee_pid)
{ {
@ -296,8 +296,7 @@ void Thread::consider_unblock(time_t now_sec, long now_usec)
case Thread::Dying: case Thread::Dying:
/* don't know, don't care */ /* don't know, don't care */
return; return;
case Thread::Blocked: case Thread::Blocked: {
{
ASSERT(m_blocker != nullptr); ASSERT(m_blocker != nullptr);
timespec now; timespec now;
now.tv_sec = now_sec, now.tv_sec = now_sec,
@ -378,7 +377,7 @@ bool Scheduler::pick_next()
auto name = process.name(); auto name = process.name();
auto pid = process.pid(); auto pid = process.pid();
auto exit_status = Process::reap(process); auto exit_status = Process::reap(process);
dbg() << "Scheduler[" << Processor::current().id() << "]: Reaped unparented process " << name << "(" << pid << "), exit status: " << exit_status.si_status; dbg() << "Scheduler[" << Processor::current().id() << "]: Reaped unparented process " << name << "(" << pid.value() << "), exit status: " << exit_status.si_status;
} }
return IterationDecision::Continue; return IterationDecision::Continue;
} }
@ -496,7 +495,7 @@ bool Scheduler::yield()
bool Scheduler::donate_to(Thread* beneficiary, const char* reason) bool Scheduler::donate_to(Thread* beneficiary, const char* reason)
{ {
ASSERT(beneficiary); ASSERT(beneficiary);
// Set the m_in_scheduler flag before acquiring the spinlock. This // Set the m_in_scheduler flag before acquiring the spinlock. This
// prevents a recursive call into Scheduler::invoke_async upon // prevents a recursive call into Scheduler::invoke_async upon
// leaving the scheduler lock. // leaving the scheduler lock.
@ -685,8 +684,9 @@ void Scheduler::timer_tick(const RegisterState& regs)
SmapDisabler disabler; SmapDisabler disabler;
auto backtrace = current_thread->raw_backtrace(regs.ebp, regs.eip); auto backtrace = current_thread->raw_backtrace(regs.ebp, regs.eip);
auto& sample = Profiling::next_sample_slot(); auto& sample = Profiling::next_sample_slot();
sample.pid = current_thread->process().pid(); // FIXME: PID/TID INCOMPLETE
sample.tid = current_thread->tid(); sample.pid = current_thread->process().pid().value();
sample.tid = current_thread->tid().value();
sample.timestamp = g_uptime; sample.timestamp = g_uptime;
for (size_t i = 0; i < min(backtrace.size(), Profiling::max_stack_frame_count); ++i) { for (size_t i = 0; i < min(backtrace.size(), Profiling::max_stack_frame_count); ++i) {
sample.frames[i] = backtrace[i]; sample.frames[i] = backtrace[i];

8
Kernel/SharedBuffer.cpp
View file

@ -48,13 +48,13 @@ void SharedBuffer::sanity_check(const char* what)
if (found_refs != m_total_refs) { if (found_refs != m_total_refs) {
dbg() << what << " sanity -- SharedBuffer{" << this << "} id: " << m_shbuf_id << " has total refs " << m_total_refs << " but we found " << found_refs; dbg() << what << " sanity -- SharedBuffer{" << this << "} id: " << m_shbuf_id << " has total refs " << m_total_refs << " but we found " << found_refs;
for (const auto& ref : m_refs) { for (const auto& ref : m_refs) {
dbg() << " ref from pid " << ref.pid << ": refcnt " << ref.count; dbg() << " ref from pid " << ref.pid.value() << ": refcnt " << ref.count;
} }
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
} }
} }
bool SharedBuffer::is_shared_with(pid_t peer_pid) const bool SharedBuffer::is_shared_with(ProcessID peer_pid) const
{ {
LOCKER(shared_buffers().lock(), Lock::Mode::Shared); LOCKER(shared_buffers().lock(), Lock::Mode::Shared);
if (m_global) if (m_global)
@ -102,7 +102,7 @@ void* SharedBuffer::ref_for_process_and_get_address(Process& process)
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
} }
void SharedBuffer::share_with(pid_t peer_pid) void SharedBuffer::share_with(ProcessID peer_pid)
{ {
LOCKER(shared_buffers().lock()); LOCKER(shared_buffers().lock());
if (m_global) if (m_global)
@ -146,7 +146,7 @@ void SharedBuffer::deref_for_process(Process& process)
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
} }
void SharedBuffer::disown(pid_t pid) void SharedBuffer::disown(ProcessID pid)
{ {
LOCKER(shared_buffers().lock()); LOCKER(shared_buffers().lock());
for (size_t i = 0; i < m_refs.size(); ++i) { for (size_t i = 0; i < m_refs.size(); ++i) {

10
Kernel/SharedBuffer.h
View file

@ -36,12 +36,12 @@ namespace Kernel {
class SharedBuffer { class SharedBuffer {
private: private:
struct Reference { struct Reference {
Reference(pid_t pid) Reference(ProcessID pid)
: pid(pid) : pid(pid)
{ {
} }
pid_t pid; ProcessID pid;
unsigned count { 0 }; unsigned count { 0 };
WeakPtr<Region> region; WeakPtr<Region> region;
}; };
@ -64,12 +64,12 @@ public:
} }
void sanity_check(const char* what); void sanity_check(const char* what);
bool is_shared_with(pid_t peer_pid) const; bool is_shared_with(ProcessID peer_pid) const;
void* ref_for_process_and_get_address(Process& process); void* ref_for_process_and_get_address(Process& process);
void share_with(pid_t peer_pid); void share_with(ProcessID peer_pid);
void share_globally() { m_global = true; } void share_globally() { m_global = true; }
void deref_for_process(Process& process); void deref_for_process(Process& process);
void disown(pid_t pid); void disown(ProcessID pid);
size_t size() const { return m_vmobject->size(); } size_t size() const { return m_vmobject->size(); }
void destroy_if_unused(); void destroy_if_unused();
void seal(); void seal();

2
Kernel/Syscalls/disown.cpp
View file

@ -28,7 +28,7 @@
namespace Kernel { namespace Kernel {
int Process::sys$disown(pid_t pid) int Process::sys$disown(ProcessID pid)
{ {
REQUIRE_PROMISE(proc); REQUIRE_PROMISE(proc);
auto process = Process::from_pid(pid); auto process = Process::from_pid(pid);

5
Kernel/Syscalls/execve.cpp
View file

@ -282,7 +282,8 @@ int Process::do_exec(NonnullRefPtr<FileDescription> main_program_description, Ve
m_master_tls_size = master_tls_size; m_master_tls_size = master_tls_size;
m_master_tls_alignment = master_tls_alignment; m_master_tls_alignment = master_tls_alignment;
m_pid = new_main_thread->tid(); // FIXME: PID/TID BUG
m_pid = new_main_thread->tid().value();
new_main_thread->make_thread_specific_region({}); new_main_thread->make_thread_specific_region({});
new_main_thread->reset_fpu_state(); new_main_thread->reset_fpu_state();
@ -296,7 +297,7 @@ int Process::do_exec(NonnullRefPtr<FileDescription> main_program_description, Ve
tss.eip = m_entry_eip; tss.eip = m_entry_eip;
tss.esp = new_userspace_esp; tss.esp = new_userspace_esp;
tss.cr3 = m_page_directory->cr3(); tss.cr3 = m_page_directory->cr3();
tss.ss2 = m_pid; tss.ss2 = m_pid.value();
if (was_profiling) if (was_profiling)
Profiling::did_exec(path); Profiling::did_exec(path);

2
Kernel/Syscalls/fork.cpp
View file

@ -95,7 +95,7 @@ pid_t Process::sys$fork(RegisterState& regs)
} }
child_first_thread->set_state(Thread::State::Skip1SchedulerPass); child_first_thread->set_state(Thread::State::Skip1SchedulerPass);
return child->pid(); return child->pid().value();
} }
} }

21
Kernel/Syscalls/kill.cpp
View file

@ -35,7 +35,7 @@ KResult Process::do_kill(Process& process, int signal)
if (!is_superuser() && m_euid != process.m_uid && m_uid != process.m_uid) if (!is_superuser() && m_euid != process.m_uid && m_uid != process.m_uid)
return KResult(-EPERM); return KResult(-EPERM);
if (process.is_ring0() && signal == SIGKILL) { if (process.is_ring0() && signal == SIGKILL) {
klog() << "attempted to send SIGKILL to ring 0 process " << process.name().characters() << "(" << process.pid() << ")"; klog() << "attempted to send SIGKILL to ring 0 process " << process.name().characters() << "(" << process.pid().value() << ")";
return KResult(-EPERM); return KResult(-EPERM);
} }
if (signal != 0) if (signal != 0)
@ -119,33 +119,34 @@ KResult Process::do_killself(int signal)
return KSuccess; return KSuccess;
} }
int Process::sys$kill(pid_t pid, int signal) int Process::sys$kill(pid_t pid_or_pgid, int signal)
{ {
if (pid == m_pid) if (pid_or_pgid == m_pid.value())
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
else else
REQUIRE_PROMISE(proc); REQUIRE_PROMISE(proc);
if (signal < 0 || signal >= 32) if (signal < 0 || signal >= 32)
return -EINVAL; return -EINVAL;
if (pid < -1) { if (pid_or_pgid < -1) {
if (pid == NumericLimits<i32>::min()) if (pid_or_pgid == NumericLimits<i32>::min())
return -EINVAL; return -EINVAL;
return do_killpg(-pid, signal); return do_killpg(-pid_or_pgid, signal);
} }
if (pid == -1) if (pid_or_pgid == -1)
return do_killall(signal); return do_killall(signal);
if (pid == m_pid) { if (pid_or_pgid == m_pid.value()) {
return do_killself(signal); return do_killself(signal);
} }
ASSERT(pid_or_pgid >= 0);
ScopedSpinLock lock(g_processes_lock); ScopedSpinLock lock(g_processes_lock);
auto peer = Process::from_pid(pid); auto peer = Process::from_pid(pid_or_pgid);
if (!peer) if (!peer)
return -ESRCH; return -ESRCH;
return do_kill(*peer, signal); return do_kill(*peer, signal);
} }
int Process::sys$killpg(int pgrp, int signum) int Process::sys$killpg(pid_t pgrp, int signum)
{ {
REQUIRE_PROMISE(proc); REQUIRE_PROMISE(proc);
if (signum < 1 || signum >= 32) if (signum < 1 || signum >= 32)

4
Kernel/Syscalls/process.cpp
View file

@ -32,13 +32,13 @@ namespace Kernel {
pid_t Process::sys$getpid() pid_t Process::sys$getpid()
{ {
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
return m_pid; return m_pid.value();
} }
pid_t Process::sys$getppid() pid_t Process::sys$getppid()
{ {
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
return m_ppid; return m_ppid.value();
} }
int Process::sys$set_process_icon(int icon_id) int Process::sys$set_process_icon(int icon_id)

5
Kernel/Syscalls/ptrace.cpp
View file

@ -44,7 +44,10 @@ int Process::sys$ptrace(Userspace<const Syscall::SC_ptrace_params*> user_params)
return result.is_error() ? result.error() : result.value(); return result.is_error() ? result.error() : result.value();
} }
bool Process::has_tracee_thread(int tracer_pid) const /**
* "Does this process have a thread that is currently being traced by the provided process?"
*/
bool Process::has_tracee_thread(ProcessID tracer_pid) const
{ {
bool has_tracee = false; bool has_tracee = false;

12
Kernel/Syscalls/setpgid.cpp
View file

@ -48,14 +48,15 @@ pid_t Process::sys$setsid()
REQUIRE_PROMISE(proc); REQUIRE_PROMISE(proc);
InterruptDisabler disabler; InterruptDisabler disabler;
bool found_process_with_same_pgid_as_my_pid = false; bool found_process_with_same_pgid_as_my_pid = false;
Process::for_each_in_pgrp(pid(), [&](auto&) { // FIXME: PID/PGID ISSUE?
Process::for_each_in_pgrp(pid().value(), [&](auto&) {
found_process_with_same_pgid_as_my_pid = true; found_process_with_same_pgid_as_my_pid = true;
return IterationDecision::Break; return IterationDecision::Break;
}); });
if (found_process_with_same_pgid_as_my_pid) if (found_process_with_same_pgid_as_my_pid)
return -EPERM; return -EPERM;
m_sid = m_pid; m_sid = m_pid.value();
m_pgid = m_pid; m_pgid = m_pid.value();
m_tty = nullptr; m_tty = nullptr;
return m_sid; return m_sid;
} }
@ -91,7 +92,7 @@ int Process::sys$setpgid(pid_t specified_pid, pid_t specified_pgid)
{ {
REQUIRE_PROMISE(proc); REQUIRE_PROMISE(proc);
ScopedSpinLock lock(g_processes_lock); // FIXME: Use a ProcessHandle ScopedSpinLock lock(g_processes_lock); // FIXME: Use a ProcessHandle
pid_t pid = specified_pid ? specified_pid : m_pid; ProcessID pid = specified_pid ? ProcessID(specified_pid) : m_pid;
if (specified_pgid < 0) { if (specified_pgid < 0) {
// The value of the pgid argument is less than 0, or is not a value supported by the implementation. // The value of the pgid argument is less than 0, or is not a value supported by the implementation.
return -EINVAL; return -EINVAL;
@ -115,7 +116,8 @@ int Process::sys$setpgid(pid_t specified_pid, pid_t specified_pgid)
return -EPERM; return -EPERM;
} }
pid_t new_pgid = specified_pgid ? specified_pgid : process->m_pid; // FIXME: PID/PGID INCOMPLETE
pid_t new_pgid = specified_pgid ? specified_pgid : process->m_pid.value();
pid_t current_sid = get_sid_from_pgid(process->m_pgid); pid_t current_sid = get_sid_from_pgid(process->m_pgid);
pid_t new_sid = get_sid_from_pgid(new_pgid); pid_t new_sid = get_sid_from_pgid(new_pgid);
if (current_sid != new_sid) { if (current_sid != new_sid) {

2
Kernel/Syscalls/shbuf.cpp
View file

@ -70,7 +70,7 @@ int Process::sys$shbuf_create(int size, void** buffer)
int Process::sys$shbuf_allow_pid(int shbuf_id, pid_t peer_pid) int Process::sys$shbuf_allow_pid(int shbuf_id, pid_t peer_pid)
{ {
REQUIRE_PROMISE(shared_buffer); REQUIRE_PROMISE(shared_buffer);
if (!peer_pid || peer_pid < 0 || peer_pid == m_pid) if (!peer_pid || peer_pid < 0 || ProcessID(peer_pid) == m_pid)
return -EINVAL; return -EINVAL;
LOCKER(shared_buffers().lock()); LOCKER(shared_buffers().lock());
auto it = shared_buffers().resource().find(shbuf_id); auto it = shared_buffers().resource().find(shbuf_id);

4
Kernel/Syscalls/thread.cpp
View file

@ -87,7 +87,7 @@ int Process::sys$create_thread(void* (*entry)(void*), Userspace<const Syscall::S
thread->make_thread_specific_region({}); thread->make_thread_specific_region({});
thread->set_state(Thread::State::Runnable); thread->set_state(Thread::State::Runnable);
return thread->tid(); return thread->tid().value();
} }
void Process::sys$exit_thread(void* exit_value) void Process::sys$exit_thread(void* exit_value)
@ -212,7 +212,7 @@ int Process::sys$get_thread_name(int tid, char* buffer, size_t buffer_size)
int Process::sys$gettid() int Process::sys$gettid()
{ {
REQUIRE_PROMISE(stdio); REQUIRE_PROMISE(stdio);
return Thread::current()->tid(); return Thread::current()->tid().value();
} }
} }

10
Kernel/Syscalls/waitid.cpp
View file

@ -34,9 +34,12 @@ KResultOr<siginfo_t> Process::do_waitid(idtype_t idtype, int id, int options)
ScopedSpinLock lock(g_processes_lock); ScopedSpinLock lock(g_processes_lock);
if (idtype == P_PID && !Process::from_pid(id)) if (idtype == P_PID && !Process::from_pid(id))
return KResult(-ECHILD); return KResult(-ECHILD);
// FIXME: Race: After 'lock' releases, the 'id' process might vanish.
// If that is not a problem, why check for it?
// If it is a problem, let's fix it! (Eventually.)
} }
pid_t waitee_pid; ProcessID waitee_pid { 0 };
// FIXME: WaitBlocker should support idtype/id specs directly. // FIXME: WaitBlocker should support idtype/id specs directly.
if (idtype == P_ALL) { if (idtype == P_ALL) {
@ -62,14 +65,15 @@ KResultOr<siginfo_t> Process::do_waitid(idtype_t idtype, int id, int options)
if (waitee_process->is_dead()) { if (waitee_process->is_dead()) {
return reap(*waitee_process); return reap(*waitee_process);
} else { } else {
auto* waitee_thread = Thread::from_tid(waitee_pid); // FIXME: PID/TID BUG
auto* waitee_thread = Thread::from_tid(waitee_pid.value());
if (!waitee_thread) if (!waitee_thread)
return KResult(-ECHILD); return KResult(-ECHILD);
ASSERT((options & WNOHANG) || waitee_thread->state() == Thread::State::Stopped); ASSERT((options & WNOHANG) || waitee_thread->state() == Thread::State::Stopped);
siginfo_t siginfo; siginfo_t siginfo;
memset(&siginfo, 0, sizeof(siginfo)); memset(&siginfo, 0, sizeof(siginfo));
siginfo.si_signo = SIGCHLD; siginfo.si_signo = SIGCHLD;
siginfo.si_pid = waitee_process->pid(); siginfo.si_pid = waitee_process->pid().value();
siginfo.si_uid = waitee_process->uid(); siginfo.si_uid = waitee_process->uid();
switch (waitee_thread->state()) { switch (waitee_thread->state()) {

10
Kernel/Thread.cpp
View file

@ -52,9 +52,10 @@ Thread::Thread(NonnullRefPtr<Process> process)
{ {
if (m_process->m_thread_count.fetch_add(1, AK::MemoryOrder::memory_order_acq_rel) == 0) { if (m_process->m_thread_count.fetch_add(1, AK::MemoryOrder::memory_order_acq_rel) == 0) {
// First thread gets TID == PID // First thread gets TID == PID
m_tid = m_process->pid(); m_tid = m_process->pid().value();
} else { } else {
m_tid = Process::allocate_pid(); // TODO: Use separate counter?
m_tid = Process::allocate_pid().value();
} }
#ifdef THREAD_DEBUG #ifdef THREAD_DEBUG
dbg() << "Created new thread " << m_process->name() << "(" << m_process->pid() << ":" << m_tid << ")"; dbg() << "Created new thread " << m_process->name() << "(" << m_process->pid() << ":" << m_tid << ")";
@ -721,7 +722,6 @@ void Thread::set_state(State new_state)
m_wait_queue->dequeue(*this); m_wait_queue->dequeue(*this);
m_wait_queue = nullptr; m_wait_queue = nullptr;
} }
if (this != Thread::current() && is_finalizable()) { if (this != Thread::current() && is_finalizable()) {
// Some other thread set this thread to Dying, notify the // Some other thread set this thread to Dying, notify the
@ -859,7 +859,7 @@ void Thread::make_thread_specific_region(Badge<Process>)
const LogStream& operator<<(const LogStream& stream, const Thread& value) const LogStream& operator<<(const LogStream& stream, const Thread& value)
{ {
return stream << value.process().name() << "(" << value.pid() << ":" << value.tid() << ")"; return stream << value.process().name() << "(" << value.pid().value() << ":" << value.tid().value() << ")";
} }
Thread::BlockResult Thread::wait_on(WaitQueue& queue, const char* reason, timeval* timeout, Atomic<bool>* lock, Thread* beneficiary) Thread::BlockResult Thread::wait_on(WaitQueue& queue, const char* reason, timeval* timeout, Atomic<bool>* lock, Thread* beneficiary)
@ -982,7 +982,7 @@ void Thread::reset_fpu_state()
memcpy(m_fpu_state, &Processor::current().clean_fpu_state(), sizeof(FPUState)); memcpy(m_fpu_state, &Processor::current().clean_fpu_state(), sizeof(FPUState));
} }
void Thread::start_tracing_from(pid_t tracer) void Thread::start_tracing_from(ProcessID tracer)
{ {
m_tracer = ThreadTracer::create(tracer); m_tracer = ThreadTracer::create(tracer);
} }

14
Kernel/Thread.h
View file

@ -82,11 +82,11 @@ public:
explicit Thread(NonnullRefPtr<Process>); explicit Thread(NonnullRefPtr<Process>);
~Thread(); ~Thread();
static Thread* from_tid(int); static Thread* from_tid(pid_t);
static void finalize_dying_threads(); static void finalize_dying_threads();
int tid() const { return m_tid; } ThreadID tid() const { return m_tid; }
int pid() const; ProcessID pid() const;
void set_priority(u32 p) { m_priority = p; } void set_priority(u32 p) { m_priority = p; }
u32 priority() const { return m_priority; } u32 priority() const { return m_priority; }
@ -236,13 +236,13 @@ public:
class WaitBlocker final : public Blocker { class WaitBlocker final : public Blocker {
public: public:
WaitBlocker(int wait_options, pid_t& waitee_pid); WaitBlocker(int wait_options, ProcessID& waitee_pid);
virtual bool should_unblock(Thread&) override; virtual bool should_unblock(Thread&) override;
virtual const char* state_string() const override { return "Waiting"; } virtual const char* state_string() const override { return "Waiting"; }
private: private:
int m_wait_options { 0 }; int m_wait_options { 0 };
pid_t& m_waitee_pid; ProcessID& m_waitee_pid;
}; };
class SemiPermanentBlocker final : public Blocker { class SemiPermanentBlocker final : public Blocker {
@ -512,7 +512,7 @@ public:
static constexpr u32 default_userspace_stack_size = 4 * MB; static constexpr u32 default_userspace_stack_size = 4 * MB;
ThreadTracer* tracer() { return m_tracer.ptr(); } ThreadTracer* tracer() { return m_tracer.ptr(); }
void start_tracing_from(pid_t tracer); void start_tracing_from(ProcessID tracer);
void stop_tracing(); void stop_tracing();
void tracer_trap(const RegisterState&); void tracer_trap(const RegisterState&);
@ -533,7 +533,7 @@ private:
mutable RecursiveSpinLock m_lock; mutable RecursiveSpinLock m_lock;
NonnullRefPtr<Process> m_process; NonnullRefPtr<Process> m_process;
int m_tid { -1 }; ThreadID m_tid { -1 };
TSS32 m_tss; TSS32 m_tss;
Atomic<u32> m_cpu { 0 }; Atomic<u32> m_cpu { 0 };
u32 m_cpu_affinity { THREAD_AFFINITY_DEFAULT }; u32 m_cpu_affinity { THREAD_AFFINITY_DEFAULT };

2
Kernel/ThreadTracer.cpp
View file

@ -32,7 +32,7 @@
namespace Kernel { namespace Kernel {
ThreadTracer::ThreadTracer(pid_t tracer_pid) ThreadTracer::ThreadTracer(ProcessID tracer_pid)
: m_tracer_pid(tracer_pid) : m_tracer_pid(tracer_pid)
{ {
} }

8
Kernel/ThreadTracer.h
View file

@ -35,9 +35,9 @@ namespace Kernel {
class ThreadTracer { class ThreadTracer {
public: public:
static NonnullOwnPtr<ThreadTracer> create(pid_t tracer) { return make<ThreadTracer>(tracer); } static NonnullOwnPtr<ThreadTracer> create(ProcessID tracer) { return make<ThreadTracer>(tracer); }
pid_t tracer_pid() const { return m_tracer_pid; } ProcessID tracer_pid() const { return m_tracer_pid; }
bool has_pending_signal(u32 signal) const { return m_pending_signals & (1 << (signal - 1)); } bool has_pending_signal(u32 signal) const { return m_pending_signals & (1 << (signal - 1)); }
void set_signal(u32 signal) { m_pending_signals |= (1 << (signal - 1)); } void set_signal(u32 signal) { m_pending_signals |= (1 << (signal - 1)); }
void unset_signal(u32 signal) { m_pending_signals &= ~(1 << (signal - 1)); } void unset_signal(u32 signal) { m_pending_signals &= ~(1 << (signal - 1)); }
@ -54,10 +54,10 @@ public:
return m_regs.value(); return m_regs.value();
} }
explicit ThreadTracer(pid_t); explicit ThreadTracer(ProcessID);
private: private:
pid_t m_tracer_pid { -1 }; ProcessID m_tracer_pid { -1 };
// This is a bitmap for signals that are sent from the tracer to the tracee // This is a bitmap for signals that are sent from the tracer to the tracee
// TODO: Since we do not currently support sending signals // TODO: Since we do not currently support sending signals

6
Kernel/UnixTypes.h
View file

@ -26,6 +26,7 @@
#pragma once #pragma once
#include <AK/DistinctNumeric.h>
#include <AK/Types.h> #include <AK/Types.h>
#define O_RDONLY (1 << 0) #define O_RDONLY (1 << 0)
@ -320,6 +321,11 @@ typedef u32 gid_t;
typedef u32 clock_t; typedef u32 clock_t;
typedef u32 socklen_t; typedef u32 socklen_t;
typedef int pid_t; typedef int pid_t;
// Avoid interference with AK/Types.h and LibC/sys/types.h by defining *separate* names:
TYPEDEF_DISTINCT_ORDERED_ID(pid_t, ProcessID);
TYPEDEF_DISTINCT_ORDERED_ID(pid_t, ThreadID);
TYPEDEF_DISTINCT_ORDERED_ID(pid_t, SessionID);
TYPEDEF_DISTINCT_ORDERED_ID(pid_t, ProcessGroupID);
struct tms { struct tms {
clock_t tms_utime; clock_t tms_utime;