From 2716a9e2d7ceb92e66ed486b4d6797caf8be4efd Mon Sep 17 00:00:00 2001
From: Andreas Kling <awesomekling@gmail.com>
Date: Sat, 27 Oct 2018 00:14:24 +0200
Subject: [PATCH] Greatly improve /proc/PID/stack by tracing the ebp frame
 chain.

I also added a generator cache to FileHandle. This way, multiple
reads to a generated file (i.e in a synthfs) can transparently
handle multiple calls to read() without the contents changing
between calls.

The cache is discarded at EOF (or when the FileHandle is destroyed.)
---
 AK/ByteBuffer.h                           |   5 +
 Kernel/ProcFileSystem.cpp                 | 213 ++++++++++++----------
 Kernel/StdLib.h                           |  10 +
 Kernel/Task.cpp                           |  20 ++
 Kernel/Task.h                             |   4 +
 Kernel/_fs_contents                       | Bin 1024000 -> 1024000 bytes
 Kernel/i386.cpp                           |   6 +-
 Kernel/init.cpp                           |  11 ++
 Kernel/kmalloc.cpp                        |   5 +
 Kernel/kmalloc.h                          |   2 +
 Kernel/system.h                           |   1 +
 Kernel/types.h                            |   4 +
 Userland/cat.cpp                          |   2 +-
 VirtualFileSystem/Ext2FileSystem.cpp      |   3 +-
 VirtualFileSystem/Ext2FileSystem.h        |   2 +-
 VirtualFileSystem/FileHandle.cpp          |   4 +-
 VirtualFileSystem/FileHandle.h            |   4 +
 VirtualFileSystem/FileSystem.cpp          |   4 +-
 VirtualFileSystem/FileSystem.h            |   6 +-
 VirtualFileSystem/InodeIdentifier.cpp     |   2 +-
 VirtualFileSystem/SyntheticFileSystem.cpp |  16 +-
 VirtualFileSystem/SyntheticFileSystem.h   |   2 +-
 22 files changed, 210 insertions(+), 116 deletions(-)

diff --git a/AK/ByteBuffer.h b/AK/ByteBuffer.h
index 3147d90534..c576ad2b74 100644
--- a/AK/ByteBuffer.h
+++ b/AK/ByteBuffer.h
@@ -24,6 +24,11 @@ public:
             m_impl = move(other.m_impl);
         return *this;
     }
+    ByteBuffer& operator=(const ByteBuffer& other)
+    {
+        m_impl = other.m_impl.copyRef();
+        return *this;
+    }
 
     static ByteBuffer createEmpty() { return ByteBuffer(Buffer<byte>::createUninitialized(0)); }
     static ByteBuffer createUninitialized(size_t size) { return ByteBuffer(Buffer<byte>::createUninitialized(size)); }
diff --git a/Kernel/ProcFileSystem.cpp b/Kernel/ProcFileSystem.cpp
index 9560faad69..a763549e11 100644
--- a/Kernel/ProcFileSystem.cpp
+++ b/Kernel/ProcFileSystem.cpp
@@ -2,6 +2,7 @@
 #include "Task.h"
 #include <VirtualFileSystem/VirtualFileSystem.h>
 #include "system.h"
+#include "MemoryManager.h"
 
 static ProcFileSystem* s_the;
 
@@ -25,6 +26,64 @@ ProcFileSystem::~ProcFileSystem()
 {
 }
 
