[kernel] Improve VMA lifecycle

The vm_area objects had a number of issues I have been running into when
working on srv.init:

- It was impossible to map a VMA, fill it, unmap it, and hand it to
  another process. Unmapping the VMA in this process would cause all the
  pages to be freed, since it was removed from its last mapping.
- If a VMA was marked with vm_flag::zero, it would be zeroed out _every
  time_ it was mapped into a vm_space.
- The vm_area_open class was leaking its page_tree nodes.

In order to fix these issues, the different VMA types all work slightly
differently now:

- Physical pages allocated for a VMA are now freed when the VMA is
  deleted, not when it is unmapped.
- A knock-on effect from the first point is that vm_area_guarded is now
  based on vm_area_open, instead of vm_area_untracked. An untracked area
  cannot free its pages, since it does not track them.
- The vm_area_open type now deletes its root page_tree node. And
  page_tree nodes will delete child nodes or free physical pages in
  their dtors.
- vm_flag::zero has been removed; pages will need to be zeroed out
  further at a higher level.
- vm_area also no longer deletes itself only on losing its last handle -
  it will only self-delete when all handles _and_ mappings are gone.

src/kernel/objects/vm_area.cpp

@@ -27,20 +27,21 @@ vm_area::add_to(vm_space *space)
     return true;
 }
 
-bool
+void
 vm_area::remove_from(vm_space *space)
 {
     m_spaces.remove_swap(space);
-    return
-        !m_spaces.count() &&
-        !(m_flags && vm_flags::mmio);
+    if (!m_spaces.count() &&
+        check_signal(j6_signal_no_handles))
+        delete this;
 }
 
 void
 vm_area::on_no_handles()
 {
     kobject::on_no_handles();
-    delete this;
+    if (!m_spaces.count())
+        delete this;
 }
 
 size_t
@@ -66,15 +67,24 @@ vm_area_fixed::vm_area_fixed(uintptr_t start, size_t size, vm_flags flags) :
 {
 }
 
-vm_area_fixed::~vm_area_fixed() {}
+vm_area_fixed::~vm_area_fixed()
+{
+    if (m_flags && vm_flags::mmio)
+        return;
 
-size_t vm_area_fixed::resize(size_t size)
+    size_t pages = memory::page_count(m_size);
+    frame_allocator::get().free(m_start, pages);
+}
+
+size_t
+vm_area_fixed::resize(size_t size)
 {
     // Not resizable
     return m_size;
 }
 
-bool vm_area_fixed::get_page(uintptr_t offset, uintptr_t &phys)
+bool
+vm_area_fixed::get_page(uintptr_t offset, uintptr_t &phys)
 {
     if (offset > m_size)
         return false;
@@ -83,13 +93,15 @@ bool vm_area_fixed::get_page(uintptr_t offset, uintptr_t &phys)
     return true;
 }
 
-
 vm_area_untracked::vm_area_untracked(size_t size, vm_flags flags) :
     vm_area {size, flags}
 {
 }
 
-vm_area_untracked::~vm_area_untracked() {}
+vm_area_untracked::~vm_area_untracked()
+{
+    kassert(false, "An untracked VMA's pages cannot be reclaimed, leaking memory");
+}
 
 bool
 vm_area_untracked::get_page(uintptr_t offset, uintptr_t &phys)
@@ -115,7 +127,11 @@ vm_area_open::vm_area_open(size_t size, vm_flags flags) :
 {
 }
 
-vm_area_open::~vm_area_open() {}
+vm_area_open::~vm_area_open()
+{
+    // the page_tree will free its pages when deleted
+    delete m_mapped;
+}
 
 bool
 vm_area_open::get_page(uintptr_t offset, uintptr_t &phys)
@@ -128,7 +144,7 @@ vm_area_guarded::vm_area_guarded(uintptr_t start, size_t buf_pages, size_t size,
     m_start {start},
     m_pages {buf_pages},
     m_next {memory::frame_size},
-    vm_area_untracked {size, flags}
+    vm_area_open {size, flags}
 {
 }
 
@@ -164,6 +180,5 @@ vm_area_guarded::get_page(uintptr_t offset, uintptr_t &phys)
     if ((offset >> 12) % (m_pages+1) == 0)
         return false;
 
-    return vm_area_untracked::get_page(offset, phys);
+    return vm_area_open::get_page(offset, phys);
 }
-