Use the new ScopedMachVM class and the MACH_LOG family of logging macros

base/process/memory_mac.mm

 // Copyright (c) 2013 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/process/memory.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 #include <errno.h>
 #include <mach/mach.h>
 #include <mach/mach_vm.h>
 #include <malloc/malloc.h>
 #import <objc/runtime.h>
 
 #include <new>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
+#include "base/mac/mach_logging.h"
 #include "base/scoped_clear_errno.h"
 #include "third_party/apple_apsl/CFBase.h"
 #include "third_party/apple_apsl/malloc.h"
 
 #if ARCH_CPU_32_BITS
 #include <dlfcn.h>
 #include <mach-o/nlist.h>
 
 #include "base/threading/thread_local.h"
 #include "third_party/mach_override/mach_override.h"
@@ skipping 186 matching lines @@
   struct vm_region_basic_info_64 info;
   mach_msg_type_number_t count = VM_REGION_BASIC_INFO_COUNT_64;
   kern_return_t result =
       mach_vm_region(mach_task_self(),
                      reprotection_start,
                      reprotection_length,
                      VM_REGION_BASIC_INFO_64,
                      reinterpret_cast<vm_region_info_t>(&info),
                      &count,
                      &unused);
-  CHECK(result == KERN_SUCCESS);
+  MACH_CHECK(result == KERN_SUCCESS, result) << "mach_vm_region";
 
-  result = mach_port_deallocate(mach_task_self(), unused);
-  CHECK(result == KERN_SUCCESS);
+  mach_port_deallocate(mach_task_self(), unused);

[Robert Sesek, 2014/05/09 20:40:01]

Technically this _can_ fail. But it's not likely.

[Mark Mentovai, 2014/05/09 21:09:35]

rsesek wrote:
Oh, maybe I should have said something here? The kernel doesn’t actually give
you back a port object when you call mach_vm_region. It always gives you a null
port. The deallocate is there to make the code not look like a leaky hog, but
it’s really a no-op.

 
   // Does the region fully enclose the zone pointers? Possibly unwarranted
   // simplification used: using the size of a full version 8 malloc zone rather
   // than the actual smaller size if the passed-in zone is not version 8.
   CHECK(*reprotection_start <=
             reinterpret_cast<mach_vm_address_t>(default_zone));
   mach_vm_size_t zone_offset = reinterpret_cast<mach_vm_size_t>(default_zone) -
       reinterpret_cast<mach_vm_size_t>(*reprotection_start);
   CHECK(zone_offset + sizeof(ChromeMallocZone) <= *reprotection_length);
 
   if (info.protection & VM_PROT_WRITE) {
     // No change needed; the zone is already writable.
     *reprotection_start = 0;
     *reprotection_length = 0;
     *reprotection_value = VM_PROT_NONE;
   } else {
     *reprotection_value = info.protection;
     result = mach_vm_protect(mach_task_self(),
                              *reprotection_start,
                              *reprotection_length,
                              false,
                              info.protection | VM_PROT_WRITE);
-    CHECK(result == KERN_SUCCESS);
+    MACH_CHECK(result == KERN_SUCCESS, result) << "mach_vm_protect";
   }
 }
 
 // === C malloc/calloc/valloc/realloc/posix_memalign ===
 
 typedef void* (*malloc_type)(struct _malloc_zone_t* zone,
                              size_t size);
 typedef void* (*calloc_type)(struct _malloc_zone_t* zone,
                              size_t num_items,
                              size_t size);
@@ skipping 377 matching lines @@
   }
 
   // Restore protection if it was active.
 
   if (default_reprotection_start) {
     kern_return_t result = mach_vm_protect(mach_task_self(),
                                            default_reprotection_start,
                                            default_reprotection_length,
                                            false,
                                            default_reprotection_value);
-    CHECK(result == KERN_SUCCESS);
+    MACH_CHECK(result == KERN_SUCCESS, result) << "mach_vm_protect";
   }
 
   if (purgeable_reprotection_start) {
     kern_return_t result = mach_vm_protect(mach_task_self(),
                                            purgeable_reprotection_start,
                                            purgeable_reprotection_length,
                                            false,
                                            purgeable_reprotection_value);
-    CHECK(result == KERN_SUCCESS);
+    MACH_CHECK(result == KERN_SUCCESS, result) << "mach_vm_protect";
   }
 #endif
 
   // === C malloc_zone_batch_malloc ===
 
   // batch_malloc is omitted because the default malloc zone's implementation
   // only supports batch_malloc for "tiny" allocations from the free list. It
   // will fail for allocations larger than "tiny", and will only allocate as
   // many blocks as it's able to from the free list. These factors mean that it
   // can return less than the requested memory even in a non-out-of-memory
@@ skipping 68 matching lines @@
                                             @selector(allocWithZone:));
   g_old_allocWithZone = reinterpret_cast<allocWithZone_t>(
       method_getImplementation(orig_method));
   CHECK(g_old_allocWithZone)
       << "Failed to get allocWithZone allocation function.";
   method_setImplementation(orig_method,
                            reinterpret_cast<IMP>(oom_killer_allocWithZone));
 }
 
 }  // namespace base