+ByteBuffer procfs$pid_vm(const Task& task)
+{
+    InterruptDisabler disabler;
+    char* buffer;
+    auto stringImpl = StringImpl::createUninitialized(80 + task.regionCount() * 80, buffer);
+    memset(buffer, 0, stringImpl->length());
+    char* ptr = buffer;
+    ptr += ksprintf(ptr, "BEGIN       END         SIZE        NAME\n");
+    for (auto& region : task.regions()) {
+        ptr += ksprintf(ptr, "%x -- %x    %x    %s\n",
+            region->linearAddress.get(),
+            region->linearAddress.offset(region->size - 1).get(),
+            region->size,
+            region->name.characters());
+    }
+    *ptr = '\0';
+    return ByteBuffer::copy((byte*)buffer, ptr - buffer);
+}
+
+ByteBuffer procfs$pid_stack(Task& task)
+{
+    InterruptDisabler disabler;
+    if (current != &task) {
+        MemoryManager::the().unmapRegionsForTask(*current);
+        MemoryManager::the().mapRegionsForTask(task);
+    }
+    struct RecognizedSymbol {
+        dword address;
+        const KSym* ksym;
+    };
+    Vector<RecognizedSymbol> recognizedSymbols;
+    if (auto* eipKsym = ksymbolicate(task.tss().eip))
+        recognizedSymbols.append({ task.tss().eip, eipKsym });
+    for (dword* stackPtr = (dword*)task.framePtr(); task.isValidAddressForKernel(LinearAddress((dword)stackPtr)); stackPtr = (dword*)*stackPtr) {
+        dword retaddr = stackPtr[1];
+        if (auto* ksym = ksymbolicate(retaddr))
+            recognizedSymbols.append({ retaddr, ksym });
+    }
+    size_t bytesNeeded = 0;
+    for (auto& symbol : recognizedSymbols) {
+        bytesNeeded += symbol.ksym->name.length() + 8 + 16;
+    }
+    auto buffer = ByteBuffer::createUninitialized(bytesNeeded);
+    char* bufptr = (char*)buffer.pointer();
+
+    for (auto& symbol : recognizedSymbols) {
+        // FIXME: This doesn't actually create a file!
+        unsigned offset = symbol.address - symbol.ksym->address;
+        bufptr += ksprintf(bufptr, "%p  %s +%u\n", symbol.address, symbol.ksym->name.characters(), offset);
+    }
+    buffer.trim(bufptr - (char*)buffer.pointer());
+    if (current != &task) {
+        MemoryManager::the().unmapRegionsForTask(task);
+        MemoryManager::the().mapRegionsForTask(*current);
+    }
+    return buffer;
+}
+
 void ProcFileSystem::addProcess(Task& task)
 {
     ASSERT_INTERRUPTS_DISABLED();
@@ -32,58 +91,8 @@ void ProcFileSystem::addProcess(Task& task)
     ksprintf(buf, "%d", task.pid());
     auto dir = addFile(createDirectory(buf));
     m_pid2inode.set(task.pid(), dir.index());
-    addFile(createGeneratedFile("vm", [&task] {
-        InterruptDisabler disabler;
-        char* buffer;
-        auto stringImpl = StringImpl::createUninitialized(80 + task.regionCount() * 80, buffer);
-        memset(buffer, 0, stringImpl->length());
-        char* ptr = buffer;
-        ptr += ksprintf(ptr, "BEGIN       END         SIZE        NAME\n");
-        for (auto& region : task.regions()) {
-            ptr += ksprintf(ptr, "%x -- %x    %x    %s\n",
-                region->linearAddress.get(),
-                region->linearAddress.offset(region->size - 1).get(),
-                region->size,
-                region->name.characters());
-        }
-        *ptr = '\0';
-        return ByteBuffer::copy((byte*)buffer, ptr - buffer);
-    }), dir.index());
-    addFile(createGeneratedFile("stack", [&task] {
-        InterruptDisabler disabler;
-        auto& syms = ksyms();
-        dword firstKsymAddress = syms.first().address;
-        dword lastKsymAddress = syms.last().address;
-        struct RecognizedSymbol {
-            dword address;
-            const char* name;
-            dword offset;
-        };
-        Vector<RecognizedSymbol> recognizedSymbols;
-        size_t bytesNeeded = 0;
-        for (dword* stackPtr = (dword*)task.stackPtr(); (dword)stackPtr < task.stackTop(); ++stackPtr) {
-            if (*stackPtr < firstKsymAddress || *stackPtr > lastKsymAddress)
-                continue;
-            const char* name = nullptr;
-            unsigned offset = 0;
-            for (unsigned i = 0; i < syms.size(); ++i) {
-                if (*stackPtr < syms[i+1].address) {
-                    name = syms[i].name.characters();
-                    offset = *stackPtr - syms[i].address;
-                    bytesNeeded += syms[i].name.length() + 8 + 16;
-                    break;
-                }
-            }
-            recognizedSymbols.append({ *stackPtr, name, offset });
-        }
-        auto buffer = ByteBuffer::createUninitialized(bytesNeeded);
-        char* ptr = (char*)buffer.pointer();
-        for (auto& symbol : recognizedSymbols) {
-            kprintf("%p  %s +%u\n", symbol.address, symbol.name, symbol.offset);
-        }
-        buffer.trim(ptr - (char*)buffer.pointer());
-        return buffer;
-    }), dir.index());
+    addFile(createGeneratedFile("vm", [&task] { return procfs$pid_vm(task); }), dir.index());
+    addFile(createGeneratedFile("stack", [&task] { return procfs$pid_stack(task); }), dir.index());
 }
 
 void ProcFileSystem::removeProcess(Task& task)
@@ -97,56 +106,62 @@ void ProcFileSystem::removeProcess(Task& task)
     m_pid2inode.remove(pid);
 }
 
