Add `LsanMetadataRemoteView` class.

[delcypher]

Summary

This corresponds roughly with the existing LsanMetadata wrapper
class but it is intended for use in an out-of-process context.

Instead of templating the LsanMetadata class on AddressSpaceView,
we sub-class LsanMetadata as LsanMetadataRemoteView so we can
re-use as much code as possible. LsanMetadataRemoteView also requires
storing extra more fields which I did not want LsanMetadata to also
require.

This patch only provides an implementation of LsanMetadataRemoteView
for ASan. An implementation for LSan will be provided at a later date.

This patch uses refactorings done in

• https://reviews.llvm.org/D56968
• https://reviews.llvm.org/D56993

rdar://problem/45284065

[vitalybuka]

Removing stale patches from the "Ready to Review" list.

lib/asan/asan_allocator.cc

 //===----------------------------------------------------------------------===//
 
 #include "asan_allocator.h"
 #include "asan_mapping.h"
 #include "asan_poisoning.h"
 #include "asan_report.h"
 #include "asan_stack.h"
 #include "asan_thread.h"
+#include "lsan/lsan_common.h"
 #include "sanitizer_common/sanitizer_allocator_checks.h"
 #include "sanitizer_common/sanitizer_allocator_interface.h"
 #include "sanitizer_common/sanitizer_errno.h"
 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_list.h"
-#include "sanitizer_common/sanitizer_stackdepot.h"
 #include "sanitizer_common/sanitizer_quarantine.h"
-#include "lsan/lsan_common.h"
+#include "sanitizer_common/sanitizer_remote_address_space_view.h"
+#include "sanitizer_common/sanitizer_stackdepot.h"
 
 namespace __asan {
 
 // Valid redzone sizes are 16, 32, 64, ... 2048, so we encode them in 3 bits.
 // We use adaptive redzones: for larger allocation larger redzones are used.
 static u32 RZLog2Size(u32 rz_log) {
   CHECK_LT(rz_log, 8);
   return 16 << rz_log;
struct AsanChunk: ChunkBase {
   void *AllocBeg(bool locked_version = false) {
     return AllocBegInternal<LocalAddressSpaceView>(
         reinterpret_cast<uptr>(this), locked_version,
         reinterpret_cast<uptr>(&get_allocator()));
   }
   bool AddrIsInside(uptr addr, bool locked_version = false) {
     return (addr >= Beg()) && (addr < Beg() + UsedSize(locked_version));
   }
+  // Allow class to access private methods for out-of-process use case.
+  friend class __lsan::LsanMetadataRemoteView;
 
  private:
   // Common code for in-process and out-of-process chunk examination.
   //
   // * For the in-process case `chunk_storage_addr` is the same as the `this`
   //   pointer. For the out-of-process case it is a pointer to the
   //   `AsanChunk` in the target process.
   // * `allocator` is a pointer to the allocator in the local
uptr LsanMetadata::requested_size() const {
   return m->UsedSize(/*locked_version=*/true);
 }
 
 u32 LsanMetadata::stack_trace_id() const {
   __asan::AsanChunk *m = reinterpret_cast<__asan::AsanChunk *>(metadata_);
   return m->alloc_context_id;
 }
 
+LsanMetadataRemoteView::LsanMetadataRemoteView(uptr block_begin, uptr allocator)
+    : LsanMetadata(0) {
+  CHECK(block_begin);
+  CHECK(allocator);
+  this->block_begin_target_ = block_begin;
+  this->allocator_ = allocator;
+
+  // We expect the `block_begin` pointer to actually point to the beginning
+  // of an allocator block.
+#if SANITIZER_DEBUG
+  using RemoteAllocatorTy = __asan::AsanAllocatorASVT<RemoteAddressSpaceView>;
+  DCHECK_EQ(reinterpret_cast<RemoteAllocatorTy *>(allocator)->GetBlockBegin(
+                reinterpret_cast<void *>(block_begin_target_)),
+            block_begin_target_);
+#endif
+
+  // Determine the address of the AsanChunk in the target process.
+  auto chunk_addr = __asan::GetAsanChunkInternal<RemoteAddressSpaceView>(
+      block_begin_target_, allocator_);
+  metadata_target_ = reinterpret_cast<uptr>(chunk_addr);
+
+  // Copy the AsanChunk into the local process.
+  const __asan::AsanChunk *asan_chunk =
+      RemoteAddressSpaceView::Load(chunk_addr);
+  metadata_ =
+      reinterpret_cast<void *>(const_cast<__asan::AsanChunk *>(asan_chunk));
+}
+
+void LsanMetadataRemoteView::set_tag(ChunkTag value) {
+  CHECK(0 && "Unsupported operation");
+}
+
+uptr LsanMetadataRemoteView::requested_size() const {
+  auto asan_chunk = reinterpret_cast<__asan::AsanChunk *>(metadata_);
+  // NOTE: We provide `known_alloc_beg` as an optimization.
+  return asan_chunk->UsedSizeInternal<RemoteAddressSpaceView>(
+      /*chunk_storage_addr=*/metadata_target_,
+      /*locked_version=*/false, /*allocator=*/allocator_,
+      /*known_alloc_beg=*/reinterpret_cast<void *>(block_begin_target_));
+}
+
+uptr LsanMetadataRemoteView::user_begin() const {
+  auto asan_chunk = reinterpret_cast<__asan::AsanChunk *>(metadata_);
+  return asan_chunk->BegInternal(/*chunk_storage_addr=*/metadata_target_);
+}
+
 void ForEachChunk(ForEachChunkCallback callback, void *arg) {
   __asan::get_allocator().ForEachChunk(callback, arg);
 }
 
 IgnoreObjectResult IgnoreObjectLocked(const void *p) {
   uptr addr = reinterpret_cast<uptr>(p);
   __asan::AsanChunk *m = __asan::instance.GetAsanChunkByAddr(addr);
   if (!m) return kIgnoreObjectInvalid;

lib/lsan/lsan_common.h

  public:
   // Constructor accepts address of user-visible chunk.
   explicit LsanMetadata(uptr chunk);
   bool allocated() const;
   ChunkTag tag() const;
   void set_tag(ChunkTag value);
   uptr requested_size() const;
   u32 stack_trace_id() const;
- private:
+
+ protected:
   void *metadata_;
 };
 
+class LsanMetadataRemoteView : public LsanMetadata {
+  // For efficiency reasons we require a pointer to the beginning of
+  // the underlying allocator block (i.e. what `ForEachChunk` gives to its call
+  // back). This is different from `LsanMetadata` which expects a pointer
+  // to the beginning of user data.
+  //
+  // `block_begin` - Pointer to the beginning of an allocator block in
+  //                 target process (as returned by GetBlockBegin() and reported
+  //                 by ForEachChunk()).
+  //
+  // `allocator`   - Pointer to allocator. This should be in the local
+  //                 address space.
+ public:
+  LsanMetadataRemoteView(uptr block_begin, uptr allocator);
+  void set_tag(ChunkTag value);
+  uptr requested_size() const;
+  uptr user_begin() const;
+
+ private:
+  uptr metadata_target_;
+  uptr block_begin_target_;
+  uptr allocator_;
+};
+
 }  // namespace __lsan
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 const char *__lsan_default_options();
 
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 int __lsan_is_turned_off();
 
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 const char *__lsan_default_suppressions();
 }  // extern "C"
 
 #endif  // LSAN_COMMON_H