ProcessManager: Add a "Memory map" view to show a process's VM layout.

Fetch all the data from /proc/PID/vm for the selected process and show it
in a nice GTableView. :^)

Applications/ProcessManager/Makefile

@@ -6,6 +6,8 @@ OBJS = \
  MemoryStatsWidget.o \
  GraphWidget.o \
  ProcessStacksWidget.o \
+ ProcessMemoryMapWidget.o \
+ ProcessMemoryMapModel.o \
  main.o
 
 APP = ProcessManager

Applications/ProcessManager/ProcessMemoryMapModel.cpp

@@ -0,0 +1,98 @@
+#include "ProcessMemoryMapModel.h"
+#include <AK/JsonObject.h>
+#include <AK/StringBuilder.h>
+#include <LibCore/CFile.h>
+
+void ProcessMemoryMapModel::update()
+{
+ CFile file(String::format("/proc/%d/vm", m_pid));
+ if (!file.open(CIODevice::ReadOnly)) {
+ dbg() << "Unable to open " << file.filename();
+ return;
+ }
+
+ auto json = JsonValue::from_string(file.read_all());
+
+ ASSERT(json.is_array());
+ m_process_vm = json.as_array();
+
+ did_update();
+}
+
+int ProcessMemoryMapModel::row_count(const GModelIndex&) const
+{
+ return m_process_vm.size();
+}
+
+String ProcessMemoryMapModel::column_name(int column) const
+{
+ switch (column) {
+ case Column::Address:
+ return "Address";
+ case Column::Size:
+ return "Size";
+ case Column::AmountResident:
+ return "Resident";
+ case Column::Access:
+ return "Access";
+ case Column::Name:
+ return "Name";
+ default:
+ ASSERT_NOT_REACHED();
+ }
+}
+
+GModel::ColumnMetadata ProcessMemoryMapModel::column_metadata(int column) const
+{
+ switch (column) {
+ case Column::Address:
+ return { 80 };
+ case Column::Size:
+ return { 60, TextAlignment::CenterRight };
+ case Column::AmountResident:
+ return { 60, TextAlignment::CenterRight };
+ case Column::Access:
+ return { 50 };
+ case Column::Name:
+ return { 200 };
+ default:
+ ASSERT_NOT_REACHED();
+ }
+ return {};
+}
+
+GVariant ProcessMemoryMapModel::data(const GModelIndex& index, Role role) const
+{
+ auto& region_object = m_process_vm.at(index.row()).as_object();
+ if (role == GModel::Role::Display) {
+ switch (index.column()) {
+ case Column::Address:
+ return String::format("%#x", region_object.get("address").to_u32());
+ case Column::Size:
+ return region_object.get("size").to_int();
+ case Column::AmountResident:
+ return region_object.get("amount_resident").to_int();
+ case Column::Access: {
+ StringBuilder builder;
+ if (region_object.get("readable").to_bool())
+ builder.append('R');
+ if (region_object.get("writable").to_bool())
+ builder.append('W');
+ return builder.to_string();
+ }
+ case Column::Name:
+ return region_object.get("name").to_string();
+ default:
+ ASSERT_NOT_REACHED();
+ }
+ }
+ return {};
+}
+
+void ProcessMemoryMapModel::set_pid(pid_t pid)
+{
+ if (m_pid == pid)
+ return;
+ m_pid = pid;
+ update();
+}

Applications/ProcessManager/ProcessMemoryMapModel.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <AK/JsonArray.h>
+#include <LibGUI/GModel.h>
+
+class ProcessMemoryMapModel final : public GModel {
+public:
+ enum Column {
+ Address,
+ Size,
+ AmountResident,
+ Access,
+ Name,
+ __Count
+ };
+
+ ProcessMemoryMapModel() {}
+ virtual ~ProcessMemoryMapModel() override {}
+
+ virtual int row_count(const GModelIndex& = GModelIndex()) const override;
+ virtual int column_count(const GModelIndex& = GModelIndex()) const override { return Column::__Count; }
+ virtual String column_name(int) const override;
+ virtual ColumnMetadata column_metadata(int) const override;
+ virtual GVariant data(const GModelIndex&, Role = Role::Display) const override;
+ virtual void update() override;
+
+ void set_pid(pid_t);
+
+private:
+ JsonArray m_process_vm;
+ int m_pid { -1 };
+};

Applications/ProcessManager/ProcessMemoryMapWidget.cpp

@@ -0,0 +1,25 @@
+#include "ProcessMemoryMapWidget.h"
+#include "ProcessMemoryMapModel.h"
+#include <LibGUI/GBoxLayout.h>
+#include <LibGUI/GTableView.h>
+
+ProcessMemoryMapWidget::ProcessMemoryMapWidget(GWidget* parent)
+ : GWidget(parent)
+{
+ set_layout(make<GBoxLayout>(Orientation::Vertical));
+ layout()->set_margins({ 4, 4, 4, 4 });
+ m_table_view = new GTableView(this);
+ m_table_view->set_model(adopt(*new ProcessMemoryMapModel));
+}
+
+ProcessMemoryMapWidget::~ProcessMemoryMapWidget()
+{
+}
+
+void ProcessMemoryMapWidget::set_pid(pid_t pid)
+{
+ if (m_pid == pid)
+ return;
+ m_pid = pid;
+ static_cast<ProcessMemoryMapModel*>(m_table_view->model())->set_pid(pid);
+}

Applications/ProcessManager/ProcessMemoryMapWidget.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <LibGUI/GWidget.h>
+
+class GTableView;
+
+class ProcessMemoryMapWidget final : public GWidget {
+ C_OBJECT(ProcessMemoryMapWidget);
+public:
+ explicit ProcessMemoryMapWidget(GWidget* parent);
+ virtual ~ProcessMemoryMapWidget() override;
+
+ void set_pid(pid_t);
+
+private:
+ GTableView* m_table_view { nullptr };
+ pid_t m_pid { -1 };
+};

Applications/ProcessManager/main.cpp

@@ -1,5 +1,6 @@
 #include "GraphWidget.h"
 #include "MemoryStatsWidget.h"
+#include "ProcessMemoryMapWidget.h"
 #include "ProcessStacksWidget.h"
 #include "ProcessTableView.h"
 #include <LibCore/CTimer.h>
@@ -155,11 +156,16 @@ int main(int argc, char** argv)
  app.set_menubar(move(menubar));
 
  auto* process_tab_widget = new GTabWidget(process_container_splitter);
+
+ auto* memory_map_widget = new ProcessMemoryMapWidget(nullptr);
+ process_tab_widget->add_widget("Memory map", memory_map_widget);
+
  auto* stacks_widget = new ProcessStacksWidget(nullptr);
  process_tab_widget->add_widget("Stacks", stacks_widget);
 
  process_table_view->on_process_selected = [&](pid_t pid) {
  stacks_widget->set_pid(pid);
+ memory_map_widget->set_pid(pid);
  };
 
  auto* window = new GWindow;