MEM_RESERVE regions are not accessible by ReadProcessMemory()

util/win/process_info.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 89 matching lines @@
     PLOG(ERROR) << "ReadProcessMemory " << __FUNCSIG__;
     return false;
   }
   if (bytes_read != sizeof(T)) {
     LOG(ERROR) << "ReadProcessMemory " << __FUNCSIG__ << " incorrect size";
     return false;
   }
   return true;
 }
 
-bool RegionIsInaccessible(const ProcessInfo::MemoryInfo& memory_info) {
-  return memory_info.state == MEM_FREE ||
-         (memory_info.state == MEM_COMMIT &&
-          ((memory_info.protect & PAGE_NOACCESS) ||
-           (memory_info.protect & PAGE_GUARD)));
+bool RegionIsAccessible(const ProcessInfo::MemoryInfo& memory_info) {
+  return memory_info.state == MEM_COMMIT &&
+         (memory_info.protect & PAGE_NOACCESS) == 0 &&
+         (memory_info.protect & PAGE_GUARD) == 0;
 }
 
 }  // namespace
 
 template <class Traits>
 bool GetProcessBasicInformation(HANDLE process,
                                 bool is_wow64,
                                 ProcessInfo* process_info,
                                 WinVMAddress* peb_address,
                                 WinVMSize* peb_size) {
@@ skipping 336 matching lines @@
       (original_front_base_address + front.region_size) - front.base_address;
 
   ProcessInfo::MemoryInfo& back = overlapping.back();
   WinVMAddress back_end = back.base_address + back.region_size;
   back.region_size = std::min(range.end(), back_end) - back.base_address;
 
   // Discard all non-accessible.
   overlapping.erase(std::remove_if(overlapping.begin(),
                                    overlapping.end(),
                                    [](const ProcessInfo::MemoryInfo& mi) {
-                                     return RegionIsInaccessible(mi);
+                                     return !RegionIsAccessible(mi);
                                    }),
                     overlapping.end());
   if (overlapping.empty())
     return std::vector<Range>();
 
   // Convert to return type.
   std::vector<Range> as_ranges;
   for (const auto& mi : overlapping) {
     as_ranges.push_back(Range(mi.base_address, mi.region_size));
     DCHECK(as_ranges.back().IsValid());
   }
 
   // Coalesce remaining regions.
   std::vector<Range> result;
   result.push_back(as_ranges[0]);
   for (size_t i = 1; i < as_ranges.size(); ++i) {
     if (result.back().end() == as_ranges[i].base()) {
       result.back().SetRange(result.back().base(),
                              result.back().size() + as_ranges[i].size());
     } else {
       result.push_back(as_ranges[i]);
     }
     DCHECK(result.back().IsValid());
   }
 
   return result;
 }
 
 }  // namespace crashpad