Use sysctlbyname() to get kernel page size.

base/trace_event/process_memory_dump.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/trace_event/process_memory_dump.h"
 
 #include <errno.h>
 #include <vector>
 
 #include "base/process/process_metrics.h"
 #include "base/trace_event/process_memory_totals.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "build/build_config.h"
 
+#if defined(OS_IOS)
+#include <sys/sysctl.h>
+#endif
+
 #if defined(OS_POSIX)
 #include <sys/mman.h>
 #endif
 
 #if defined(OS_WIN)
 #include <Psapi.h>
 #endif
 
 namespace base {
 namespace trace_event {
@@ skipping 10 matching lines @@
 #if defined(COUNT_RESIDENT_BYTES_SUPPORTED)
 size_t GetSystemPageCount(size_t mapped_size, size_t page_size) {
   return (mapped_size + page_size - 1) / page_size;
 }
 #endif
 
 }  // namespace
 
 #if defined(COUNT_RESIDENT_BYTES_SUPPORTED)
 // static
+size_t ProcessMemoryDump::GetSystemPageSize() {
+#if defined(OS_IOS)
+  // On iOS, getpagesize() returns the user page sizes, but for allocating
+  // arrays for mincore(), kernel page sizes is needed. sysctlbyname() should
+  // be used for this. Refer to crbug.com/542671 and Apple rdar://23651782
+  int pagesize;
+  size_t pagesize_len;
+  int status = sysctlbyname("vm.pagesize", NULL, &pagesize_len, NULL, 0);

[Primiano Tucci (use gerrit), 2016/03/15 15:50:48]

nit: s/NULL/nullptr
same below

[pkl (ping after 24h if needed), 2016/03/16 14:24:21]

Done.

+  if (!status && pagesize_len == sizeof(pagesize)) {
+    if (sysctlbyname("vm.pagesize", &pagesize, &pagesize_len, NULL, 0) == 0)

[Primiano Tucci (use gerrit), 2016/03/15 15:50:48]

nit: consistency, either you check the syscall ret value with ! or == 0, both
work for me as long as you are consistent within 3 lines :)

[pkl (ping after 24h if needed), 2016/03/16 14:24:21]

Yep, you're right. Thank you!

+      return pagesize;
+  }
+  LOG(ERROR) << "sysctlbyname(\"vm.pagesize\") failed.";
+  // Falls back to getpagesize() although it may be wrong in certain cases.
+#endif  // defined(OS_IOS)
+  return base::GetPageSize();
+}
+
+// static
 size_t ProcessMemoryDump::CountResidentBytes(void* start_address,
                                              size_t mapped_size) {
-  const size_t page_size = GetPageSize();
+  const size_t page_size = GetSystemPageSize();
   const uintptr_t start_pointer = reinterpret_cast<uintptr_t>(start_address);
   DCHECK_EQ(0u, start_pointer % page_size);
 
   size_t offset = 0;
   size_t total_resident_size = 0;
   bool failure = false;
 
   // An array as large as number of pages in memory segment needs to be passed
   // to the query function. To avoid allocating a large array, the given block
   // of memory is split into chunks of size |kMaxChunkSize|.
@@ skipping 230 matching lines @@
 
 void ProcessMemoryDump::AddSuballocation(const MemoryAllocatorDumpGuid& source,
                                          const std::string& target_node_name) {
   std::string child_mad_name = target_node_name + "/__" + source.ToString();
   MemoryAllocatorDump* target_child_mad = CreateAllocatorDump(child_mad_name);
   AddOwnershipEdge(source, target_child_mad->guid());
 }
 
 }  // namespace trace_event
 }  // namespace base