Handle EAGAIN error for the mincore syscall used

content/common/host_discardable_shared_memory_manager.cc

 // Copyright 2014 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 "content/common/host_discardable_shared_memory_manager.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
@@ skipping 192 matching lines @@
               child_process_id);
       base::trace_event::MemoryAllocatorDumpGuid shared_segment_guid =
           DiscardableSharedMemoryHeap::GetSegmentGUIDForTracing(
               child_tracing_process_id, segment_id);
       pmd->CreateSharedGlobalAllocatorDump(shared_segment_guid);
       pmd->AddOwnershipEdge(dump->guid(), shared_segment_guid);
 
 #if defined(COUNT_RESIDENT_BYTES_SUPPORTED)
       if (args.level_of_detail ==
           base::trace_event::MemoryDumpLevelOfDetail::DETAILED) {
-        size_t resident_size =
-            base::trace_event::ProcessMemoryDump::CountResidentBytes(
-                segment->memory()->memory(), segment->memory()->mapped_size());
+        size_t resident_size;
 
         // This is added to the global dump since it has to be attributed to
         // both the allocator dumps involved.
-        pmd->GetSharedGlobalAllocatorDump(shared_segment_guid)
-            ->AddScalar("resident_size",
-                        base::trace_event::MemoryAllocatorDump::kUnitsBytes,
-                        static_cast<uint64>(resident_size));
+        if (base::trace_event::ProcessMemoryDump::CountResidentBytes(
+                segment->memory()->memory(), segment->memory()->mapped_size(),
+                &resident_size)) {
+          pmd->GetSharedGlobalAllocatorDump(shared_segment_guid)
+              ->AddScalar("resident_size",
+                          base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                          static_cast<uint64>(resident_size));
+        } else {
+          NOTREACHED();

[reveman, 2015/10/14 12:31:29]

please

bool rv = base::trace_event::ProcessMemoryDump::CountResidentBytes(...
DCHECK(rv);

instead.

but if we keep having a DCHECK/NOTREACHED here, how is allowing
CountResidentBytes to fail fix anything?

[ssid, 2015/10/14 12:44:29]

In general it should not fail. What I want is in release builds it should show
right values. But in debug build it is good to see if this is failing and not
hide it in the tests running.

[reveman, 2015/10/14 13:03:53]

ok, sounds good. I don't like when NOTREACHED/DCHECKs are part of the structure
of the code. It should be possible to removed the DCHECK without making any
other changes and the code should still work and not look weird.

Can we do the following instead and dump resident_size=0 when it fails?

size_t resident_size = 0;
bool rv = base::trace_event::ProcessMemoryDump::CountResidentBytes(...
DCHECK(rv);
pmd->GetSharedGlobalAllocatorDump(shared_segment_guid)
              ->AddScalar(...

[ssid, 2015/10/14 13:35:55]

Done.

+        }
       }
 #endif  // defined(COUNT_RESIDENT_BYTES_SUPPORTED)
     }
   }
   return true;
 }
 
 void HostDiscardableSharedMemoryManager::
     AllocateLockedDiscardableSharedMemoryForChild(
         base::ProcessHandle process_handle,
@@ skipping 259 matching lines @@
 
   enforce_memory_policy_pending_ = true;
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&HostDiscardableSharedMemoryManager::EnforceMemoryPolicy,
                  weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs));
 }
 
 }  // namespace content