+ByteBuffer procfs$mounts()
+{
+    InterruptDisabler disabler;
+    auto buffer = ByteBuffer::createUninitialized(VirtualFileSystem::the().mountCount() * 80);
+    char* ptr = (char*)buffer.pointer();
+    VirtualFileSystem::the().forEachMount([&ptr] (auto& mount) {
+        auto& fs = mount.fileSystem();
+        ptr += ksprintf(ptr, "%s @ ", fs.className());
+        if (!mount.host().isValid())
+            ptr += ksprintf(ptr, "/\n", fs.className());
+        else
+            ptr += ksprintf(ptr, "%u:%u\n", mount.host().fileSystemID(), mount.host().index());
+    });
+    buffer.trim(ptr - (char*)buffer.pointer());
+    return buffer;
+}
+
+ByteBuffer procfs$kmalloc()
+{
+    InterruptDisabler disabler;
+    auto buffer = ByteBuffer::createUninitialized(128);
+    char* ptr = (char*)buffer.pointer();
+    ptr += ksprintf(ptr, "alloc: %u\nfree:  %u\n", sum_alloc, sum_free);
+    buffer.trim(ptr - (char*)buffer.pointer());
+    return buffer;
+}
+
+ByteBuffer procfs$summary()
+{
+    InterruptDisabler disabler;
+    auto tasks = Task::allTasks();
+    auto buffer = ByteBuffer::createUninitialized(tasks.size() * 256);
+    char* ptr = (char*)buffer.pointer();
+    ptr += ksprintf(ptr, "PID    OWNER      STATE  PPID  NSCHED      FDS    NAME\n");
+    for (auto* task : tasks) {
+        ptr += ksprintf(ptr, "%w   %w:%w  %b     %w  %x    %w   %s\n",
+            task->pid(),
+            task->uid(),
+            task->gid(),
+            task->state(),
+            task->parentPID(),
+            task->timesScheduled(),
+            task->fileHandleCount(),
+            task->name().characters());
+    }
+    *ptr = '\0';
+    buffer.trim(ptr - (char*)buffer.pointer());
+    return buffer;
+}
+
 bool ProcFileSystem::initialize()
 {
     SyntheticFileSystem::initialize();
-
-    addFile(createGeneratedFile("mounts", [] {
-        InterruptDisabler disabler;
-        auto buffer = ByteBuffer::createUninitialized(VirtualFileSystem::the().mountCount() * 80);
-        char* ptr = (char*)buffer.pointer();
-        VirtualFileSystem::the().forEachMount([&ptr] (auto& mount) {
-            auto& fs = mount.fileSystem();
-            ptr += ksprintf(ptr, "%s @ ", fs.className());
-            if (!mount.host().isValid())
-                ptr += ksprintf(ptr, "/\n", fs.className());
-            else
-                ptr += ksprintf(ptr, "%u:%u\n", mount.host().fileSystemID(), mount.host().index());
-        });
-        buffer.trim(ptr - (char*)buffer.pointer());
-        return buffer;
-    }));
-
-    addFile(createGeneratedFile("kmalloc", [] {
-        InterruptDisabler disabler;
-        auto buffer = ByteBuffer::createUninitialized(128);
-        char* ptr = (char*)buffer.pointer();
-        ptr += ksprintf(ptr, "alloc: %u\nfree:  %u\n", sum_alloc, sum_free);
-        buffer.trim(ptr - (char*)buffer.pointer());
-        return buffer;
-    }));
-
-    addFile(createGeneratedFile("summary", [] {
-        InterruptDisabler disabler;
-        auto tasks = Task::allTasks();
-        auto buffer = ByteBuffer::createUninitialized(tasks.size() * 256);
-        char* ptr = (char*)buffer.pointer();
-        ptr += ksprintf(ptr, "PID    OWNER      STATE  PPID  NSCHED      FDS    NAME\n");
-        for (auto* task : tasks) {
-            ptr += ksprintf(ptr, "%w   %w:%w  %b     %w  %x    %w   %s\n",
-                task->pid(),
-                task->uid(),
-                task->gid(),
-                task->state(),
-                task->parentPID(),
-                task->timesScheduled(),
-                task->fileHandleCount(),
-                task->name().characters());
-        }
-        *ptr = '\0';
-        buffer.trim(ptr - (char*)buffer.pointer());
-        return buffer;
-    }));
+    addFile(createGeneratedFile("mounts", procfs$mounts));
+    addFile(createGeneratedFile("kmalloc", procfs$kmalloc));
+    addFile(createGeneratedFile("summary", procfs$summary));
     return true;
 }
 
diff --git a/Kernel/StdLib.h b/Kernel/StdLib.h
index f507773e55..ee7cd18c33 100644
--- a/Kernel/StdLib.h
+++ b/Kernel/StdLib.h
@@ -2,7 +2,17 @@
 
 #include "types.h"
 
+#if 0
+inline void memcpy(void *dest, const void *src, DWORD n)
+{
+    BYTE* bdest = (BYTE*)dest;
+    const BYTE* bsrc = (const BYTE*)src;
+    for (; n; --n)
+        *(bdest++) = *(bsrc++);
+}
+#else
 void memcpy(void*, const void*, DWORD);
+#endif
 void strcpy(char*, const char*);
 int strcmp(char const*, const char*);
 DWORD strlen(const char*);
diff --git a/Kernel/Task.cpp b/Kernel/Task.cpp
index 79fd9d7c37..91fffcd15b 100644
--- a/Kernel/Task.cpp
+++ b/Kernel/Task.cpp
@@ -885,3 +885,23 @@ Task::Region::Region(LinearAddress a, size_t s, RetainPtr<Zone>&& z, String&& n)
 Task::Region::~Region()
 {
 }
+
+bool Task::isValidAddressForKernel(LinearAddress laddr) const
+{
+    InterruptDisabler disabler;
+    if (laddr.get() >= ksyms().first().address && laddr.get() <= ksyms().last().address)
+        return true;
+    if (is_kmalloc_address((void*)laddr.get()))
+        return true;
+    return isValidAddressForUser(laddr);
+}
+
+bool Task::isValidAddressForUser(LinearAddress laddr) const
+{
+    InterruptDisabler disabler;
+    for (auto& region: m_regions) {
+        if (laddr >= region->linearAddress && laddr < region->linearAddress.offset(region->size))
+            return true;
+    }
+    return false;
+}
diff --git a/Kernel/Task.h b/Kernel/Task.h
index dd06be7022..957b28699e 100644
--- a/Kernel/Task.h
+++ b/Kernel/Task.h
@@ -122,9 +122,13 @@ public:
 
     size_t fileHandleCount() const { return m_fileHandles.size(); }
 
