gecko-dev/xpcom/base/SystemMemoryReporter.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "mozilla/SystemMemoryReporter.h"

#include "mozilla/Attributes.h"
#include "mozilla/LinuxUtils.h"
#include "mozilla/PodOperations.h"
#include "mozilla/Preferences.h"
#include "mozilla/TaggedAnonymousMemory.h"
#include "mozilla/Unused.h"

#include "nsDataHashtable.h"
#include "nsIMemoryReporter.h"
#include "nsPrintfCString.h"
#include "nsString.h"
#include "nsTHashtable.h"
#include "nsHashKeys.h"

#include <dirent.h>
#include <inttypes.h>
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>

// This file implements a Linux-specific, system-wide memory reporter.  It
// gathers all the useful memory measurements obtainable from the OS in a
// single place, giving a high-level view of memory consumption for the entire
// machine/device.
//
// Other memory reporters measure part of a single process's memory consumption.
// This reporter is different in that it measures memory consumption of many
// processes, and they end up in a single reports tree.  This is a slight abuse
// of the memory reporting infrastructure, and therefore the results are given
// their own "process" called "System", which means they show up in about:memory
// in their own section, distinct from the per-process sections.

namespace mozilla {
namespace SystemMemoryReporter {

#if !defined(XP_LINUX)
#error "This won't work if we're not on Linux."
#endif

/**
 * RAII helper that will close an open DIR handle.
 */
struct MOZ_STACK_CLASS AutoDir
{
  explicit AutoDir(DIR* aDir) : mDir(aDir) {}
  ~AutoDir() { if (mDir) closedir(mDir); };
  DIR* mDir;
};

/**
 * RAII helper that will close an open FILE handle.
 */
struct MOZ_STACK_CLASS AutoFile
{
  explicit AutoFile(FILE* aFile) : mFile(aFile) {}
  ~AutoFile() { if (mFile) fclose(mFile); }
  FILE* mFile;
};

static bool
EndsWithLiteral(const nsCString& aHaystack, const char* aNeedle)
{
  int32_t idx = aHaystack.RFind(aNeedle);
  return idx != -1 && idx + strlen(aNeedle) == aHaystack.Length();
}

static void
GetDirname(const nsCString& aPath, nsACString& aOut)
{
  int32_t idx = aPath.RFind("/");
  if (idx == -1) {
    aOut.Truncate();
  } else {
    aOut.Assign(Substring(aPath, 0, idx));
  }
}

static void
GetBasename(const nsCString& aPath, nsACString& aOut)
{
  nsCString out;
  int32_t idx = aPath.RFind("/");
  if (idx == -1) {
    out.Assign(aPath);
  } else {
    out.Assign(Substring(aPath, idx + 1));
  }

  // On Android, some entries in /dev/ashmem end with "(deleted)" (e.g.
  // "/dev/ashmem/libxul.so(deleted)").  We don't care about this modifier, so
  // cut it off when getting the entry's basename.
  if (EndsWithLiteral(out, "(deleted)")) {
    out.Assign(Substring(out, 0, out.RFind("(deleted)")));
  }
  out.StripChars(" ");

  aOut.Assign(out);
}

static bool
IsNumeric(const char* aStr)
{
  MOZ_ASSERT(*aStr);  // shouldn't see empty strings
  while (*aStr) {
    if (!isdigit(*aStr)) {
      return false;
    }
    ++aStr;
  }
  return true;
}

static bool
IsAnonymous(const nsACString& aName)
{
  // Recent kernels have multiple [stack:nnnn] entries, where |nnnn| is a
  // thread ID.  However, the entire virtual memory area containing a thread's
  // stack pointer is considered the stack for that thread, even if it was
  // merged with an adjacent area containing non-stack data.  So we treat them
  // as regular anonymous memory.  However, see below about tagged anonymous
  // memory.
  return aName.IsEmpty() ||
         StringBeginsWith(aName, NS_LITERAL_CSTRING("[stack:"));
}

class SystemReporter final : public nsIMemoryReporter
{
  ~SystemReporter() {}

public:
  NS_DECL_THREADSAFE_ISUPPORTS

#define REPORT(_path, _units, _amount, _desc)                                 \
  do {                                                                        \
    size_t __amount = _amount;  /* evaluate _amount only once */              \
    if (__amount > 0) {                                                       \
      aHandleReport->Callback(NS_LITERAL_CSTRING("System"), _path,            \
                              KIND_OTHER, _units, __amount, _desc, aData);    \
    }                                                                         \
  } while (0)

  NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                            nsISupports* aData, bool aAnonymize) override
  {
    // There is lots of privacy-sensitive data in /proc. Just skip this
    // reporter entirely when anonymization is required.
    if (aAnonymize) {
      return NS_OK;
    }

    if (!Preferences::GetBool("memory.system_memory_reporter")) {
      return NS_OK;
    }

    // Read relevant fields from /proc/meminfo.
    int64_t memTotal = 0, memFree = 0;
    nsresult rv1 = ReadMemInfo(&memTotal, &memFree);

    // Collect per-process reports from /proc/<pid>/smaps.
    int64_t totalPss = 0;
    nsresult rv2 = CollectProcessReports(aHandleReport, aData, &totalPss);

    // Report the non-process numbers.
    if (NS_SUCCEEDED(rv1) && NS_SUCCEEDED(rv2)) {
      int64_t other = memTotal - memFree - totalPss;
      REPORT(NS_LITERAL_CSTRING("mem/other"), UNITS_BYTES, other,
             NS_LITERAL_CSTRING(
"Memory which is neither owned by any user-space process nor free. Note that "
"this includes memory holding cached files from the disk which can be "
"reclaimed by the OS at any time."));

      REPORT(NS_LITERAL_CSTRING("mem/free"), UNITS_BYTES, memFree,
             NS_LITERAL_CSTRING(
"Memory which is free and not being used for any purpose."));
    }

    // Report reserved memory not included in memTotal.
    CollectPmemReports(aHandleReport, aData);

    // Report zram usage statistics.
    CollectZramReports(aHandleReport, aData);

    // Report kgsl graphics memory usage.
    CollectKgslReports(aHandleReport, aData);

    // Report ION memory usage.
    CollectIonReports(aHandleReport, aData);

    return NS_OK;
  }

private:
  // These are the cross-cutting measurements across all processes.
  class ProcessSizes
  {
  public:
    void Add(const nsACString& aKey, size_t aSize)
    {
      mTagged.Put(aKey, mTagged.Get(aKey) + aSize);
    }

    void Report(nsIHandleReportCallback* aHandleReport, nsISupports* aData)
    {
      for (auto iter = mTagged.Iter(); !iter.Done(); iter.Next()) {
        nsCStringHashKey::KeyType key = iter.Key();
        size_t amount = iter.UserData();

        nsAutoCString path("processes/");
        path.Append(key);

        nsAutoCString desc("This is the sum of all processes' '");
        desc.Append(key);
        desc.AppendLiteral("' numbers.");

        REPORT(path, UNITS_BYTES, amount, desc);
      }
    }

  private:
    nsDataHashtable<nsCStringHashKey, size_t> mTagged;
  };

  nsresult ReadMemInfo(int64_t* aMemTotal, int64_t* aMemFree)
  {
    FILE* f = fopen("/proc/meminfo", "r");
    if (!f) {
      return NS_ERROR_FAILURE;
    }

    int n1 = fscanf(f, "MemTotal: %" SCNd64 " kB\n", aMemTotal);
    int n2 = fscanf(f, "MemFree: %"  SCNd64 " kB\n", aMemFree);

    fclose(f);

    if (n1 != 1 || n2 != 1) {
      return NS_ERROR_FAILURE;
    }

    // Convert from KB to B.
    *aMemTotal *= 1024;
    *aMemFree  *= 1024;

    return NS_OK;
  }

  nsresult CollectProcessReports(nsIHandleReportCallback* aHandleReport,
                                 nsISupports* aData,
                                 int64_t* aTotalPss)
  {
    *aTotalPss = 0;
    ProcessSizes processSizes;

    DIR* d = opendir("/proc");
    if (NS_WARN_IF(!d)) {
      return NS_ERROR_FAILURE;
    }
    struct dirent* ent;
    while ((ent = readdir(d))) {
      struct stat statbuf;
      const char* pidStr = ent->d_name;
      // Don't check the return value of stat() -- it can return -1 for these
      // directories even when it has succeeded, apparently.
      stat(pidStr, &statbuf);
      if (S_ISDIR(statbuf.st_mode) && IsNumeric(pidStr)) {
        nsCString processName("process(");

        // Get the command name from cmdline.  If that fails, the pid is still
        // shown.
        nsPrintfCString cmdlinePath("/proc/%s/cmdline", pidStr);
        FILE* f = fopen(cmdlinePath.get(), "r");
        if (f) {
          static const size_t len = 256;
          char buf[len];
          if (fgets(buf, len, f)) {
            processName.Append(buf);
            // A hack: replace forward slashes with '\\' so they aren't treated
            // as path separators.  Consumers of this reporter (such as
            // about:memory) have to undo this change.
            processName.ReplaceChar('/', '\\');
            processName.AppendLiteral(", ");
          }
          fclose(f);
        }
        processName.AppendLiteral("pid=");
        processName.Append(pidStr);
        processName.Append(')');

        // Read the PSS values from the smaps file.
        nsPrintfCString smapsPath("/proc/%s/smaps", pidStr);
        f = fopen(smapsPath.get(), "r");
        if (!f) {
          // Processes can terminate between the readdir() call above and now,
          // so just skip if we can't open the file.
          continue;
        }
        ParseMappings(f, processName, aHandleReport, aData, &processSizes,
                      aTotalPss);
        fclose(f);

        // Report the open file descriptors for this process.
        nsPrintfCString procFdPath("/proc/%s/fd", pidStr);
        CollectOpenFileReports(aHandleReport, aData, procFdPath, processName);
      }
    }
    closedir(d);

    // Report the "processes/" tree.
    processSizes.Report(aHandleReport, aData);

    return NS_OK;
  }

  void ParseMappings(FILE* aFile,
                     const nsACString& aProcessName,
                     nsIHandleReportCallback* aHandleReport,
                     nsISupports* aData,
                     ProcessSizes* aProcessSizes,
                     int64_t* aTotalPss)
  {
    // The first line of an entry in /proc/<pid>/smaps looks just like an entry
    // in /proc/<pid>/maps:
    //
    //   address           perms offset  dev   inode  pathname
    //   02366000-025d8000 rw-p 00000000 00:00 0      [heap]
    //
    // Each of the following lines contains a key and a value, separated
    // by ": ", where the key does not contain either of those characters.
    // Assuming more than this about the structure of those lines has
    // failed to be future-proof in the past, so we avoid doing so.
    //
    // This makes it difficult to detect the start of a new entry
    // until it's been removed from the stdio buffer, so we just loop
    // over all lines in the file in this routine.

    const int argCount = 8;

    unsigned long long addrStart, addrEnd;
    char perms[5];
    unsigned long long offset;
    // The 2.6 and 3.0 kernels allocate 12 bits for the major device number and
    // 20 bits for the minor device number.  Future kernels might allocate more.
    // 64 bits ought to be enough for anybody.
    char devMajor[17];
    char devMinor[17];
    unsigned int inode;
    char line[1025];

    // This variable holds the path of the current entry, or is void
    // if we're scanning for the start of a new entry.
    nsAutoCString currentPath;
    int pathOffset;

    currentPath.SetIsVoid(true);
    while (fgets(line, sizeof(line), aFile)) {
      if (currentPath.IsVoid()) {
        int n = sscanf(line,
                       "%llx-%llx %4s %llx "
                       "%16[0-9a-fA-F]:%16[0-9a-fA-F] %u %n",
                       &addrStart, &addrEnd, perms, &offset, devMajor,
                       devMinor, &inode, &pathOffset);

        if (n >= argCount - 1) {
          currentPath.Assign(line + pathOffset);
          currentPath.StripChars("\n");
        }
        continue;
      }

      // Now that we have a name and other metadata, scan for the PSS.
      size_t pss_kb;
      int n = sscanf(line, "Pss: %zu", &pss_kb);
      if (n < 1) {
        continue;
      }

      size_t pss = pss_kb * 1024;
      if (pss > 0) {
        nsAutoCString name, description, tag;
        GetReporterNameAndDescription(currentPath.get(), perms, name, description, tag);

        nsAutoCString processMemPath("mem/processes/");
        processMemPath.Append(aProcessName);
        processMemPath.Append('/');
        processMemPath.Append(name);

        REPORT(processMemPath, UNITS_BYTES, pss, description);

        // Increment the appropriate aProcessSizes values, and the total.
        aProcessSizes->Add(tag, pss);
        *aTotalPss += pss;
      }

      // Now that we've seen the PSS, we're done with this entry.
      currentPath.SetIsVoid(true);
    }
  }

  void GetReporterNameAndDescription(const char* aPath,
                                     const char* aPerms,
                                     nsACString& aName,
                                     nsACString& aDesc,
                                     nsACString& aTag)
  {
    aName.Truncate();
    aDesc.Truncate();
    aTag.Truncate();

    // If aPath points to a file, we have its absolute path; it might
    // also be a bracketed pseudo-name (see below).  In either case
    // there is also some whitespace to trim.
    nsAutoCString absPath;
    absPath.Append(aPath);
    absPath.StripChars(" ");

    if (absPath.EqualsLiteral("[heap]")) {
      aName.AppendLiteral("anonymous/brk-heap");
      aDesc.AppendLiteral(
        "Memory in anonymous mappings within the boundaries defined by "
        "brk() / sbrk().  This is likely to be just a portion of the "
        "application's heap; the remainder lives in other anonymous mappings. "
        "This corresponds to '[heap]' in /proc/<pid>/smaps.");
      aTag = aName;
    } else if (absPath.EqualsLiteral("[stack]")) {
      aName.AppendLiteral("stack/main-thread");
      aDesc.AppendPrintf(
        "The stack size of the process's main thread.  This corresponds to "
        "'[stack]' in /proc/<pid>/smaps.");
      aTag = aName;
    } else if (MozTaggedMemoryIsSupported() &&
               StringBeginsWith(absPath, NS_LITERAL_CSTRING("[stack:"))) {
      // If tagged memory is supported, we can be reasonably sure that
      // the virtual memory area containing the stack hasn't been
      // merged with unrelated heap memory.  (This prevents the
      // "[stack:" entries from reaching the IsAnonymous case below.)
      pid_t tid = atoi(absPath.get() + 7);
      nsAutoCString threadName, escapedThreadName;
      LinuxUtils::GetThreadName(tid, threadName);
      if (threadName.IsEmpty()) {
        threadName.AssignLiteral("<unknown>");
      }
      escapedThreadName.Assign(threadName);
      escapedThreadName.StripChars("()");
      escapedThreadName.ReplaceChar('/', '\\');

      aName.AppendLiteral("stack/non-main-thread");
      aName.AppendLiteral("/name(");
      aName.Append(escapedThreadName);
      aName.Append(')');
      aTag = aName;
      aName.AppendPrintf("/thread(%d)", tid);

      aDesc.AppendPrintf("The stack size of a non-main thread named '%s' with "
                         "thread ID %d.  This corresponds to '[stack:%d]' "
                         "in /proc/%d/smaps.", threadName.get(), tid, tid, tid);
    } else if (absPath.EqualsLiteral("[vdso]")) {
      aName.AppendLiteral("vdso");
      aDesc.AppendLiteral(
        "The virtual dynamically-linked shared object, also known as the "
        "'vsyscall page'. This is a memory region mapped by the operating "
        "system for the purpose of allowing processes to perform some "
        "privileged actions without the overhead of a syscall.");
      aTag = aName;
    } else if (StringBeginsWith(absPath, NS_LITERAL_CSTRING("[anon:")) &&
               EndsWithLiteral(absPath, "]")) {
      // It's tagged memory; see also "mfbt/TaggedAnonymousMemory.h".
      nsAutoCString tag(Substring(absPath, 6, absPath.Length() - 7));

      aName.AppendLiteral("anonymous/");
      aName.Append(tag);
      aTag = aName;
      aDesc.AppendLiteral("Memory in anonymous mappings tagged with '");
      aDesc.Append(tag);
      aDesc.Append('\'');
    } else if (!IsAnonymous(absPath)) {
      // We now know it's an actual file.  Truncate this to its
      // basename, and put the absolute path in the description.
      nsAutoCString basename, dirname;
      GetBasename(absPath, basename);
      GetDirname(absPath, dirname);

      // Hack: A file is a shared library if the basename contains ".so" and
      // its dirname contains "/lib", or if the basename ends with ".so".
      if (EndsWithLiteral(basename, ".so") ||
          (basename.Find(".so") != -1 && dirname.Find("/lib") != -1)) {
        aName.AppendLiteral("shared-libraries/");
        aTag = aName;

        if (strncmp(aPerms, "r-x", 3) == 0) {
          aTag.AppendLiteral("read-executable");
        } else if (strncmp(aPerms, "rw-", 3) == 0) {
          aTag.AppendLiteral("read-write");
        } else if (strncmp(aPerms, "r--", 3) == 0) {
          aTag.AppendLiteral("read-only");
        } else {
          aTag.AppendLiteral("other");
        }

      } else {
        aName.AppendLiteral("other-files");
        if (EndsWithLiteral(basename, ".xpi")) {
          aName.AppendLiteral("/extensions");
        } else if (dirname.Find("/fontconfig") != -1) {
          aName.AppendLiteral("/fontconfig");
        } else {
          aName.AppendLiteral("/misc");
        }
        aTag = aName;
        aName.Append('/');
      }

      aName.Append(basename);
      aDesc.Append(absPath);
    } else {
      if (MozTaggedMemoryIsSupported()) {
        aName.AppendLiteral("anonymous/untagged");
        aDesc.AppendLiteral("Memory in untagged anonymous mappings.");
        aTag = aName;
      } else {
        aName.AppendLiteral("anonymous/outside-brk");
        aDesc.AppendLiteral("Memory in anonymous mappings outside the "
                            "boundaries defined by brk() / sbrk().");
        aTag = aName;
      }
    }

    aName.AppendLiteral("/[");
    aName.Append(aPerms);
    aName.Append(']');

    // Append the permissions.  This is useful for non-verbose mode in
    // about:memory when the filename is long and goes of the right side of the
    // window.
    aDesc.AppendLiteral(" [");
    aDesc.Append(aPerms);
    aDesc.Append(']');
  }

