Remove the is_nested bit from the BlockInfo structure.

syzygy/agent/asan/block_unittest.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 49 matching lines @@
             block.RawTrailerPadding());
   EXPECT_EQ(block.RawTrailerPadding() + block.trailer_padding_size,
             block.RawTrailer());
   EXPECT_EQ(block.RawHeader() + block.block_size,
             block.RawTrailer() + sizeof(BlockTrailer));
 
   // Validate the actual contents of the various parts of the block.
 
   // Check the header.
   EXPECT_EQ(kBlockHeaderMagic, block.header->magic);
-  EXPECT_FALSE(block.header->is_nested);
   EXPECT_LT(0u, block.header->body_size);
   EXPECT_EQ(block.header->body_size, block.body_size);
   if (just_initialized) {
     EXPECT_EQ(0u, block.header->checksum);
     EXPECT_EQ(NULL, block.header->alloc_stack);
     EXPECT_EQ(NULL, block.header->free_stack);
     EXPECT_EQ(ALLOCATED_BLOCK, block.header->state);
   }
 
-  // By default we assume the blocks to not be nested.
-  EXPECT_FALSE(block.header->is_nested);
-  EXPECT_EQ(static_cast<bool>(block.header->is_nested), block.is_nested);
-
   // Check the header padding.
   if (block.header->has_header_padding) {
     EXPECT_LE(kShadowRatio, block.header_padding_size);
     EXPECT_EQ(block.header_padding_size,
               *reinterpret_cast<const uint32_t*>(block.header_padding));
     EXPECT_EQ(block.header_padding_size,
               *reinterpret_cast<const uint32_t*>(block.RawHeaderPadding() +
                                                  block.header_padding_size -
                                                  sizeof(uint32_t)));
     for (uint32_t i = sizeof(uint32_t);
@@ skipping 106 matching lines @@
   // Plan a layout with an invalid size, this should fail.
   EXPECT_FALSE(BlockPlanLayout(8, 8, 0xffffffff, 0, 0, &layout));
 }
 
 TEST_F(BlockTest, EndToEnd) {
   BlockLayout layout = {};
   BlockInfo block_info = {};
 
   EXPECT_TRUE(BlockPlanLayout(8, 8, 4, 0, 0, &layout));
   std::vector<uint8_t> block_data(layout.block_size);
-  BlockInitialize(layout, block_data.data(), false, &block_info);
+  BlockInitialize(layout, block_data.data(), &block_info);
   EXPECT_NO_FATAL_FAILURE(IsValidInitializedBlock(block_info));
   block_data.clear();
 
   EXPECT_TRUE(BlockPlanLayout(8, 8, 61, 0, 0, &layout));
   block_data.resize(layout.block_size);
-  BlockInitialize(layout, block_data.data(), false, &block_info);
+  BlockInitialize(layout, block_data.data(), &block_info);
   EXPECT_NO_FATAL_FAILURE(IsValidInitializedBlock(block_info));
   block_data.clear();
 
   EXPECT_TRUE(BlockPlanLayout(8, 8, 60, 32, 32, &layout));
   block_data.resize(layout.block_size);
-  BlockInitialize(layout, block_data.data(), false, &block_info);
+  BlockInitialize(layout, block_data.data(), &block_info);
   EXPECT_NO_FATAL_FAILURE(IsValidInitializedBlock(block_info));
   block_data.clear();
 
   // Do an allocation that uses entire pages.
   EXPECT_TRUE(BlockPlanLayout(4096, 8, 100, 4096, 4096, &layout));
   void* data = ::VirtualAlloc(NULL, layout.block_size, MEM_COMMIT,
                               PAGE_READWRITE);
   ::memset(data, 0, layout.block_size);
-  BlockInitialize(layout, data, false, &block_info);
+  BlockInitialize(layout, data, &block_info);
   EXPECT_NO_FATAL_FAILURE(IsValidInitializedBlock(block_info));
   ASSERT_EQ(TRUE, ::VirtualFree(data, 0, MEM_RELEASE));
 }
 
 TEST_F(BlockTest, GetHeaderFromBody) {
   // Plan two layouts, one with header padding and another without.
   BlockLayout layout1 = {};
   BlockLayout layout2 = {};
   EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 10, 0, 0, &layout1));
   EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 10, 32, 0, &layout2));
 
   std::unique_ptr<uint8_t[]> data(new uint8_t[layout2.block_size]);
   ::memset(data.get(), 0, layout2.block_size);
 
   // First try navigating a block without header padding.
   BlockInfo info = {};
-  BlockInitialize(layout1, data.get(), false, &info);
+  BlockInitialize(layout1, data.get(), &info);
   // This should succeed as expected.
   EXPECT_EQ(info.header, BlockGetHeaderFromBody(info.body));
   // This fails because of invalid alignment.
   EXPECT_TRUE(BlockGetHeaderFromBody(
       reinterpret_cast<BlockBody*>(info.RawBody() + 1)) == nullptr);
   // This fails because the pointer is not at the beginning of the
   // body.
   EXPECT_TRUE(BlockGetHeaderFromBody(
       reinterpret_cast<BlockBody*>(info.RawBody() + kShadowRatio)) == nullptr);
   // This fails because of invalid header magic.
   ++info.header->magic;
   EXPECT_TRUE(BlockGetHeaderFromBody(info.body) == nullptr);
   // This fails because the header indicates there's padding.
   --info.header->magic;
   info.header->has_header_padding = 1;
   EXPECT_TRUE(BlockGetHeaderFromBody(info.body) == nullptr);
 
   // Now navigate a block with header padding.
-  BlockInitialize(layout2, data.get(), false, &info);
+  BlockInitialize(layout2, data.get(), &info);
   // This should succeed as expected.
   EXPECT_EQ(info.header, BlockGetHeaderFromBody(info.body));
   // This fails because of invalid alignment.
   EXPECT_TRUE(BlockGetHeaderFromBody(
       reinterpret_cast<BlockBody*>(info.RawBody() + 1)) == nullptr);
   // This fails because the pointer is not at the beginning of the
   // body.
   EXPECT_TRUE(BlockGetHeaderFromBody(
       reinterpret_cast<BlockBody*>(info.RawBody() + kShadowRatio)) == nullptr);
   // This fails because of invalid header magic.
@@ skipping 15 matching lines @@
   EXPECT_TRUE(BlockGetHeaderFromBody(info.body) == nullptr);
 }
 
 TEST_F(BlockTest, GetHeaderFromBodyProtectedMemory) {
   BlockLayout layout = {};
   EXPECT_TRUE(BlockPlanLayout(4096, 4096, 4096, 4096, 4096, &layout));
   void* alloc = ::VirtualAlloc(NULL, layout.block_size, MEM_COMMIT,
                                PAGE_READWRITE);
   ASSERT_TRUE(alloc != NULL);
   BlockInfo block_info = {};
-  BlockInitialize(layout, alloc, false, &block_info);
+  BlockInitialize(layout, alloc, &block_info);
 
   BlockProtectRedzones(block_info, &shadow_);
   EXPECT_CALL(*this, OnExceptionCallback(_));
   EXPECT_TRUE(BlockGetHeaderFromBody(block_info.body) == NULL);
   testing::Mock::VerifyAndClearExpectations(this);
   BlockProtectNone(block_info, &shadow_);
 
   ASSERT_EQ(TRUE, ::VirtualFree(alloc, 0, MEM_RELEASE));
 }
 
 TEST_F(BlockTest, ConvertBlockInfo) {
   BlockLayout layout = {};
   EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 10, 0, 0, &layout));
 
   std::unique_ptr<uint8_t[]> data(new uint8_t[layout.block_size]);
   ::memset(data.get(), 0, layout.block_size);
 
   BlockInfo expanded = {};
-  BlockInitialize(layout, data.get(), false, &expanded);
+  BlockInitialize(layout, data.get(), &expanded);
 
   CompactBlockInfo compact = {};
   ConvertBlockInfo(expanded, &compact);
   EXPECT_EQ(layout.block_size, compact.block_size);
   EXPECT_EQ(layout.header_size + layout.header_padding_size,
             compact.header_size);
   EXPECT_EQ(layout.trailer_size + layout.trailer_padding_size,
             compact.trailer_size);
   EXPECT_FALSE(compact.is_nested);
 
   BlockInfo expanded2 = {};
   ConvertBlockInfo(compact, &expanded2);
   EXPECT_EQ(0, ::memcmp(&expanded, &expanded2, sizeof(expanded)));
 }
 
 TEST_F(BlockTest, BlockInfoFromMemory) {
   // Plan two layouts, one with header padding and another without.
   BlockLayout layout1 = {};
   BlockLayout layout2 = {};
   EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 10, 0, 0, &layout1));
   EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 10, 32, 0, &layout2));
 
   std::unique_ptr<uint8_t[]> data(new uint8_t[layout2.block_size]);
   ::memset(data.get(), 0, layout2.block_size);
 
   // First recover a block without header padding.
   BlockInfo info = {};
-  BlockInitialize(layout1, data.get(), false, &info);
+  BlockInitialize(layout1, data.get(), &info);
   BlockInfo info_recovered = {};
   EXPECT_TRUE(BlockInfoFromMemory(info.header, &info_recovered));
   EXPECT_EQ(info, info_recovered);
   // Failed because its not aligned.
   EXPECT_FALSE(BlockInfoFromMemory(
       reinterpret_cast<BlockHeader*>(info.RawHeader() + 1),
       &info_recovered));
   // Failed because the magic is invalid.
   ++info.header->magic;
   EXPECT_FALSE(BlockInfoFromMemory(info.header, &info_recovered));
   --info.header->magic;
   // This fails because the header indicates there's padding yet there is
   // none.
   info.header->has_header_padding = 1;
   EXPECT_FALSE(BlockInfoFromMemory(info.header, &info_recovered));
 
   // Now recover a block with header padding.
-  BlockInitialize(layout2, data.get(), false, &info);
+  BlockInitialize(layout2, data.get(), &info);
   EXPECT_TRUE(BlockInfoFromMemory(info.header, &info_recovered));
   EXPECT_EQ(info, info_recovered);
   // Failed because the magic is invalid.
   ++info.header->magic;
   EXPECT_FALSE(BlockInfoFromMemory(info.header, &info_recovered));
   --info.header->magic;
   // Failed because the header padding lengths don't match.
   uint32_t* head = reinterpret_cast<uint32_t*>(info.header_padding);
   uint32_t* tail = head + (info.header_padding_size / sizeof(uint32_t)) - 1;
   ++(*tail);
   EXPECT_FALSE(BlockInfoFromMemory(info.header, &info_recovered));
   --(*tail);
 
   // Finally ensure that we can recover information about blocks of various
   // sizes.
   const size_t kAllocSize = 3 * GetPageSize();
   void* alloc = ::VirtualAlloc(NULL, kAllocSize, MEM_COMMIT, PAGE_READWRITE);
   for (uint32_t block_size = 0; block_size < kShadowRatio * 2; ++block_size) {
     BlockLayout layout = {};
     EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, block_size, 0, 0,
                                 &layout));
     ASSERT_LE(layout.block_size, kAllocSize);
-    BlockInitialize(layout, alloc, false, &info);
+    BlockInitialize(layout, alloc, &info);
     EXPECT_TRUE(BlockInfoFromMemory(info.header, &info_recovered));
     EXPECT_EQ(info.body_size, info_recovered.body_size);
-    EXPECT_EQ(info, info_recovered);
+    EXPECT_EQ(info, info_recovered) << block_size;
 
     EXPECT_TRUE(BlockPlanLayout(4096, 4096, block_size, 4096, 4096,
                                 &layout));
     ASSERT_LE(layout.block_size, kAllocSize);
-    BlockInitialize(layout, alloc, false, &info);
+    BlockInitialize(layout, alloc, &info);
     EXPECT_TRUE(BlockInfoFromMemory(info.header, &info_recovered));
     EXPECT_EQ(info.body_size, info_recovered.body_size);
     EXPECT_EQ(info, info_recovered);
   }
   ::VirtualFree(alloc, 0, MEM_RELEASE);
 }
 
 TEST_F(BlockTest, BlockInfoFromMemoryInvalidPadding) {
   BlockLayout layout = {};
   EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 10,
       4 * sizeof(BlockHeader), 0, &layout));
 
   std::unique_ptr<uint8_t[]> data(new uint8_t[layout.block_size]);
   ::memset(data.get(), 0, layout.block_size);
 
   BlockInfo info = {};