+    dword framePtr() const { return m_tss.ebp; }
     dword stackPtr() const { return m_tss.esp; }
     dword stackTop() const { return m_tss.ss == 0x10 ? m_stackTop0 : m_stackTop3; }
 
+    bool isValidAddressForKernel(LinearAddress) const;
+    bool isValidAddressForUser(LinearAddress) const;
+
 private:
     friend class MemoryManager;
     friend bool scheduleNewTask();
diff --git a/Kernel/_fs_contents b/Kernel/_fs_contents
index cff5e6f4916190479fb98de75f2925f1bec586d3..5971aa3cec200f94111667d44823dfdbb3c75919 100644
GIT binary patch
delta 13392
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
GAN^mt+09Y_

delta 4437
zcmai030M`^73Q89<~>J13<xOOuo*BB=j{)TK%z#CLD8s*F-GRidryrDxI~SK3Q5Wr
zwNaG9X|ovlz7|cIMQY;9(kP_vniOmLecD8M#wDq7!B%bDpl4<tsC-}T<NG=1+<WKT
zv)yxVMN@u7Q~s6+p0(FR@~J(Zdg1U?4QsYK_+bo2Wj3-ZSZ|JC?OP+w9lf})u#TET
z&X{%4W_t$-^lR$~{S2|=mBKJ>AS~==M}fZJ_P?72>sZRxmlCS`j_%yYm}FrIp;e6N
zNeBx&ML113L->*K6XBnPvxJ`s=LqKs7iuP118Lp0-FJt!dBo4J`GYHU9iOn(Ys-eA
z_gcM%3|LF3Cafc@C)5yrL#QRxg}kph<=8x;yP~)|wta$(n@E^Mm`r$*@DyPR;c3ED
z!ZU<vH5NIh=9Dx0o@PBuE2k4m2nxYNPzhdwkKiXQi8Wr=y|o}Y@LR&~2yYPHB)mm<
zo3MfKPM348?3C`#Mcv`tMuua(;r(j9bw;m?j;`^#vy;0oC!_QqsSVp?=*_M<^?w#_
z?p)~2%kI}*<L#tksW-g8vAMbC)V-IkzhkL)aCTmIt<iVb`2`vKXTq0+?SvhKCPFje
zE5o#inp1-}PI@Jag_SQhPKu_m)782=l>LQ1+DX_&*iG0&*h|<)*iSe>I7s-K@D1Vh
zSB?$|938^$H}ej!!;Wbq*Z}alu<>nk3QEJ-Xk1$_^yM8so2t#lVEJXCH@>qA!g+_^
z@5U25p%#3hxz)QMiRn6Gu(}Z<dWf<tTbwqh1zUDOcDz-ZC{36+Z1CXHvc=gs#-u&Z
zhP`&vcQO|5hICMMn!&8NeI!fg?A{RLknOmAHx!Znh&?ct$kaWM8zSKfX&#H^k1?5Z
z=2@|A59Bcg2keCcP<&Xu7c#o2$B;35FW(y@_d!e-7mI28c!$a9^O3ekF?TNv0lyD-
z?1Oa9X)qZe>jN2rRon7W%pc9{;E=I#3`^r&w;2^z?*}I~@8=7_<;J1|WI-o&>vAT}
zJHWd+m#SdP0nKrpW-uq_7cnR2^7?S#K^Q`Tm~{{yq2biAtUu>=bTUqZLH|KM7E8W{
zJ~-nbAER^3jmkIt*$@GWaM52OfyUr0_~gL&76@k)@A?TW8z@?phxlh%9zML?{2*4m
zAdW%#6BvXoPq62?Jk^cue}kd4J!Lu*OAdpIhgx}kVG(X@65@HM>UQFXlgR%Nlg=!(
z213dTzk?xI{CD`|e~h}&vR_Eiwwr=0wwY70cruk)=@b^ldA%~On8I>6pH1%CKNB}x
z7baubE)Y1s)sE6p3avpiDOi=4DWe}f&F<r<_OR(Fj0b~Gph;O}ed{X3K}KP^WVLHZ
z#N$)hU@g03`7$J<udyzkzeaV|c#MA^><Ugl4x^X{gF7J$<(EVSb6deo@u{zdIP6$1
zreUcupa-nFUAQ0L7-NdyTy%mca;w2&*X_V9K}fk<aH`l61RHIp8H&j#AYJ=pnQ;bP
z4wpXh5Y?H^q~qWp-~meH_^VU`558ya!@1m6Y+TM_@s`TsIk(M&O+Ucnq%iFati-kD
zEE(K)2@ah1Bh3Ua!c**SKJ5&@iG~aknD--}$e1HUooHFgc47HXkbIk?1IK2wRk-mS
zB!Tm`kW3afk7Z-9q?G-UbGz=AoR~I~y%sXft!dM(nSuqU`PKOT8R`s5;6$6YyF#||
zyD)f(cGdmau~73z#dW>K$3xn^Zmj}xC?5weLn`=mD$%FsFH^UWG3g4}sSw6r0jEJE
z>{!GSIE9X`vX~9;VnA_W@l`$_6gO611q(J`<sSx{E+pfUB`gg*bST<*J*?rF^8!oZ
zJTBdxRaoF>L-G4-kV<DzH?^>sdkEjT2GcrAH2OMZ;GtKASlsX;iw6%CN2kDfd_GjJ
z!+>yAR-}b^=oVGh7B3ruQ8!>dIZ=579sw$rW{!);?{7d~P*u(P7!+@kKt-$z(G@Hl
zhu(w%;0}$nR*HGpwwwt--BhoWX*og!9=k~uO#XLJlV~Rm8n0=4;1&!bdv(6_7TEBs
zD-est%Sr9$w;%>ws%A<8=C2?RtnRvY-p6cMe~T6^ZPzQa(+&sNt@=dm2b>uPo-n7?
zO=sb}+ewGv^$M0v`I^UzeGJ_#6)cN$Iel2)0R<TB;D>f<U0KQ8oZDk0p>`G5i!8m=
z4v84?GRx)^)m|IqCL2lF!MH4~npR^Oa2ZBz?$J_`%)32wC+LP#P_wYtuLJ>9I_z5f
z*FMHQh=&gMEC>|*nw?18Bqi~g0qIp1%xH+_BCxRv`r)l#AU2SjV2aM=+|;2Swh9X%
z&x6VbFhaW?V=&4lq;ZN@CTkM$!UvS-a+?s#DRfUB`V?H8huTQ<NYnG+@oMcRC9v@`
zkXScKwHb|(F5yZ}&C?rTq1H+wIh8I+?V|2vavEZ}q=ubP_@^V16p-3jFtutYRPE#%
zcJdn=ycBW$>VDuob6g<DZHkMccwX8}*3u=NjOPMyAE#JlWS_zke08L$ckKl(vdiv1
z+V!TH4IV{nf>~I8Nl3!z%fcX(N104oYoy0Q$OrXqiH_{|)Z7gp{C2I0>pnzj9b0$7
zYcM(63VCT^K)M_rT)XWu8#O#I>InDgu&M}CLxlO;x)L!GYg;KlDc6Na%q<bKu(eD4
ztVGPjoM7jyF0NlL#^S(}La#bS%%DSfyhI#<$Fw!e6j27BA3svWflS3?ifAPlqCH}<
zc3*nLu~aKtJffZEPJ3w1jR`6d1;?nOjT-+7RdnNWRqToLPYaphlvHUx22Da=JaW?9
zm$&#mR!sBiN+)_rjT2XTMGL9<!Yk(Ss!Xd3MWH{Y_{1b$4vBs7{2GYF*UkuuKq0L3
ziO=!wuDQ2*2vPc6IAxx`uZX1G#`(qmRQ|zM(v>?yOvjefLO7mk71DK)Htd=rSH{l}
zhZ(yS_YyL(m@{dn`s{dghB)1@swq;4$B%=;{hZ$~<Fc7z0mbFZnG_cnM$Hm!xbdtx
z4S(T;rk?uK&F|NZY3?md!&T3TFY$SrZR28vIFx3KNffG~v&EDw%|&U!%vt`0)8{JX
z+Lu=P(+0alyNvRA!4Gyimj4z~(KLtRX2)~qg^`@YC*$l3f)yNo{9GHi;Key&hGFuC
zWD3NfxuSLnPMs@`=IxpZN(z<S?zv)rBZQUp)V-HH$@Sx8>Vx^E;>c91Tbe8_TBvyD
z_#}VXd}&x&>4LI3KEt>?JN~{@lxU;YHX#v%rBo6Y98@OG)_UPYYAa1;Vigrc?;A#G
zkH!zn#kCah3;z-x;bcFZ@_AwrE!GJYmG({Np?OS@eVX&AWC|HL_@a=2@6H$FvG8LE
zN7Dj|n*%c!h?%6W{;W9(3$ldqJuS=fb=xeKJZxSdE(Q;^ou4TiTdIXL>}UkPIW(`L
z<v;Y*N84ar=aAP>L_?2b?m|&yKAd+&C`M_Kn9f_ZfJN<r;karM)uU4rn|8x6JWnF|
zxaJ2z!hifCWM|mC-GVlJ)`Ho?eT!zPM%*kmKR&-$k6WEaY#7jp9gi%geH2n$cbKk_
zwa-u@Ec6H%yF?s~MN7mUIBO!8ti3Gtm)$&Y`2rN#K8zwzGLh?#)l0?2q{jRrX>(y(
z5toF8<GCSN@uIkricDWa53yx*()38vlj}|9#poNtKx}!I#bH^8aGbOF<l17>1ftFm
zRW%xJ@lyz}xk8M?wi7_F&(r39G)RZf7>owf7?LSxhMYT<JbM>Ri6C2XH<)sOp2(NL
zw3N22KWUD`@=Eb(GJRdp9FNioO6qsZsC-(2=6-_Jr=RzfD=+{zKT2`1(gCD}Q;1Qp
zax@nkxcIWzn{A5*iQgn0;f4pKLOwXI;TbM^TQ!ps^y_G=^ldP)iWjT+o>hEA6(3o}
KM>X)h-uf@`x>KP5

diff --git a/Kernel/i386.cpp b/Kernel/i386.cpp
index 047212f877..7bca2f0b93 100644
--- a/Kernel/i386.cpp
+++ b/Kernel/i386.cpp
@@ -196,10 +196,10 @@ void exception_14_handler()
     asm ("movl %%cr2, %%eax":"=a"(faultAddress));
 
     auto& regs = *reinterpret_cast<RegisterDump*>(exception_state_dump);
-    kprintf("%s page fault: %u(%s), %s laddr=%p\n",
-        current->isRing0() ? "Kernel" : "User",
-        current->pid(),
+    kprintf("Ring%u page fault in %s(%u), %s laddr=%p\n",
+        regs.cs & 3,
         current->name().characters(),
+        current->pid(),
         exception_code & 2 ? "write" : "read",
         faultAddress);
 
diff --git a/Kernel/init.cpp b/Kernel/init.cpp
index 8368e071c9..7e220a6ced 100644
--- a/Kernel/init.cpp
+++ b/Kernel/init.cpp
@@ -65,6 +65,17 @@ Vector<KSym>& ksyms()
     return *s_ksyms;
 }
 
+const KSym* ksymbolicate(dword address)
+{
+    if (address < ksyms().first().address || address > ksyms().last().address)
+        return nullptr;
+    for (unsigned i = 0; i < ksyms().size(); ++i) {
+        if (address < ksyms()[i + 1].address)
+            return &ksyms()[i];
+    }
+    return nullptr;
+}
+
 static void loadKernelMap(const ByteBuffer& buffer)
 {
     s_ksyms = new Vector<KSym>;
diff --git a/Kernel/kmalloc.cpp b/Kernel/kmalloc.cpp
index 082307ac3b..fbb56569c6 100644
--- a/Kernel/kmalloc.cpp
+++ b/Kernel/kmalloc.cpp
@@ -29,6 +29,11 @@ PRIVATE BYTE alloc_map[POOL_SIZE / CHUNK_SIZE / 8];
 volatile DWORD sum_alloc = 0;
 volatile DWORD sum_free = POOL_SIZE;
 
+bool is_kmalloc_address(void* ptr)
+{
+    return ptr >= (void*)BASE_PHYS && ptr <= ((void*)BASE_PHYS + POOL_SIZE);
+}
+
 PUBLIC void
 kmalloc_init()
 {
diff --git a/Kernel/kmalloc.h b/Kernel/kmalloc.h
index 3862b68aef..e0b5ac4955 100644
--- a/Kernel/kmalloc.h
+++ b/Kernel/kmalloc.h
@@ -4,6 +4,8 @@ void kmalloc_init();
 void *kmalloc(DWORD size) __attribute__ ((malloc));
 void kfree(void*);
 
+bool is_kmalloc_address(void*);
+
 extern volatile DWORD sum_alloc;
 extern volatile DWORD sum_free;
 
diff --git a/Kernel/system.h b/Kernel/system.h
index 03de208bbb..0839f28d45 100644
--- a/Kernel/system.h
+++ b/Kernel/system.h
@@ -10,6 +10,7 @@ struct KSym {
 };
 
 Vector<KSym>& ksyms() PURE;
+const KSym* ksymbolicate(dword address) PURE;
 
 struct system_t
 {
diff --git a/Kernel/types.h b/Kernel/types.h
index 63f2a22846..c7e135fbfb 100644
--- a/Kernel/types.h
+++ b/Kernel/types.h
@@ -74,6 +74,10 @@ public:
     void set(dword address) { m_address = address; }
     void mask(dword m) { m_address &= m; }
 
+    bool operator<=(const LinearAddress& other) const { return m_address <= other.m_address; }
+    bool operator>=(const LinearAddress& other) const { return m_address >= other.m_address; }
+    bool operator>(const LinearAddress& other) const { return m_address > other.m_address; }
+    bool operator<(const LinearAddress& other) const { return m_address < other.m_address; }
     bool operator==(const LinearAddress& other) const { return m_address == other.m_address; }
 
     byte* asPtr() { return reinterpret_cast<byte*>(m_address); }
diff --git a/Userland/cat.cpp b/Userland/cat.cpp
index c6c11b4127..fd0044a7fe 100644
--- a/Userland/cat.cpp
+++ b/Userland/cat.cpp
@@ -15,7 +15,7 @@ int main(int argc, char** argv)
         return 1;
     }
     for (;;) {
-        char buf[4096];
+        char buf[1024];
         ssize_t nread = read(fd, buf, sizeof(buf));
         if (nread == 0)
             break;
diff --git a/VirtualFileSystem/Ext2FileSystem.cpp b/VirtualFileSystem/Ext2FileSystem.cpp
index 1b79224488..9314722a5f 100644
--- a/VirtualFileSystem/Ext2FileSystem.cpp
+++ b/VirtualFileSystem/Ext2FileSystem.cpp
@@ -268,7 +268,7 @@ Vector<unsigned> Ext2FileSystem::blockListForInode(const ext2_inode& e2inode) co
     return list;
 }
 
-Unix::ssize_t Ext2FileSystem::readInodeBytes(InodeIdentifier inode, Unix::off_t offset, Unix::size_t count, byte* buffer) const
+Unix::ssize_t Ext2FileSystem::readInodeBytes(InodeIdentifier inode, Unix::off_t offset, Unix::size_t count, byte* buffer, FileHandle*) const
 {
     ASSERT(offset >= 0);
     ASSERT(inode.fileSystemID() == id());
@@ -293,6 +293,7 @@ Unix::ssize_t Ext2FileSystem::readInodeBytes(InodeIdentifier inode, Unix::off_t
     static const unsigned maxInlineSymlinkLength = 60;
     if (isSymbolicLink(e2inode->i_mode) && e2inode->i_size < maxInlineSymlinkLength) {
         Unix::ssize_t nread = min((Unix::off_t)e2inode->i_size - offset, static_cast<Unix::off_t>(count));
+        kprintf("nread = %d\n", nread);
         memcpy(buffer, e2inode->i_block + offset, nread);
         return nread;
     }
diff --git a/VirtualFileSystem/Ext2FileSystem.h b/VirtualFileSystem/Ext2FileSystem.h
index f7b73465ef..a0f8a74d3e 100644
--- a/VirtualFileSystem/Ext2FileSystem.h
+++ b/VirtualFileSystem/Ext2FileSystem.h
@@ -44,7 +44,7 @@ private:
     virtual InodeMetadata inodeMetadata(InodeIdentifier) const override;
     virtual bool setModificationTime(InodeIdentifier, dword timestamp) override;
     virtual InodeIdentifier createInode(InodeIdentifier parentInode, const String& name, Unix::mode_t, unsigned size) override;
-    virtual Unix::ssize_t readInodeBytes(InodeIdentifier, Unix::off_t offset, Unix::size_t count, byte* buffer) const override;
+    virtual Unix::ssize_t readInodeBytes(InodeIdentifier, Unix::off_t offset, Unix::size_t count, byte* buffer, FileHandle*) const override;
     virtual InodeIdentifier makeDirectory(InodeIdentifier parentInode, const String& name, Unix::mode_t) override;
 
     bool isDirectoryInode(unsigned) const;
diff --git a/VirtualFileSystem/FileHandle.cpp b/VirtualFileSystem/FileHandle.cpp
index c1a67dfe25..4e61f1b172 100644
--- a/VirtualFileSystem/FileHandle.cpp
+++ b/VirtualFileSystem/FileHandle.cpp
@@ -102,7 +102,7 @@ Unix::ssize_t FileHandle::read(byte* buffer, Unix::size_t count)
         // FIXME: What should happen to m_currentOffset?
         return m_vnode->characterDevice()->read(buffer, count);
     }
-    Unix::ssize_t nread = m_vnode->fileSystem()->readInodeBytes(m_vnode->inode, m_currentOffset, count, buffer);
+    Unix::ssize_t nread = m_vnode->fileSystem()->readInodeBytes(m_vnode->inode, m_currentOffset, count, buffer, this);
     m_currentOffset += nread;
     return nread;
 }
@@ -125,7 +125,7 @@ ByteBuffer FileHandle::readEntireFile()
         return buffer;
     }
 
-    return m_vnode->fileSystem()->readEntireInode(m_vnode->inode);
+    return m_vnode->fileSystem()->readEntireInode(m_vnode->inode, this);
 }
 
 bool FileHandle::isDirectory() const
diff --git a/VirtualFileSystem/FileHandle.h b/VirtualFileSystem/FileHandle.h
index 9bbabdcf0c..cc3cc4ee0a 100644
--- a/VirtualFileSystem/FileHandle.h
+++ b/VirtualFileSystem/FileHandle.h
@@ -32,6 +32,8 @@ public:
     void setBlocking(bool b) { m_isBlocking = b; }
 #endif
 
+    ByteBuffer& generatorCache() { return m_generatorCache; }
+
 private:
     friend class VirtualFileSystem;
 
@@ -39,6 +41,8 @@ private:
 
     Unix::off_t m_currentOffset { 0 };
 
+    ByteBuffer m_generatorCache;
+
 #ifdef SERENITY
     int m_fd { -1 };
     bool m_isBlocking { true };
diff --git a/VirtualFileSystem/FileSystem.cpp b/VirtualFileSystem/FileSystem.cpp
index e8b774e767..e5529b5168 100644
--- a/VirtualFileSystem/FileSystem.cpp
+++ b/VirtualFileSystem/FileSystem.cpp
@@ -50,7 +50,7 @@ InodeIdentifier FileSystem::childOfDirectoryInodeWithName(InodeIdentifier inode,
     return foundInode;
 }
 
-ByteBuffer FileSystem::readEntireInode(InodeIdentifier inode) const
+ByteBuffer FileSystem::readEntireInode(InodeIdentifier inode, FileHandle* handle) const
 {
     ASSERT(inode.fileSystemID() == id());
 
@@ -67,7 +67,7 @@ ByteBuffer FileSystem::readEntireInode(InodeIdentifier inode) const
     byte* out = contents.pointer();
     Unix::off_t offset = 0;
     for (;;) {
-        nread = readInodeBytes(inode, offset, sizeof(buffer), buffer);
+        nread = readInodeBytes(inode, offset, sizeof(buffer), buffer, handle);
         if (nread <= 0)
             break;
         memcpy(out, buffer, nread);
diff --git a/VirtualFileSystem/FileSystem.h b/VirtualFileSystem/FileSystem.h
index a32e8c4077..c6e345d4aa 100644
--- a/VirtualFileSystem/FileSystem.h
+++ b/VirtualFileSystem/FileSystem.h
@@ -16,6 +16,8 @@
 
 static const dword mepoch = 476763780;
 
+class FileHandle;
+
 class FileSystem : public Retainable<FileSystem> {
 public:
     static void initializeGlobals();
@@ -30,7 +32,7 @@ public:
     virtual bool writeInode(InodeIdentifier, const ByteBuffer&) = 0;
     virtual InodeMetadata inodeMetadata(InodeIdentifier) const = 0;
 
-    virtual Unix::ssize_t readInodeBytes(InodeIdentifier, Unix::off_t offset, Unix::size_t count, byte* buffer) const = 0;
+    virtual Unix::ssize_t readInodeBytes(InodeIdentifier, Unix::off_t offset, Unix::size_t count, byte* buffer, FileHandle*) const = 0;
 
     struct DirectoryEntry {
         String name;
@@ -44,7 +46,7 @@ public:
     virtual InodeIdentifier makeDirectory(InodeIdentifier parentInode, const String& name, Unix::mode_t) = 0;
 
     InodeIdentifier childOfDirectoryInodeWithName(InodeIdentifier, const String& name) const;
-    ByteBuffer readEntireInode(InodeIdentifier) const;
+    ByteBuffer readEntireInode(InodeIdentifier, FileHandle* = nullptr) const;
 
 protected:
     FileSystem();
diff --git a/VirtualFileSystem/InodeIdentifier.cpp b/VirtualFileSystem/InodeIdentifier.cpp
index 45aa2dd1ca..f89e7ef8ef 100644
--- a/VirtualFileSystem/InodeIdentifier.cpp
+++ b/VirtualFileSystem/InodeIdentifier.cpp
@@ -5,5 +5,5 @@ ByteBuffer InodeIdentifier::readEntireFile() const
 {
     if (!fileSystem())
         return { };
-    return fileSystem()->readEntireInode(*this);
+    return fileSystem()->readEntireInode(*this, nullptr);
 }
diff --git a/VirtualFileSystem/SyntheticFileSystem.cpp b/VirtualFileSystem/SyntheticFileSystem.cpp
index f36deeed9c..51f48c8c9c 100644
--- a/VirtualFileSystem/SyntheticFileSystem.cpp
+++ b/VirtualFileSystem/SyntheticFileSystem.cpp
@@ -1,4 +1,5 @@
 #include "SyntheticFileSystem.h"
+#include "FileHandle.h"
 #include <AK/StdLib.h>
 
 //#define SYNTHFS_DEBUG
@@ -188,7 +189,7 @@ bool SyntheticFileSystem::writeInode(InodeIdentifier, const ByteBuffer&)
     return false;
 }
 
-Unix::ssize_t SyntheticFileSystem::readInodeBytes(InodeIdentifier inode, Unix::off_t offset, Unix::size_t count, byte* buffer) const
+Unix::ssize_t SyntheticFileSystem::readInodeBytes(InodeIdentifier inode, Unix::off_t offset, Unix::size_t count, byte* buffer, FileHandle* handle) const
 {
     InterruptDisabler disabler;
 
@@ -204,12 +205,21 @@ Unix::ssize_t SyntheticFileSystem::readInodeBytes(InodeIdentifier inode, Unix::o
         return false;
     const File& file = *(*it).value;
     ByteBuffer generatedData;
-    if (file.generator)
-        generatedData = file.generator();
+    if (file.generator) {
+        if (!handle) {
+            generatedData = file.generator();
+        } else {
+            if (!handle->generatorCache())
+                handle->generatorCache() = file.generator();
+            generatedData = handle->generatorCache();
+        }
+    }
     auto* data = generatedData ? &generatedData : &file.data;
 
     Unix::ssize_t nread = min(static_cast<Unix::off_t>(data->size() - offset), static_cast<Unix::off_t>(count));
     memcpy(buffer, data->pointer() + offset, nread);
+    if (nread == 0 && handle && handle->generatorCache())
+        handle->generatorCache().clear();
     return nread;
 }
 
diff --git a/VirtualFileSystem/SyntheticFileSystem.h b/VirtualFileSystem/SyntheticFileSystem.h
index dc129caf56..2831d6d239 100644
--- a/VirtualFileSystem/SyntheticFileSystem.h
+++ b/VirtualFileSystem/SyntheticFileSystem.h
@@ -17,7 +17,7 @@ public:
     virtual InodeMetadata inodeMetadata(InodeIdentifier) const override;
     virtual bool setModificationTime(InodeIdentifier, dword timestamp) override;
     virtual InodeIdentifier createInode(InodeIdentifier parentInode, const String& name, Unix::mode_t, unsigned size) override;
-    virtual Unix::ssize_t readInodeBytes(InodeIdentifier, Unix::off_t offset, Unix::size_t count, byte* buffer) const override;
+    virtual Unix::ssize_t readInodeBytes(InodeIdentifier, Unix::off_t offset, Unix::size_t count, byte* buffer, FileHandle*) const override;
     virtual InodeIdentifier makeDirectory(InodeIdentifier parentInode, const String& name, Unix::mode_t) override;
 
 protected: