The Tor Browser: xpcom/base/SystemMemoryReporter.cpp@b8a032363ba2 (annotated)

xpcom/base/SystemMemoryReporter.cpp@b8a032363ba2 (annotated)

xpcom/base/SystemMemoryReporter.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- 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/Preferences.h"
 #include "mozilla/unused.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
 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* s)
 {
   MOZ_ASSERT(*s);   // shouldn't see empty strings
   while (*s) {
     if (!isdigit(*s)) {
       return false;
     }
     s++;
   }
   return true;
 }
 static bool
 IsAnonymous(const nsACString& aName)
 {
   // Recent kernels (e.g. 3.5) have multiple [stack:nnnn] entries, where |nnnn|
   // is a thread ID.  However, [stack:nnnn] entries count both stack memory
   // *and* anonymous memory because the kernel only knows about the start of
   // each thread stack, not its end.  So we treat such entries as anonymous
   // memory instead of stack.  This is consistent with older kernels that don't
   // even show [stack:nnnn] entries.
   return aName.IsEmpty() ||
          StringBeginsWith(aName, NS_LITERAL_CSTRING("[stack:"));
 }
 class SystemReporter MOZ_FINAL : public nsIMemoryReporter
 {
 public:
   NS_DECL_THREADSAFE_ISUPPORTS
 #define REPORT_WITH_CLEANUP(_path, _units, _amount, _desc, _cleanup)          \
   do {                                                                        \
     size_t amount = _amount;  /* evaluate _amount only once */                \
     if (amount > 0) {                                                         \
       nsresult rv;                                                            \
       rv = aHandleReport->Callback(NS_LITERAL_CSTRING("System"), _path,       \
                                    KIND_NONHEAP, _units, amount, _desc,       \
                                    aData);                                    \
       if (NS_WARN_IF(NS_FAILED(rv))) {                                        \
         _cleanup;                                                             \
         return rv;                                                            \
       }                                                                       \
     }                                                                         \
   } while (0)
 #define REPORT(_path, _amount, _desc) \
     REPORT_WITH_CLEANUP(_path, UNITS_BYTES, _amount, _desc, (void)0)
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData)
   {
     if (!Preferences::GetBool("memory.system_memory_reporter")) {
       return NS_OK;
     }
     // Read relevant fields from /proc/meminfo.
     int64_t memTotal = 0, memFree = 0;
     nsresult rv = ReadMemInfo(&memTotal, &memFree);
     // Collect per-process reports from /proc/<pid>/smaps.
     int64_t totalPss = 0;
     rv = CollectProcessReports(aHandleReport, aData, &totalPss);
     NS_ENSURE_SUCCESS(rv, rv);
     // Report the non-process numbers.
     int64_t other = memTotal - memFree - totalPss;
     REPORT(NS_LITERAL_CSTRING("mem/other"), 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"), memFree, NS_LITERAL_CSTRING(
 "Memory which is free and not being used for any purpose."));
     // Report reserved memory not included in memTotal.
     rv = CollectPmemReports(aHandleReport, aData);
     NS_ENSURE_SUCCESS(rv, rv);
     // Report zram usage statistics.
     rv = CollectZramReports(aHandleReport, aData);
     NS_ENSURE_SUCCESS(rv, rv);
     return rv;
   }
 private:
   // Keep this in sync with SystemReporter::kindPathSuffixes!
   enum ProcessSizeKind {
     AnonymousOutsideBrk  = 0,
     AnonymousBrkHeap     = 1,
     SharedLibrariesRX    = 2,
     SharedLibrariesRW    = 3,
     SharedLibrariesR     = 4,
     SharedLibrariesOther = 5,
     OtherFiles           = 6,
     MainThreadStack      = 7,
     Vdso                 = 8,
     ProcessSizeKindLimit = 9  // must be last
   };
   static const char* kindPathSuffixes[ProcessSizeKindLimit];
   // These are the cross-cutting measurements across all processes.
   struct ProcessSizes
   {
     ProcessSizes() { memset(this, 0, sizeof(*this)); }
     size_t mSizes[ProcessSizeKindLimit];
   };
   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.Append(", ");
           }
           fclose(f);
         }
         processName.Append("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;
         }
         while (true) {
           nsresult rv = ParseMapping(f, processName, aHandleReport, aData,
                                      &processSizes, aTotalPss);
           if (NS_FAILED(rv))
             break;
         }
         fclose(f);
       }
     }
     closedir(d);
     // Report the "processes/" tree.
     for (size_t i = 0; i < ProcessSizeKindLimit; i++) {
       nsAutoCString path("processes/");
       path.Append(kindPathSuffixes[i]);
       nsAutoCString desc("This is the sum of all processes' '");
       desc.Append(kindPathSuffixes[i]);
       desc.Append("' numbers.");
       REPORT(path, processSizes.mSizes[i], desc);
     }
     return NS_OK;
   }
   nsresult ParseMapping(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]
     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 path[1025];
     // A path might not be present on this line; set it to the empty string.
     path[0] = '\0';
     // This is a bit tricky.  Whitespace in a scanf pattern matches *any*
     // whitespace, including newlines.  We want this pattern to match a line
     // with or without a path, but we don't want to look to a new line for the
     // path.  Thus we have %u%1024[^\n] at the end of the pattern.  This will
     // capture into the path some leading whitespace, which we'll later trim
     // off.
     int n = fscanf(aFile,
                    "%llx-%llx %4s %llx "
                    "%16[0-9a-fA-F]:%16[0-9a-fA-F] %u%1024[^\n]",
                    &addrStart, &addrEnd, perms, &offset, devMajor,
                    devMinor, &inode, path);
     // Eat up any whitespace at the end of this line, including the newline.
     unused << fscanf(aFile, " ");
     // We might or might not have a path, but the rest of the arguments should
     // be there.
     if (n != argCount && n != argCount - 1) {
       return NS_ERROR_FAILURE;
     }
     nsAutoCString name, description;
     ProcessSizeKind kind;
     GetReporterNameAndDescription(path, perms, name, description, &kind);
     while (true) {
       size_t pss = 0;
       nsresult rv = ParseMapBody(aFile, aProcessName, name, description,
                                  aHandleReport, aData, &pss);
       if (NS_FAILED(rv))
         break;
       // Increment the appropriate aProcessSizes values, and the total.
       aProcessSizes->mSizes[kind] += pss;
       *aTotalPss += pss;
     }
     return NS_OK;
   }
   void GetReporterNameAndDescription(const char* aPath,
                                      const char* aPerms,
                                      nsACString& aName,
                                      nsACString& aDesc,
                                      ProcessSizeKind* aProcessSizeKind)
   {
     aName.Truncate();
     aDesc.Truncate();
     // If aPath points to a file, we have its absolute path, plus some
     // whitespace.  Truncate this to its basename, and put the absolute path in
     // the description.
     nsAutoCString absPath;
     absPath.Append(aPath);
     absPath.StripChars(" ");
     nsAutoCString basename;
     GetBasename(absPath, basename);
     if (basename.EqualsLiteral("[heap]")) {
       aName.Append("anonymous/brk-heap");
       aDesc.Append("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.");
       *aProcessSizeKind = AnonymousBrkHeap;
     } else if (basename.EqualsLiteral("[stack]")) {
       aName.Append("main-thread-stack");
       aDesc.Append("The stack size of the process's main thread.  This "
                    "corresponds to '[stack]' in /proc/<pid>/smaps.");
       *aProcessSizeKind = MainThreadStack;
     } else if (basename.EqualsLiteral("[vdso]")) {
       aName.Append("vdso");
       aDesc.Append("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.");
       *aProcessSizeKind = Vdso;
     } else if (!IsAnonymous(basename)) {
       nsAutoCString dirname;
       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.Append("shared-libraries/");
         if (strncmp(aPerms, "r-x", 3) == 0) {
           *aProcessSizeKind = SharedLibrariesRX;
         } else if (strncmp(aPerms, "rw-", 3) == 0) {
           *aProcessSizeKind = SharedLibrariesRW;
         } else if (strncmp(aPerms, "r--", 3) == 0) {
           *aProcessSizeKind = SharedLibrariesR;
         } else {
           *aProcessSizeKind = SharedLibrariesOther;
         }
       } else {
         aName.Append("other-files/");
         if (EndsWithLiteral(basename, ".xpi")) {
           aName.Append("extensions/");
         } else if (dirname.Find("/fontconfig") != -1) {
           aName.Append("fontconfig/");
         }
         *aProcessSizeKind = OtherFiles;
       }
       aName.Append(basename);
       aDesc.Append(absPath);
     } else {
       aName.Append("anonymous/outside-brk");
       aDesc.Append("Memory in anonymous mappings outside the boundaries "
                    "defined by brk() / sbrk().");
       *aProcessSizeKind = AnonymousOutsideBrk;
     }
     aName.Append("/[");
     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.Append(" [");
     aDesc.Append(aPerms);
     aDesc.Append("]");
   }
   nsresult ParseMapBody(
     FILE* aFile,
     const nsACString& aProcessName,
     const nsACString& aName,
     const nsACString& aDescription,
     nsIHandleReportCallback* aHandleReport,
     nsISupports* aData,
     size_t* aPss)
   {
     // Most of the lines in the body look like this:
     //
     // Size:                132 kB
     // Rss:                  20 kB
     // Pss:                  20 kB
     //
     // We're only interested in Pss.  In newer kernels, the last line in the
     // body has a different form:
     //
     // VmFlags: rd wr mr mw me dw ac
     //
     // The strings after "VmFlags: " vary.
     char desc[1025];
     int64_t sizeKB;
     int n = fscanf(aFile, "%1024[a-zA-Z_]: %" SCNd64 " kB\n", desc, &sizeKB);
     if (n == EOF || n == 0) {
       return NS_ERROR_FAILURE;
     } else if (n == 1 && strcmp(desc, "VmFlags") == 0) {
       // This is the "VmFlags:" line.  Chew up the rest of it.
       fscanf(aFile, "%*1024[a-z ]\n");
       return NS_ERROR_FAILURE;
     }
     // Only report "Pss" values.
     if (strcmp(desc, "Pss") == 0) {
       *aPss = sizeKB * 1024;
       // Don't report zero values.
       if (*aPss == 0) {
         return NS_OK;
       }
       nsAutoCString path("mem/processes/");
       path.Append(aProcessName);
       path.Append("/");
       path.Append(aName);
       REPORT(path, *aPss, aDescription);
     } else {
       *aPss = 0;
     }
     return NS_OK;
   }
   nsresult 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) {
       if (NS_WARN_IF(errno != ENOENT)) {
         return NS_ERROR_FAILURE;
       }
       // If ENOENT, system doesn't use pmem.
       return NS_OK;
     }
     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);
       if (NS_WARN_IF(scanned != 1)) {
         continue;
       }
       fclose(sizeFile);
       // 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_WITH_CLEANUP(path, UNITS_BYTES, mapLen, desc,
                                 (fclose(regionsFile), closedir(d)));
             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_WITH_CLEANUP(path, UNITS_BYTES, freeSize, desc, closedir(d));
     }
     closedir(d);
     return NS_OK;
   }
   uint64_t
   ReadSizeFromFile(const char* aFilename)
   {
       FILE* sizeFile = fopen(aFilename, "r");
       if (NS_WARN_IF(!sizeFile)) {
         return 0;
       }
       uint64_t size = 0;
       fscanf(sizeFile, "%" SCNu64, &size);
       fclose(sizeFile);
       return size;
   }
   nsresult
   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) {
       if (NS_WARN_IF(errno != ENOENT)) {
         return NS_ERROR_FAILURE;
       }
       return NS_OK;
     }
     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_WITH_CLEANUP(diskUsedPath, UNITS_BYTES, origSize,
                           diskUsedDesc, closedir(d));
       nsPrintfCString diskUnusedPath("zram-disksize/%s/unused", name);
       nsPrintfCString diskUnusedDesc(
                            "The amount of uncompressed data that can still be "
                            "be stored in \"%s\"", name);
       REPORT_WITH_CLEANUP(diskUnusedPath, UNITS_BYTES, unusedSize,
                           diskUnusedDesc, closedir(d));
       // 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_WITH_CLEANUP(readsPath, UNITS_COUNT_CUMULATIVE, reads,
                           readsDesc, closedir(d));
       nsPrintfCString writesDesc(
                            "The number of writes (failed or successful) done "
                            "on \"%s\"", name);
       nsPrintfCString writesPath("zram-accesses/%s/writes", name);
       REPORT_WITH_CLEANUP(writesPath, UNITS_COUNT_CUMULATIVE, writes,
                           writesDesc, closedir(d));
       // 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_WITH_CLEANUP(comprSizePath, UNITS_BYTES, comprSize,
                           comprSizeDesc, closedir(d));
     }
     closedir(d);
     return NS_OK;
   }
 #undef REPORT
 };
 NS_IMPL_ISUPPORTS(SystemReporter, nsIMemoryReporter)
 // Keep this in sync with SystemReporter::ProcessSizeKind!
 const char* SystemReporter::kindPathSuffixes[] = {
     "anonymous/outside-brk",
     "anonymous/brk-heap",
     "shared-libraries/read-executable",
     "shared-libraries/read-write",
     "shared-libraries/read-only",
     "shared-libraries/other",
     "other-files",
     "main-thread-stack",
     "vdso"
 };
 void Init()
 {
   RegisterStrongMemoryReporter(new SystemReporter());
 }
 } // namespace SystemMemoryReporter
 } // namespace mozilla

The Tor Browser / annotate

xpcom/base/SystemMemoryReporter.cpp@b8a032363ba2 (annotated)

xpcom/base/SystemMemoryReporter.cpp