Add basic zero faults.

mmap() will now map uncommitted pages that get allocated and zeroed upon the
first access. I also made /proc/PID/vm show number of "committed" bytes in
each region. This is so cool! :^)

Kernel/MemoryManager.cpp

@@ -224,6 +224,24 @@ Region* MemoryManager::region_from_laddr(Process& process, LinearAddress laddr)
     return nullptr;
 }
 
+bool MemoryManager::zero_page(PageDirectory& page_directory, Region& region, unsigned page_index_in_region)
+{
+    ASSERT_INTERRUPTS_DISABLED();
+    auto& vmo = region.vmo();
+    auto physical_page = allocate_physical_page();
+    byte* dest_ptr = quickmap_page(*physical_page);
+    memset(dest_ptr, 0, PAGE_SIZE);
+#ifdef PAGE_FAULT_DEBUG
+    dbgprintf("      >> ZERO P%x\n", physical_page->paddr().get());
+#endif
+    unquickmap_page();
+    region.cow_map.set(page_index_in_region, false);
+    vmo.physical_pages()[page_index_in_region] = move(physical_page);
+    unquickmap_page();
+    remap_region_page(&page_directory, region, page_index_in_region, true);
+    return true;
+}
+
 bool MemoryManager::copy_on_write(Process& process, Region& region, unsigned page_index_in_region)
 {
     ASSERT_INTERRUPTS_DISABLED();
@@ -325,7 +343,9 @@ PageFaultResponse MemoryManager::handle_page_fault(const PageFault& fault)
             page_in_from_vnode(*current->m_page_directory, *region, page_index_in_region);
             return PageFaultResponse::Continue;
         } else {
-            kprintf("NP(error) fault in Region{%p}[%u]\n", region, page_index_in_region);
+            dbgprintf("NP(zero) fault in Region{%p}[%u]\n", region, page_index_in_region);
+            zero_page(*current->m_page_directory, *region, page_index_in_region);
+            return PageFaultResponse::Continue;
         }
     } else if (fault.is_protection_violation()) {
         if (region->cow_map.get(page_index_in_region)) {
@@ -761,3 +781,13 @@ inline bool PageDirectory::is_active() const
 {
     return &current->page_directory() == this;
 }
+
+size_t Region::committed() const
+{
+    size_t bytes = 0;
+    for (size_t i = 0; i < page_count(); ++i) {
+        if (m_vmo->physical_pages()[first_page_index() + i])
+            bytes += PAGE_SIZE;
+    }
+    return bytes;
+}

Kernel/MemoryManager.h

@@ -132,6 +132,8 @@ public:
     int commit(Process&);
     int decommit(Process&);
 
+    size_t committed() const;
+
     LinearAddress linearAddress;
     size_t size { 0 };
     size_t m_offset_in_vmo { 0 };
@@ -209,6 +211,7 @@ private:
 
     bool copy_on_write(Process&, Region&, unsigned page_index_in_region);
     bool page_in_from_vnode(PageDirectory&, Region&, unsigned page_index_in_region);
+    bool zero_page(PageDirectory&, Region& region, unsigned page_index_in_region);
 
     byte* quickmap_page(PhysicalPage&);
     void unquickmap_page();

Kernel/ProcFileSystem.cpp

@@ -52,12 +52,13 @@ ByteBuffer procfs$pid_vm(Process& process)
     auto stringImpl = StringImpl::createUninitialized(80 + process.regionCount() * 160 + 4096, buffer);
     memset(buffer, 0, stringImpl->length());
     char* ptr = buffer;
-    ptr += ksprintf(ptr, "BEGIN       END         SIZE        NAME\n");
+    ptr += ksprintf(ptr, "BEGIN       END         SIZE      COMMIT     NAME\n");
     for (auto& region : process.regions()) {
-        ptr += ksprintf(ptr, "%x -- %x    %x    %s\n",
+        ptr += ksprintf(ptr, "%x -- %x    %x  %x   %s\n",
             region->linearAddress.get(),
             region->linearAddress.offset(region->size - 1).get(),
             region->size,
+            region->committed(),
             region->name.characters());
     }
     *ptr = '\0';

Kernel/Process.cpp

@@ -65,7 +65,7 @@ Vector<Process*> Process::allProcesses()
     return processes;
 }
 
-Region* Process::allocate_region(LinearAddress laddr, size_t size, String&& name, bool is_readable, bool is_writable)
+Region* Process::allocate_region(LinearAddress laddr, size_t size, String&& name, bool is_readable, bool is_writable, bool commit)
 {
     // FIXME: This needs sanity checks. What if this overlaps existing regions?
     if (laddr.is_null()) {
@@ -74,6 +74,7 @@ Region* Process::allocate_region(LinearAddress laddr, size_t size, String&& name
     }
     laddr.mask(0xfffff000);
     m_regions.append(adopt(*new Region(laddr, size, move(name), is_readable, is_writable)));
+    if (commit)
         m_regions.last()->commit(*this);
     MM.mapRegion(*this, *m_regions.last());
     return m_regions.last().ptr();
@@ -161,7 +162,7 @@ void* Process::sys$mmap(const Syscall::SC_mmap_params* params)
         InterruptDisabler disabler;
         // FIXME: Implement mapping at a client-specified address. Most of the support is already in plcae.
         ASSERT(addr == nullptr);
-        auto* region = allocate_region(LinearAddress(), size, "mmap", prot & PROT_READ, prot & PROT_WRITE);
+        auto* region = allocate_region(LinearAddress(), size, "mmap", prot & PROT_READ, prot & PROT_WRITE, false);
         if (!region)
             return (void*)-ENOMEM;
         return region->linearAddress.asPtr();

Kernel/Process.h

@@ -283,7 +283,7 @@ private:
 
     TTY* m_tty { nullptr };
 
-    Region* allocate_region(LinearAddress, size_t, String&& name, bool is_readable = true, bool is_writable = true);
+    Region* allocate_region(LinearAddress, size_t, String&& name, bool is_readable = true, bool is_writable = true, bool commit = true);
     Region* allocate_file_backed_region(LinearAddress, size_t, RetainPtr<Vnode>&& vnode, String&& name, bool is_readable, bool is_writable);
     Region* allocate_region_with_vmo(LinearAddress, size_t, RetainPtr<VMObject>&&, size_t offset_in_vmo, String&& name, bool is_readable, bool is_writable);
     bool deallocate_region(Region& region);