  void CollectPmemReports(nsIHandleReportCallback* aHandleReport,
                          nsISupports* aData)
  {
    // The pmem subsystem allocates physically contiguous memory for
    // interfacing with hardware.  In order to ensure availability,
    // this memory is reserved during boot, and allocations are made
    // within these regions at runtime.
    //
    // There are typically several of these pools allocated at boot.
    // The /sys/kernel/pmem_regions directory contains a subdirectory
    // for each one.  Within each subdirectory, the files we care
    // about are "size" (the total amount of physical memory) and
    // "mapped_regions" (a list of the current allocations within that
    // area).
    DIR* d = opendir("/sys/kernel/pmem_regions");
    if (!d) {
      return;
    }

    struct dirent* ent;
    while ((ent = readdir(d))) {
      const char* name = ent->d_name;
      uint64_t size;
      int scanned;

      // Skip "." and ".." (and any other dotfiles).
      if (name[0] == '.') {
        continue;
      }

      // Read the total size.  The file gives the size in decimal and
      // hex, in the form "13631488(0xd00000)"; we parse the former.
      nsPrintfCString sizePath("/sys/kernel/pmem_regions/%s/size", name);
      FILE* sizeFile = fopen(sizePath.get(), "r");
      if (NS_WARN_IF(!sizeFile)) {
        continue;
      }
      scanned = fscanf(sizeFile, "%" SCNu64, &size);
      fclose(sizeFile);
      if (NS_WARN_IF(scanned != 1)) {
        continue;
      }

      // Read mapped regions; format described below.
      uint64_t freeSize = size;
      nsPrintfCString regionsPath("/sys/kernel/pmem_regions/%s/mapped_regions",
                                  name);
      FILE* regionsFile = fopen(regionsPath.get(), "r");
      if (regionsFile) {
        static const size_t bufLen = 4096;
        char buf[bufLen];
        while (fgets(buf, bufLen, regionsFile)) {
          int pid;

          // Skip header line.
          if (strncmp(buf, "pid #", 5) == 0) {
            continue;
          }
          // Line format: "pid N:" + zero or more "(Start,Len) ".
          // N is decimal; Start and Len are in hex.
          scanned = sscanf(buf, "pid %d", &pid);
          if (NS_WARN_IF(scanned != 1)) {
            continue;
          }
          for (const char* nextParen = strchr(buf, '(');
               nextParen != nullptr;
               nextParen = strchr(nextParen + 1, '(')) {
            uint64_t mapStart, mapLen;

            scanned = sscanf(nextParen + 1, "%" SCNx64 ",%" SCNx64,
                             &mapStart, &mapLen);
            if (NS_WARN_IF(scanned != 2)) {
              break;
            }

            nsPrintfCString path("mem/pmem/used/%s/segment(pid=%d, "
                                 "offset=0x%" PRIx64 ")", name, pid, mapStart);
            nsPrintfCString desc("Physical memory reserved for the \"%s\" pool "
                                 "and allocated to a buffer.", name);
            REPORT(path, UNITS_BYTES, mapLen, desc);
            freeSize -= mapLen;
          }
        }
        fclose(regionsFile);
      }

      nsPrintfCString path("mem/pmem/free/%s", name);
      nsPrintfCString desc("Physical memory reserved for the \"%s\" pool and "
                           "unavailable to the rest of the system, but not "
                           "currently allocated.", name);
      REPORT(path, UNITS_BYTES, freeSize, desc);
    }
    closedir(d);
  }

  void
  CollectIonReports(nsIHandleReportCallback* aHandleReport,
                    nsISupports* aData)
  {
    // ION is a replacement for PMEM (and other similar allocators).
    //
    // More details from http://lwn.net/Articles/480055/
    //  "Like its PMEM-like predecessors, ION manages one or more memory pools,
    //   some of which are set aside at boot time to combat fragmentation or to
    //   serve special hardware needs. GPUs, display controllers, and cameras
    //   are some of the hardware blocks that may have special memory
    //   requirements."
    //
    // The file format starts as follows:
    //     client              pid             size
    //     ----------------------------------------------------
    //     adsprpc-smd                1             4096
    //     fd900000.qcom,mdss_mdp     1          1658880
    //     ----------------------------------------------------
    //     orphaned allocations (info is from last known client):
    //     Homescreen            24100           294912 0 1
    //     b2g                   23987          1658880 0 1
    //     mdss_fb0                401          1658880 0 1
    //     b2g                   23987             4096 0 1
    //     Built-in Keyboa       24205            61440 0 1
    //     ----------------------------------------------------
    //     <other stuff>
    //
    // For our purposes we only care about the first portion of the file noted
    // above which contains memory alloations (both sections). The term
    // "orphaned" is misleading, it appears that every allocation not by the
    // first process is considered orphaned on FxOS devices.

    // The first three fields of each entry interest us:
    //   1) client - Essentially the process name. We limit client names to 63
    //               characters, in theory they should never be greater than 15
    //               due to thread name length limitations.
    //   2) pid    - The ID of the allocating process, read as a uint32_t.
    //   3) size   - The size of the allocation in bytes, read as as a uint64_t.
    const char* const kFormatString = "%63s %" SCNu32 " %" SCNu64;
    const int kNumFields = 3;
    const size_t kStringSize = 64;
    const char* const kIonIommuPath = "/sys/kernel/debug/ion/iommu";

    FILE* iommu = fopen(kIonIommuPath, "r");
    if (!iommu) {
      return;
    }

    AutoFile iommuGuard(iommu);

    const size_t kBufferLen = 256;
    char buffer[kBufferLen];
    char client[kStringSize];
    uint32_t pid;
    uint64_t size;

    // Ignore the header line.
    Unused << fgets(buffer, kBufferLen, iommu);

    // Ignore the separator line.
    Unused << fgets(buffer, kBufferLen, iommu);

    const char* const kSep = "----";
    const size_t kSepLen = 4;

    // Read non-orphaned entries.
    while (fgets(buffer, kBufferLen, iommu) &&
           strncmp(kSep, buffer, kSepLen) != 0) {
      if (sscanf(buffer, kFormatString, client, &pid, &size) == kNumFields) {
        nsPrintfCString entryPath("ion-memory/%s (pid=%d)", client, pid);
        REPORT(entryPath, UNITS_BYTES, size,
               NS_LITERAL_CSTRING("An ION kernel memory allocation."));
      }
    }

    // Ignore the orphaned header.
    Unused << fgets(buffer, kBufferLen, iommu);

    // Read orphaned entries.
    while (fgets(buffer, kBufferLen, iommu) &&
           strncmp(kSep, buffer, kSepLen) != 0) {
      if (sscanf(buffer, kFormatString, client, &pid, &size) == kNumFields) {
        nsPrintfCString entryPath("ion-memory/%s (pid=%d)", client, pid);
        REPORT(entryPath, UNITS_BYTES, size,
               NS_LITERAL_CSTRING("An ION kernel memory allocation."));
      }
    }

    // Ignore the rest of the file.
  }

  uint64_t
  ReadSizeFromFile(const char* aFilename)
  {
    FILE* sizeFile = fopen(aFilename, "r");
    if (NS_WARN_IF(!sizeFile)) {
      return 0;
    }

    uint64_t size = 0;
    Unused << fscanf(sizeFile, "%" SCNu64, &size);
    fclose(sizeFile);

    return size;
  }

