[SyzyAsan] Disable registry filter for sandboxed processes.

syzygy/agent/asan/heap_managers/block_heap_manager.cc

 // Copyright 2014 Google Inc. 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 64 matching lines @@
       stack_cache_(stack_cache),
       memory_notifier_(memory_notifier),
       initialized_(false),
       process_heap_(nullptr),
       process_heap_underlying_heap_(nullptr),
       process_heap_id_(0),
       zebra_block_heap_(nullptr),
       zebra_block_heap_id_(0),
       large_block_heap_id_(0),
       locked_heaps_(nullptr),
-      enable_page_protections_(true),
-      corrupt_block_registry_cache_(L"SyzyAsanCorruptBlocks") {
+      enable_page_protections_(true) {
   DCHECK_NE(static_cast<Shadow*>(nullptr), shadow);
   DCHECK_NE(static_cast<StackCaptureCache*>(nullptr), stack_cache);
   DCHECK_NE(static_cast<MemoryNotifierInterface*>(nullptr), memory_notifier);
   SetDefaultAsanParameters(&parameters_);
 
   // Initialize the allocation-filter flag (using Thread Local Storage).
   allocation_filter_flag_tls_ = ::TlsAlloc();
   CHECK_NE(TLS_OUT_OF_INDEXES, allocation_filter_flag_tls_);
   // And disable it by default.
   set_allocation_filter_flag(false);
 }
 
 BlockHeapManager::~BlockHeapManager() {
   TearDownHeapManager();
 }
 
 void BlockHeapManager::Init() {
   DCHECK(!initialized_);
 
   {
     base::AutoLock lock(lock_);
     InitInternalHeap();
-    corrupt_block_registry_cache_.Init();
+
+    // Only create a registry cache if the registry is available. It is not
+    // available in sandboxed Chrome renderer processes.
+    if (RegistryCache::RegistryAvailable()) {
+      corrupt_block_registry_cache_.reset(
+          new RegistryCache(L"SyzyAsanCorruptBlocks"));
+      corrupt_block_registry_cache_->Init();
+    }
   }
 
   // This takes care of its own locking, as its reentrant.
   PropagateParameters();
 
   {
     base::AutoLock lock(lock_);
     InitProcessHeap();
     initialized_ = true;
   }
@@ skipping 825 matching lines @@
   DCHECK_NE(static_cast<const BlockInfo*>(nullptr), block_info);
 
   if (!parameters_.prevent_duplicate_corruption_crashes)
     return true;
 
   const common::StackCapture* alloc_stack = block_info->header->alloc_stack;
   StackId relative_alloc_stack_id = alloc_stack->relative_stack_id();
 
   // Look at the registry cache to see if an error has already been reported
   // for this allocation stack trace, if so prevent from reporting another one.
-  if (corrupt_block_registry_cache_.DoesIdExist(relative_alloc_stack_id))
-    return false;
+  if (corrupt_block_registry_cache_.get()) {
+    if (corrupt_block_registry_cache_->DoesIdExist(relative_alloc_stack_id))
+      return false;
 
-  // Update the corrupt block registry cache to prevent from crashing if we
-  // encounter a corrupt block that has the same allocation stack trace.
-  corrupt_block_registry_cache_.AddOrUpdateStackId(relative_alloc_stack_id);
+    // Update the corrupt block registry cache to prevent from crashing if we
+    // encounter a corrupt block that has the same allocation stack trace.
+    corrupt_block_registry_cache_->AddOrUpdateStackId(relative_alloc_stack_id);
+  }
+
   return true;
 }
 
 void BlockHeapManager::TrimOrScheduleIfNecessary(
     TrimStatus trim_status,
     BlockQuarantineInterface* quarantine) {
   // If no trimming is required, nothing to do.
   if (trim_status == TRIM_NOT_REQUIRED)
     return;
 
@@ skipping 40 matching lines @@
 
   // Create the thread and wait for it to start.
   base::AutoLock lock(deferred_free_thread_lock_);
   deferred_free_thread_.reset(new DeferredFreeThread(deferred_free_callback));
   deferred_free_thread_->Start();
 }
 
 }  // namespace heap_managers
 }  // namespace asan
 }  // namespace agent