-  BlockInitialize(layout, data.get(), false, &info);
+  BlockInitialize(layout, data.get(), &info);
   EXPECT_EQ(1, info.header->has_header_padding);
   BlockInfo info_recovered = {};
   EXPECT_TRUE(BlockInfoFromMemory(info.header, &info_recovered));
   EXPECT_EQ(info, info_recovered);
 
   // Invalidates the padding size and make sure that we can't retrieve the block
   // information.
   size_t* padding_size = reinterpret_cast<size_t*>(info.header + 1);
   EXPECT_GE(*padding_size, 2 * sizeof(uint32_t));
   for (*padding_size = 0; *padding_size < 2 * sizeof(uint32_t);
        ++(*padding_size)) {
     EXPECT_FALSE(BlockInfoFromMemory(info.header, &info_recovered));
   }
 }
 
 TEST_F(BlockTest, BlockInfoFromMemoryProtectedMemory) {
   BlockLayout layout = {};
   EXPECT_TRUE(BlockPlanLayout(4096, 4096, 4096, 4096, 4096, &layout));
   void* alloc = ::VirtualAlloc(NULL, layout.block_size, MEM_COMMIT,
                                PAGE_READWRITE);
   ASSERT_TRUE(alloc != NULL);
   BlockInfo block_info = {};
-  BlockInitialize(layout, alloc, false, &block_info);
+  BlockInitialize(layout, alloc, &block_info);
 
   BlockProtectRedzones(block_info, &shadow_);
   BlockInfo recovered_info = {};
   EXPECT_CALL(*this, OnExceptionCallback(_));
   EXPECT_FALSE(BlockInfoFromMemory(block_info.header, &recovered_info));
   testing::Mock::VerifyAndClearExpectations(this);
   BlockProtectNone(block_info, &shadow_);
 
   ASSERT_EQ(TRUE, ::VirtualFree(alloc, 0, MEM_RELEASE));
 }
 
-TEST_F(BlockTest, BlockInfoFromMemoryForNestedBlock) {
-  BlockLayout layout = {};
-  EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 10, 0, 0, &layout));
-
-  std::unique_ptr<uint8_t[]> data(new uint8_t[layout.block_size]);
-  BlockInfo block_info = {};
-  BlockInitialize(layout, data.get(), true, &block_info);
-
-  BlockInfo recovered_info = {};
-  EXPECT_TRUE(BlockInfoFromMemory(block_info.header, &recovered_info));
-
-  EXPECT_TRUE(recovered_info.is_nested);
-  EXPECT_TRUE(recovered_info.header->is_nested);
-}
-
 TEST_F(BlockTest, ChecksumWorksForAllStates) {
   BlockLayout layout = {};
   EXPECT_TRUE(BlockPlanLayout(kShadowRatio, kShadowRatio, 10, 0, 0, &layout));
   std::unique_ptr<uint8_t[]> data(new uint8_t[layout.block_size]);
   ::memset(data.get(), 0, layout.block_size);
   BlockInfo info = {};
-  BlockInitialize(layout, data.get(), false, &info);
+  BlockInitialize(layout, data.get(), &info);
   while (true) {
     BlockCalculateChecksum(info);
     ++info.header->state;
     if (info.header->state == 0)
       break;
   }
 }
 
 namespace {
 
@@ skipping 208 matching lines @@
        chunk_size *= 2) {
     for (uint32_t align = kShadowRatio; align <= chunk_size; align *= 2) {
       for (uint32_t redzone = 0; redzone <= chunk_size; redzone += chunk_size) {
         for (size_t i = 0; i < arraysize(kSizes); ++i) {
           BlockLayout layout = {};
           EXPECT_TRUE(BlockPlanLayout(chunk_size, align, kSizes[i], redzone,
                                       redzone, &layout));
           ASSERT_GT(kAllocSize, layout.block_size);
 
           BlockInfo block_info = {};
-          BlockInitialize(layout, alloc, false, &block_info);
+          BlockInitialize(layout, alloc, &block_info);
           block_info.header->alloc_stack = valid_stack;
           block_info.trailer->heap_id = valid_heap_id;
 
           // Test that the checksum detects tampering as expected in each block
           // state.
           block_info.header->state = ALLOCATED_BLOCK;
           ASSERT_NO_FATAL_FAILURE(TestChecksumDetectsTampering(block_info));
 
           block_info.header->state = QUARANTINED_BLOCK;
           block_info.header->free_stack = valid_stack;
@@ skipping 111 matching lines @@
       BlockBitFlipsFixChecksum(QUARANTINED_BLOCK, block1.block_info, 0));
   EXPECT_TRUE(
       BlockBitFlipsFixChecksum(QUARANTINED_BLOCK, block1.block_info, 3));
   flips = BlockBitFlipsRequired(QUARANTINED_BLOCK, block1.block_info, 3);
   EXPECT_LT(0u, flips);
   EXPECT_GE(3u, flips);
 }
 
 }  // namespace asan
 }  // namespace agent