  void
  CollectZramReports(nsIHandleReportCallback* aHandleReport,
                     nsISupports* aData)
  {
    // zram usage stats files can be found under:
    //  /sys/block/zram<id>
    //  |--> disksize        - Maximum amount of uncompressed data that can be
    //                         stored on the disk (bytes)
    //  |--> orig_data_size  - Uncompressed size of data in the disk (bytes)
    //  |--> compr_data_size - Compressed size of the data in the disk (bytes)
    //  |--> num_reads       - Number of attempted reads to the disk (count)
    //  |--> num_writes      - Number of attempted writes to the disk (count)
    //
    // Each file contains a single integer value in decimal form.

    DIR* d = opendir("/sys/block");
    if (!d) {
      return;
    }

    struct dirent* ent;
    while ((ent = readdir(d))) {
      const char* name = ent->d_name;

      // Skip non-zram entries.
      if (strncmp("zram", name, 4) != 0) {
        continue;
      }

      // Report disk size statistics.
      nsPrintfCString diskSizeFile("/sys/block/%s/disksize", name);
      nsPrintfCString origSizeFile("/sys/block/%s/orig_data_size", name);

      uint64_t diskSize = ReadSizeFromFile(diskSizeFile.get());
      uint64_t origSize = ReadSizeFromFile(origSizeFile.get());
      uint64_t unusedSize = diskSize - origSize;

      nsPrintfCString diskUsedPath("zram-disksize/%s/used", name);
      nsPrintfCString diskUsedDesc(
        "The uncompressed size of data stored in \"%s.\" "
        "This excludes zero-filled pages since "
        "no memory is allocated for them.", name);
      REPORT(diskUsedPath, UNITS_BYTES, origSize, diskUsedDesc);

      nsPrintfCString diskUnusedPath("zram-disksize/%s/unused", name);
      nsPrintfCString diskUnusedDesc(
        "The amount of uncompressed data that can still be "
        "be stored in \"%s\"", name);
      REPORT(diskUnusedPath, UNITS_BYTES, unusedSize, diskUnusedDesc);

      // Report disk accesses.
      nsPrintfCString readsFile("/sys/block/%s/num_reads", name);
      nsPrintfCString writesFile("/sys/block/%s/num_writes", name);

      uint64_t reads = ReadSizeFromFile(readsFile.get());
      uint64_t writes = ReadSizeFromFile(writesFile.get());

      nsPrintfCString readsDesc(
        "The number of reads (failed or successful) done on "
        "\"%s\"", name);
      nsPrintfCString readsPath("zram-accesses/%s/reads", name);
      REPORT(readsPath, UNITS_COUNT_CUMULATIVE, reads, readsDesc);

      nsPrintfCString writesDesc(
        "The number of writes (failed or successful) done "
        "on \"%s\"", name);
      nsPrintfCString writesPath("zram-accesses/%s/writes", name);
      REPORT(writesPath, UNITS_COUNT_CUMULATIVE, writes, writesDesc);

      // Report compressed data size.
      nsPrintfCString comprSizeFile("/sys/block/%s/compr_data_size", name);
      uint64_t comprSize = ReadSizeFromFile(comprSizeFile.get());

      nsPrintfCString comprSizeDesc(
        "The compressed size of data stored in \"%s\"",
        name);
      nsPrintfCString comprSizePath("zram-compr-data-size/%s", name);
      REPORT(comprSizePath, UNITS_BYTES, comprSize, comprSizeDesc);
    }

    closedir(d);
  }

