beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 15:40:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Kernel: Rewrite ProcFS.

Browse source 
Now the filesystem is generated on-the-fly instead of manually adding and
removing inodes as processes spawn and die.

The code is convoluted and bloated as I wrote it while sleepless. However,
it's still vastly better than the old ProcFS, so I'm committing it.

I also added /proc/PID/fd/N symlinks for each of a process's open fd's.
This commit is contained in:
Andreas Kling 2019-02-03 12:33:11 +01:00
parent ab56f36bfb
commit 5e9ba2ac84
Notes: sideshowbarker 2024-07-19 15:52:55 +09:00 
Author: https://github.com/awesomekling
Commit: https://github.com/SerenityOS/serenity/commit/5e9ba2ac84c
13 changed files with 1133 additions and 468 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Kernel/Makefile
View file

@ -16,7 +16,7 @@ KERNEL_OBJS = \
Console.o \
IRQHandler.o \
kprintf.o \
ProcFileSystem.o \
ProcFS.o \
RTC.o \
TTY.o \
PTYMultiplexer.o \

2
Kernel/MemoryManager.h
View file

@ -201,7 +201,7 @@ class MemoryManager {
friend class PhysicalPage;
friend class Region;
friend class VMObject;
friend ByteBuffer procfs$mm(SynthFSInode&);
friend ByteBuffer procfs$mm(InodeIdentifier);
public:
static MemoryManager& the() PURE;

1002
Kernel/ProcFS.cpp Normal file
View file

File diff suppressed because it is too large Load diff

96
Kernel/ProcFS.h Normal file
View file

@ -0,0 +1,96 @@
#pragma once
#include <AK/Lock.h>
#include <AK/Types.h>
#include <Kernel/FileSystem.h>
class Process;
class ProcFSInode;
class ProcFS final : public FS {
friend class ProcFSInode;
public:
static ProcFS& the() PURE;
virtual ~ProcFS() override;
static RetainPtr<ProcFS> create();
virtual bool initialize() override;
virtual const char* class_name() const override;
virtual InodeIdentifier root_inode() const override;
virtual RetainPtr<Inode> get_inode(InodeIdentifier) const override;
virtual RetainPtr<Inode> create_inode(InodeIdentifier parent_id, const String& name, mode_t, unsigned size, int& error) override;
virtual RetainPtr<Inode> create_directory(InodeIdentifier parent_id, const String& name, mode_t, int& error) override;
void add_sys_file(String&&, Function<ByteBuffer(ProcFSInode&)>&& read_callback, Function<ssize_t(ProcFSInode&, const ByteBuffer&)>&& write_callback);
void add_sys_bool(String&&, bool*, Function<void()>&& notify_callback = nullptr);
private:
ProcFS();
struct ProcFSDirectoryEntry {
ProcFSDirectoryEntry() { }
ProcFSDirectoryEntry(const char* a_name, unsigned a_proc_file_type, Function<ByteBuffer(InodeIdentifier)>&& a_read_callback = nullptr, Function<ssize_t(InodeIdentifier, const ByteBuffer&)>&& a_write_callback = nullptr, RetainPtr<ProcFSInode>&& a_inode = nullptr)
: name(a_name)
, proc_file_type(a_proc_file_type)
, read_callback(move(a_read_callback))
, write_callback(move(a_write_callback))
, inode(move(a_inode))
{
}
const char* name { nullptr };
unsigned proc_file_type { 0 };
Function<ByteBuffer(InodeIdentifier)> read_callback;
Function<ssize_t(InodeIdentifier, const ByteBuffer&)> write_callback;
RetainPtr<ProcFSInode> inode;
InodeIdentifier identifier(unsigned fsid) const;
};
ProcFSDirectoryEntry* get_directory_entry(InodeIdentifier) const;
Vector<ProcFSDirectoryEntry> m_entries;
Vector<ProcFSDirectoryEntry> m_sys_entries;
mutable Lock m_inodes_lock;
mutable HashMap<unsigned, ProcFSInode*> m_inodes;
RetainPtr<ProcFSInode> m_root_inode;
};
struct ProcFSInodeCustomData {
virtual ~ProcFSInodeCustomData();
};
class ProcFSInode final : public Inode {
friend class ProcFS;
public:
virtual ~ProcFSInode() override;
void set_custom_data(OwnPtr<ProcFSInodeCustomData>&& custom_data) { m_custom_data = move(custom_data); }
ProcFSInodeCustomData* custom_data() { return m_custom_data.ptr(); }
const ProcFSInodeCustomData* custom_data() const { return m_custom_data.ptr(); }
private:
// ^Inode
virtual ssize_t read_bytes(off_t, size_t, byte* buffer, FileDescriptor*) const override;
virtual InodeMetadata metadata() const override;
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const override;
virtual InodeIdentifier lookup(const String& name) override;
virtual String reverse_lookup(InodeIdentifier) override;
virtual void flush_metadata() override;
virtual ssize_t write_bytes(off_t, size_t, const byte* buffer, FileDescriptor*) override;
virtual bool add_child(InodeIdentifier child_id, const String& name, byte file_type, int& error) override;
virtual bool remove_child(const String& name, int& error) override;
virtual RetainPtr<Inode> parent() const override;
virtual size_t directory_entry_count() const override;
virtual bool chmod(mode_t, int& error) override;
ProcFS& fs() { return static_cast<ProcFS&>(Inode::fs()); }
const ProcFS& fs() const { return static_cast<const ProcFS&>(Inode::fs()); }
ProcFSInode(ProcFS&, unsigned index);
OwnPtr<ProcFSInodeCustomData> m_custom_data;
};

418
Kernel/ProcFileSystem.cpp
View file

@ -1,418 +0,0 @@
#include "ProcFileSystem.h"
#include "Process.h"
#include <Kernel/VirtualFileSystem.h>
#include "system.h"
#include "MemoryManager.h"
#include "StdLib.h"
#include "i386.h"
#include "KSyms.h"
#include "Console.h"
#include <AK/StringBuilder.h>
static ProcFS* s_the;
ProcFS& ProcFS::the()
{
ASSERT(s_the);
return *s_the;
}
RetainPtr<ProcFS> ProcFS::create()
{
return adopt(*new ProcFS);
}
ProcFS::ProcFS()
{
s_the = this;
}
ProcFS::~ProcFS()
{
}
ByteBuffer procfs$pid_fds(Process& process)
{
ProcessInspectionHandle handle(process);
if (process.number_of_open_file_descriptors() == 0)
return { };
StringBuilder builder;
for (size_t i = 0; i < process.max_open_file_descriptors(); ++i) {
auto* descriptor = process.file_descriptor(i);
if (!descriptor)
continue;
builder.appendf("% 3u %s\n", i, descriptor->absolute_path().characters());
}
return builder.to_byte_buffer();
}
ByteBuffer procfs$pid_vm(Process& process)
{
ProcessInspectionHandle handle(process);
StringBuilder builder;
builder.appendf("BEGIN END SIZE COMMIT NAME\n");
for (auto& region : process.regions()) {
builder.appendf("%x -- %x %x %x %s\n",
region->laddr().get(),
region->laddr().offset(region->size() - 1).get(),
region->size(),
region->committed(),
region->name().characters());
}
return builder.to_byte_buffer();
}
ByteBuffer procfs$pid_vmo(Process& process)
{
ProcessInspectionHandle handle(process);
StringBuilder builder;
builder.appendf("BEGIN END SIZE NAME\n");
for (auto& region : process.regions()) {
builder.appendf("%x -- %x %x %s\n",
region->laddr().get(),
region->laddr().offset(region->size() - 1).get(),
region->size(),
region->name().characters());
builder.appendf("VMO: %s \"%s\" @ %x(%u)\n",
region->vmo().is_anonymous() ? "anonymous" : "file-backed",
region->vmo().name().characters(),
&region->vmo(),
region->vmo().retain_count());
for (size_t i = 0; i < region->vmo().page_count(); ++i) {
auto& physical_page = region->vmo().physical_pages()[i];
builder.appendf("P%x%s(%u) ",
physical_page ? physical_page->paddr().get() : 0,
region->cow_map().get(i) ? "!" : "",
physical_page ? physical_page->retain_count() : 0
);
}
builder.appendf("\n");
}
return builder.to_byte_buffer();
}
ByteBuffer procfs$pid_stack(Process& process)
{
ProcessInspectionHandle handle(process);
ProcessPagingScope paging_scope(process);
struct RecognizedSymbol {
dword address;
const KSym* ksym;
};
Vector<RecognizedSymbol> recognized_symbols;
if (auto* eip_ksym = ksymbolicate(process.tss().eip))
recognized_symbols.append({ process.tss().eip, eip_ksym });
for (dword* stack_ptr = (dword*)process.frame_ptr(); process.validate_read_from_kernel(LinearAddress((dword)stack_ptr)); stack_ptr = (dword*)*stack_ptr) {
dword retaddr = stack_ptr[1];
if (auto* ksym = ksymbolicate(retaddr))
recognized_symbols.append({ retaddr, ksym });
}
StringBuilder builder;
for (auto& symbol : recognized_symbols) {
unsigned offset = symbol.address - symbol.ksym->address;
builder.appendf("%p %s +%u\n", symbol.address, symbol.ksym->name, offset);
}
return builder.to_byte_buffer();
}
ByteBuffer procfs$pid_regs(Process& process)
{
ProcessInspectionHandle handle(process);
auto& tss = process.tss();
StringBuilder builder;
builder.appendf("eax: %x\n", tss.eax);
builder.appendf("ebx: %x\n", tss.ebx);
builder.appendf("ecx: %x\n", tss.ecx);
builder.appendf("edx: %x\n", tss.edx);
builder.appendf("esi: %x\n", tss.esi);
builder.appendf("edi: %x\n", tss.edi);
builder.appendf("ebp: %x\n", tss.ebp);
builder.appendf("cr3: %x\n", tss.cr3);
builder.appendf("flg: %x\n", tss.eflags);
builder.appendf("sp: %w:%x\n", tss.ss, tss.esp);
builder.appendf("pc: %w:%x\n", tss.cs, tss.eip);
return builder.to_byte_buffer();
}
ByteBuffer procfs$pid_exe(Process& process)
{
ProcessInspectionHandle handle(process);
auto inode = process.executable_inode();
ASSERT(inode);
return VFS::the().absolute_path(*inode).to_byte_buffer();
}
ByteBuffer procfs$pid_cwd(Process& process)
{
ProcessInspectionHandle handle(process);
auto inode = process.cwd_inode();
ASSERT(inode);
return VFS::the().absolute_path(*inode).to_byte_buffer();
}
ByteBuffer procfs$self(SynthFSInode&)
{
char buffer[16];
ksprintf(buffer, "%u", current->pid());
return ByteBuffer::copy((const byte*)buffer, strlen(buffer));
}
void ProcFS::add_process(Process& process)
{
InterruptDisabler disabler;
auto dir = add_file(create_directory(String::format("%d", process.pid())));
m_pid2inode.set(process.pid(), dir.index());
add_file(create_generated_file("vm", [&process] (SynthFSInode&) { return procfs$pid_vm(process); }), dir.index());
add_file(create_generated_file("vmo", [&process] (SynthFSInode&) { return procfs$pid_vmo(process); }), dir.index());
add_file(create_generated_file("stack", [&process] (SynthFSInode&) { return procfs$pid_stack(process); }), dir.index());
add_file(create_generated_file("regs", [&process] (SynthFSInode&) { return procfs$pid_regs(process); }), dir.index());
add_file(create_generated_file("fds", [&process] (SynthFSInode&) { return procfs$pid_fds(process); }), dir.index());
if (process.executable_inode())
add_file(create_generated_file("exe", [&process] (SynthFSInode&) { return procfs$pid_exe(process); }, 00120777), dir.index());
if (process.cwd_inode())
add_file(create_generated_file("cwd", [&process] (SynthFSInode&) { return procfs$pid_cwd(process); }, 00120777), dir.index());
}
void ProcFS::remove_process(Process& process)
{
InterruptDisabler disabler;
auto pid = process.pid();
auto it = m_pid2inode.find(pid);
if (it == m_pid2inode.end())
return;
bool success = remove_file((*it).value);
ASSERT(success);
m_pid2inode.remove(pid);
}
ByteBuffer procfs$mm(SynthFSInode&)
{
// FIXME: Implement
InterruptDisabler disabler;
StringBuilder builder;
for (auto* vmo : MM.m_vmos) {
builder.appendf("VMO: %p %s(%u): p:%4u %s\n",
vmo,
vmo->is_anonymous() ? "anon" : "file",
vmo->retain_count(),
vmo->page_count(),
vmo->name().characters());
}
builder.appendf("VMO count: %u\n", MM.m_vmos.size());
builder.appendf("Free physical pages: %u\n", MM.m_free_physical_pages.size());
builder.appendf("Free supervisor physical pages: %u\n", MM.m_free_supervisor_physical_pages.size());
return builder.to_byte_buffer();
}
ByteBuffer procfs$dmesg(SynthFSInode&)
{
InterruptDisabler disabler;
StringBuilder builder;
for (char ch : Console::the().logbuffer())
builder.append(ch);
return builder.to_byte_buffer();
}
ByteBuffer procfs$mounts(SynthFSInode&)
{
// FIXME: This is obviously racy against the VFS mounts changing.
StringBuilder builder;
VFS::the().for_each_mount([&builder] (auto& mount) {
auto& fs = mount.guest_fs();
builder.appendf("%s @ ", fs.class_name());
if (!mount.host().is_valid())
builder.appendf("/");
else {
builder.appendf("%u:%u", mount.host().fsid(), mount.host().index());
auto path = VFS::the().absolute_path(mount.host());
builder.append(' ');
builder.append(path);
}
builder.append('\n');
});
return builder.to_byte_buffer();
}
ByteBuffer procfs$cpuinfo(SynthFSInode&)
{
StringBuilder builder;
{
CPUID cpuid(0);
builder.appendf("cpuid: ");
auto emit_dword = [&] (dword value) {
builder.appendf("%c%c%c%c",
value & 0xff,
(value >> 8) & 0xff,
(value >> 16) & 0xff,
(value >> 24) & 0xff);
};
emit_dword(cpuid.ebx());
emit_dword(cpuid.edx());
emit_dword(cpuid.ecx());
builder.appendf("\n");
}
{
CPUID cpuid(1);
dword stepping = cpuid.eax() & 0xf;
dword model = (cpuid.eax() >> 4) & 0xf;
dword family = (cpuid.eax() >> 8) & 0xf;
dword type = (cpuid.eax() >> 12) & 0x3;
dword extended_model = (cpuid.eax() >> 16) & 0xf;
dword extended_family = (cpuid.eax() >> 20) & 0xff;
dword display_model;
dword display_family;
if (family == 15) {
display_family = family + extended_family;
display_model = model + (extended_model << 4);
} else if (family == 6) {
display_family = family;
display_model = model + (extended_model << 4);
} else {
display_family = family;
display_model = model;
}
builder.appendf("family: %u\n", display_family);
builder.appendf("model: %u\n", display_model);
builder.appendf("stepping: %u\n", stepping);
builder.appendf("type: %u\n", type);
}
{
// FIXME: Check first that this is supported by calling CPUID with eax=0x80000000
// and verifying that the returned eax>=0x80000004.
char buffer[48];
dword* bufptr = reinterpret_cast<dword*>(buffer);
auto copy_brand_string_part_to_buffer = [&] (dword i) {
CPUID cpuid(0x80000002 + i);
*bufptr++ = cpuid.eax();
*bufptr++ = cpuid.ebx();
*bufptr++ = cpuid.ecx();
*bufptr++ = cpuid.edx();
};
copy_brand_string_part_to_buffer(0);
copy_brand_string_part_to_buffer(1);
copy_brand_string_part_to_buffer(2);
builder.appendf("brandstr: \"%s\"\n", buffer);
}
return builder.to_byte_buffer();
}
ByteBuffer procfs$kmalloc(SynthFSInode&)
{
StringBuilder builder;
builder.appendf(
"eternal: %u\n"
"allocated: %u\n"
"free: %u\n",
kmalloc_sum_eternal,
sum_alloc,
sum_free
);
return builder.to_byte_buffer();
}
ByteBuffer procfs$summary(SynthFSInode&)
{
InterruptDisabler disabler;
auto processes = Process::all_processes();
StringBuilder builder;
builder.appendf("PID TPG PGP SID OWNER STATE PPID NSCHED FDS TTY NAME\n");
for (auto* process : processes) {
builder.appendf("% 3u % 3u % 3u % 3u % 4u % 8s % 3u % 9u % 3u % 4s %s\n",
process->pid(),
process->tty() ? process->tty()->pgid() : 0,
process->pgid(),
process->sid(),
process->uid(),
to_string(process->state()),
process->ppid(),
process->times_scheduled(),
process->number_of_open_file_descriptors(),
process->tty() ? strrchr(process->tty()->tty_name().characters(), '/') + 1 : "n/a",
process->name().characters());
}
return builder.to_byte_buffer();
}
ByteBuffer procfs$inodes(SynthFSInode&)
{
extern HashTable<Inode*>& all_inodes();
auto& vfs = VFS::the();
StringBuilder builder;
for (auto it : all_inodes()) {
RetainPtr<Inode> inode = *it;
String path = vfs.absolute_path(*inode);
builder.appendf("Inode{K%x} %02u:%08u (%u) %s\n", inode.ptr(), inode->fsid(), inode->index(), inode->retain_count(), path.characters());
}
return builder.to_byte_buffer();
}
struct SysVariableData final : public SynthFSInodeCustomData {
virtual ~SysVariableData() override { }
enum Type {
Invalid,
Boolean,
};
Type type { Invalid };
Function<void()> change_callback;
void* address;
};
static ByteBuffer read_sys_bool(SynthFSInode& inode)
{
ASSERT(inode.custom_data());
auto buffer = ByteBuffer::create_uninitialized(2);
auto& custom_data = *static_cast<const SysVariableData*>(inode.custom_data());
ASSERT(custom_data.type == SysVariableData::Boolean);
ASSERT(custom_data.address);
buffer[0] = *reinterpret_cast<bool*>(custom_data.address) ? '1' : '0';
buffer[1] = '\n';
return buffer;
}
static ssize_t write_sys_bool(SynthFSInode& inode, const ByteBuffer& data)
{
ASSERT(inode.custom_data());
if (data.size() >= 1 && (data[0] == '0' || data[0] == '1')) {
auto& custom_data = *static_cast<const SysVariableData*>(inode.custom_data());
ASSERT(custom_data.address);
bool old_value = *reinterpret_cast<bool*>(custom_data.address);
bool new_value = data[0] == '1';
*reinterpret_cast<bool*>(custom_data.address) = new_value;
if (old_value != new_value && custom_data.change_callback)
custom_data.change_callback();
}
return data.size();
}
void ProcFS::add_sys_bool(String&& name, bool* var, Function<void()>&& change_callback)
{
auto file = create_generated_file(move(name), move(read_sys_bool), move(write_sys_bool));
auto data = make<SysVariableData>();
data->type = SysVariableData::Boolean;
data->change_callback = move(change_callback);
data->address = var;
file->set_custom_data(move(data));
InterruptDisabler disabler;
add_file(move(file), m_sys_dir.index());
}
bool ProcFS::initialize()
{
SynthFS::initialize();
add_file(create_generated_file("mm", procfs$mm));
add_file(create_generated_file("mounts", procfs$mounts));
add_file(create_generated_file("kmalloc", procfs$kmalloc));
add_file(create_generated_file("summary", procfs$summary));
add_file(create_generated_file("cpuinfo", procfs$cpuinfo));
add_file(create_generated_file("inodes", procfs$inodes));
add_file(create_generated_file("dmesg", procfs$dmesg));
add_file(create_generated_file("self", procfs$self, 00120777));
m_sys_dir = add_file(create_directory("sys"));
return true;
}
const char* ProcFS::class_name() const
{
return "ProcFS";
}

30
Kernel/ProcFileSystem.h
View file

@ -1,30 +0,0 @@
#pragma once
#include <AK/Types.h>
#include <Kernel/SyntheticFileSystem.h>
class Process;
class ProcFS final : public SynthFS {
public:
static ProcFS& the() PURE;
virtual ~ProcFS() override;
static RetainPtr<ProcFS> create();
virtual bool initialize() override;
virtual const char* class_name() const override;
void add_process(Process&);
void remove_process(Process&);
void add_sys_file(String&&, Function<ByteBuffer(SynthFSInode&)>&& read_callback, Function<ssize_t(SynthFSInode&, const ByteBuffer&)>&& write_callback);
void add_sys_bool(String&&, bool*, Function<void()>&& change_callback = nullptr);
private:
ProcFS();
HashMap<pid_t, InodeIndex> m_pid2inode;
InodeIdentifier m_sys_dir;
};

19
Kernel/Process.cpp
View file

@ -10,7 +10,6 @@
#include "MemoryManager.h"
#include "i8253.h"
#include "RTC.h"
#include "ProcFileSystem.h"
#include <AK/StdLibExtras.h>
#include <LibC/signal_numbers.h>
#include <LibC/errno_numbers.h>
@ -60,13 +59,23 @@ void Process::initialize()
initialize_gui_statics();
}
Vector<pid_t> Process::all_pids()
{
InterruptDisabler disabler;
Vector<pid_t> pids;
pids.ensure_capacity(g_processes->size_slow());
for (auto* process = g_processes->head(); process; process = process->next())
pids.unchecked_append(process->pid());
return pids;
}
Vector<Process*> Process::all_processes()
{
InterruptDisabler disabler;
Vector<Process*> processes;
processes.ensure_capacity(g_processes->size_slow());
for (auto* process = g_processes->head(); process; process = process->next())
processes.append(process);
processes.unchecked_append(process);
return processes;
}
@ -266,8 +275,6 @@ Process* Process::fork(RegisterDump& regs)
dbgprintf("fork: child will begin executing at %w:%x with stack %w:%x\n", child->m_tss.cs, child->m_tss.eip, child->m_tss.ss, child->m_tss.esp);
#endif
ProcFS::the().add_process(*child);
{
InterruptDisabler disabler;
g_processes->prepend(child);
@ -507,8 +514,6 @@ Process* Process::create_user_process(const String& path, uid_t uid, gid_t gid,
return nullptr;
}
ProcFS::the().add_process(*process);
{
InterruptDisabler disabler;
g_processes->prepend(process);
@ -571,7 +576,6 @@ Process* Process::create_kernel_process(String&& name, void (*e)())
g_processes->prepend(process);
system.nprocess++;
}
ProcFS::the().add_process(*process);
#ifdef TASK_DEBUG
kprintf("Kernel process %u (%s) spawned @ %p\n", process->pid(), process->name().characters(), process->m_tss.eip);
#endif
@ -703,7 +707,6 @@ Process::Process(String&& name, uid_t uid, gid_t gid, pid_t ppid, RingLevel ring
Process::~Process()
{
InterruptDisabler disabler;
ProcFS::the().remove_process(*this);
system.nprocess--;
if (g_last_fpu_process == this)

12
Kernel/Process.h
View file

@ -55,6 +55,7 @@ public:
static Process* create_user_process(const String& path, uid_t, gid_t, pid_t ppid, int& error, Vector<String>&& arguments = Vector<String>(), Vector<String>&& environment = Vector<String>(), TTY* = nullptr);
~Process();
static Vector<pid_t> all_pids();
static Vector<Process*> all_processes();
enum State {
@ -406,6 +407,17 @@ public:
m_process.set_state(m_original_state);
}
Process& process() { return m_process; }
static OwnPtr<ProcessInspectionHandle> from_pid(pid_t pid)
{
InterruptDisabler disabler;
auto* process = Process::from_pid(pid);
if (process)
return make<ProcessInspectionHandle>(*process);
return nullptr;
}
Process* operator->() { return &m_process; }
Process& operator*() { return m_process; }
private:

8
Kernel/StdLib.cpp
View file

@ -92,10 +92,10 @@ int strcmp(const char *s1, const char *s2)
char* strdup(const char *str)
{
dword len = strlen(str);
char *s = (char*)kmalloc(len);
memcpy(s, str, len);
return s;
size_t len = strlen(str);
char* new_str = (char*)kmalloc(len + 1);
strcpy(new_str, str);
return new_str;
}
int memcmp(const void* v1, const void* v2, size_t n)

6
Kernel/init.cpp
View file

@ -16,7 +16,7 @@
#include <Kernel/VirtualFileSystem.h>
#include "GUIEventDevice.h"
#include "MemoryManager.h"
#include "ProcFileSystem.h"
#include "ProcFS.h"
#include "RTC.h"
#include "VirtualConsole.h"
#include "Scheduler.h"
@ -171,8 +171,8 @@ void init()
memset(&system, 0, sizeof(system));
auto procfs = ProcFS::create();
procfs->initialize();
auto new_procfs = ProcFS::create();
new_procfs->initialize();
auto devptsfs = DevPtsFS::create();
devptsfs->initialize();

2
Kernel/types.h
View file

@ -14,7 +14,7 @@ typedef short __s16;
typedef dword uid_t;
typedef dword gid_t;
typedef int pid_t;
typedef signed_word pid_t;
typedef dword time_t;
typedef dword suseconds_t;

2
LibC/sys/types.h
View file

@ -15,7 +15,7 @@ typedef __intmax_t intmax_t;
typedef uint32_t uid_t;
typedef uint32_t gid_t;
typedef int pid_t;
typedef int16_t pid_t;
typedef uint32_t size_t;
typedef int32_t ssize_t;

2
WindowServer/WSWindowManager.cpp
View file

@ -4,7 +4,7 @@
#include "WSMessageLoop.h"
#include "Process.h"
#include "MemoryManager.h"
#include <Kernel/ProcFileSystem.h>
#include <Kernel/ProcFS.h>
#include <SharedGraphics/Font.h>
#include <SharedGraphics/Painter.h>
#include <SharedGraphics/CharacterBitmap.h>