  void
  CollectOpenFileReports(nsIHandleReportCallback* aHandleReport,
                         nsISupports* aData,
                         const nsACString& aProcPath,
                         const nsACString& aProcessName)
  {
    // All file descriptors opened by a process are listed under
    // /proc/<pid>/fd/<numerical_fd>. Each entry is a symlink that points to the
    // path that was opened. This can be an actual file, a socket, a pipe, an
    // anon_inode, or possibly an uncategorized device.
    const char kFilePrefix[] = "/";
    const char kSocketPrefix[] = "socket:";
    const char kPipePrefix[] = "pipe:";
    const char kAnonInodePrefix[] = "anon_inode:";

    const nsCString procPath(aProcPath);
    DIR* d = opendir(procPath.get());
    if (!d) {
      return;
    }

    char linkPath[PATH_MAX + 1];
    struct dirent* ent;
    while ((ent = readdir(d))) {
      const char* fd = ent->d_name;

      // Skip "." and ".." (and any other dotfiles).
      if (fd[0] == '.') {
        continue;
      }

      nsPrintfCString fullPath("%s/%s", procPath.get(), fd);
      ssize_t linkPathSize = readlink(fullPath.get(), linkPath, PATH_MAX);
      if (linkPathSize > 0) {
        linkPath[linkPathSize] = '\0';

#define CHECK_PREFIX(prefix) \
  (strncmp(linkPath, prefix, sizeof(prefix) - 1) == 0)

        const char* category = nullptr;
        const char* descriptionPrefix = nullptr;

        if (CHECK_PREFIX(kFilePrefix)) {
          category = "files"; // No trailing slash, the file path will have one
          descriptionPrefix = "An open";
        } else if (CHECK_PREFIX(kSocketPrefix)) {
          category = "sockets/";
          descriptionPrefix = "A socket";
        } else if (CHECK_PREFIX(kPipePrefix)) {
          category = "pipes/";
          descriptionPrefix = "A pipe";
        } else if (CHECK_PREFIX(kAnonInodePrefix)) {
          category = "anon_inodes/";
          descriptionPrefix = "An anon_inode";
        } else {
          category = "";
          descriptionPrefix = "An uncategorized";
        }

#undef CHECK_PREFIX

        const nsCString processName(aProcessName);
        nsPrintfCString entryPath("open-fds/%s/%s%s/%s",
                                  processName.get(), category, linkPath, fd);
        nsPrintfCString entryDescription("%s file descriptor opened by the process",
                                         descriptionPrefix);
        REPORT(entryPath, UNITS_COUNT, 1, entryDescription);
      }
    }

    closedir(d);
  }

  void
  CollectKgslReports(nsIHandleReportCallback* aHandleReport,
                     nsISupports* aData)
  {
    // Each process that uses kgsl memory will have an entry under
    // /sys/kernel/debug/kgsl/proc/<pid>/mem. This file format includes a
    // header and then entries with types as follows:
    //   gpuaddr useraddr size id  flags type usage sglen
    //   hexaddr hexaddr  int  int str   str  str   int
    // We care primarily about the usage and size.

    // For simplicity numbers will be uint64_t, strings 63 chars max.
    const char* const kScanFormat =
      "%" SCNx64 " %" SCNx64 " %" SCNu64 " %" SCNu64
      " %63s %63s %63s %" SCNu64;
    const int kNumFields = 8;
    const size_t kStringSize = 64;

    DIR* d = opendir("/sys/kernel/debug/kgsl/proc/");
    if (!d) {
      return;
    }

    AutoDir dirGuard(d);

    struct dirent* ent;
    while ((ent = readdir(d))) {
      const char* pid = ent->d_name;

      // Skip "." and ".." (and any other dotfiles).
      if (pid[0] == '.') {
        continue;
      }

      nsPrintfCString memPath("/sys/kernel/debug/kgsl/proc/%s/mem", pid);
      FILE* memFile = fopen(memPath.get(), "r");
      if (NS_WARN_IF(!memFile)) {
        continue;
      }

      AutoFile fileGuard(memFile);

      // Attempt to map the pid to a more useful name.
      nsAutoCString procName;
      LinuxUtils::GetThreadName(atoi(pid), procName);

      if (procName.IsEmpty()) {
        procName.AppendLiteral("pid=");
        procName.Append(pid);
      } else {
        procName.AppendLiteral(" (pid=");
        procName.Append(pid);
        procName.Append(")");
      }

      uint64_t gpuaddr, useraddr, size, id, sglen;
      char flags[kStringSize];
      char type[kStringSize];
      char usage[kStringSize];

      // Bypass the header line.
      char buff[1024];
      Unused << fgets(buff, 1024, memFile);

      while (fscanf(memFile, kScanFormat, &gpuaddr, &useraddr, &size, &id,
                    flags, type, usage, &sglen) == kNumFields) {
        nsPrintfCString entryPath("kgsl-memory/%s/%s", procName.get(), usage);
        REPORT(entryPath, UNITS_BYTES, size,
               NS_LITERAL_CSTRING("A kgsl graphics memory allocation."));
      }
    }
  }
};

NS_IMPL_ISUPPORTS(SystemReporter, nsIMemoryReporter)

void
Init()
{
  RegisterStrongMemoryReporter(new SystemReporter());
}

} // namespace SystemMemoryReporter
} // namespace mozilla