commit 82ab8320be0e10c64f78bd46e68693174052a822
author Brandon Kim <brandonkim@google.com> Thu Aug 17 00:50:18 2023 +0000
committer Willy Tu <wltu@google.com> Wed Aug 16 23:37:21 2023 -0700
tree 9f6a3257dd7d64298a5599a097d97601ab67bd27
parent 759ebaf3702e52e273e69d8247b519dc0c07fdb6

buffer: Update to follow the design doc

queueSize and ueRegionSize should not change at runtime. Make it so that
it throws if these constants fail any time we try to use them as it
means that the buffer was overwritten (possibly by a bad actor).

Update the default queueSize and ueRegionSize to match our test
variables.

Signed-off-by: Brandon Kim <brandonkim@google.com>
Change-Id: I2c906d26016ce6eb19e953ae432abd5482b6ccf8

test/buffer_test.cpp

diff --git a/test/buffer_test.cpp b/test/buffer_test.cpp
index 2856e8c..d92bf06 100644
--- a/test/buffer_test.cpp
+++ b/test/buffer_test.cpp
@@ -240,6 +240,90 @@
               static_cast<uint32_t>(BmcFlags::ready));
 }
 
+TEST_F(BufferTest, GetMaxOffsetQueueSizeFail)
+{
+    InSequence s;
+    static constexpr size_t wrongQueueSize = testQueueSize - 1;
+    EXPECT_CALL(*dataInterfaceMockPtr, getMemoryRegionSize())
+        .WillOnce(Return(testRegionSize));
+    const std::vector<uint8_t> emptyArray(wrongQueueSize, 0);
+    EXPECT_CALL(*dataInterfaceMockPtr, write(0, ElementsAreArray(emptyArray)))
+        .WillOnce(Return(wrongQueueSize));
+
+    EXPECT_CALL(*dataInterfaceMockPtr, write(0, _))
+        .WillOnce(Return(bufferHeaderSize));
+    EXPECT_NO_THROW(bufferImpl->initialize(testBmcInterfaceVersion,
+                                           wrongQueueSize, testUeRegionSize,
+                                           testMagicNumber));
+    EXPECT_THROW(
+        try {
+            bufferImpl->getMaxOffset();
+        } catch (const std::runtime_error& e) {
+            EXPECT_STREQ(e.what(),
+                         "[getMaxOffset] runtime queueSize '511' did not match "
+                         "compile-time queueSize '512'. This indicates that the"
+                         " buffer was corrupted");
+            throw;
+        },
+        std::runtime_error);
+}
+
+TEST_F(BufferTest, GetMaxOffsetUeRegionSizeFail)
+{
+    InSequence s;
+    EXPECT_CALL(*dataInterfaceMockPtr, getMemoryRegionSize())
+        .WillOnce(Return(testRegionSize));
+    const std::vector<uint8_t> emptyArray(testQueueSize, 0);
+    EXPECT_CALL(*dataInterfaceMockPtr, write(0, ElementsAreArray(emptyArray)))
+        .WillOnce(Return(testQueueSize));
+
+    EXPECT_CALL(*dataInterfaceMockPtr, write(0, _))
+        .WillOnce(Return(bufferHeaderSize));
+    EXPECT_NO_THROW(bufferImpl->initialize(testBmcInterfaceVersion,
+                                           testQueueSize, testUeRegionSize + 1,
+                                           testMagicNumber));
+    EXPECT_THROW(
+        try {
+            bufferImpl->getMaxOffset();
+        } catch (const std::runtime_error& e) {
+            EXPECT_STREQ(
+                e.what(),
+                "[getMaxOffset] runtime ueRegionSize '81' did not match "
+                "compile-time ueRegionSize '80'. This indicates that the"
+                " buffer was corrupted");
+            throw;
+        },
+        std::runtime_error);
+}
+
+TEST_F(BufferTest, GetOffsetUeRegionSizeFail)
+{
+    InSequence s;
+    EXPECT_CALL(*dataInterfaceMockPtr, getMemoryRegionSize())
+        .WillOnce(Return(testRegionSize));
+    const std::vector<uint8_t> emptyArray(testQueueSize, 0);
+    EXPECT_CALL(*dataInterfaceMockPtr, write(0, ElementsAreArray(emptyArray)))
+        .WillOnce(Return(testQueueSize));
+
+    EXPECT_CALL(*dataInterfaceMockPtr, write(0, _))
+        .WillOnce(Return(bufferHeaderSize));
+    EXPECT_NO_THROW(bufferImpl->initialize(testBmcInterfaceVersion,
+                                           testQueueSize, testUeRegionSize - 1,
+                                           testMagicNumber));
+    EXPECT_THROW(
+        try {
+            bufferImpl->getQueueOffset();
+        } catch (const std::runtime_error& e) {
+            EXPECT_STREQ(
+                e.what(),
+                "[getQueueOffset] runtime ueRegionSize '79' did not match "
+                "compile-time ueRegionSize '80'. This indicates that the"
+                " buffer was corrupted");
+            throw;
+        },
+        std::runtime_error);
+}
+
 class BufferWraparoundReadTest : public BufferTest
 {
   protected:
@@ -274,11 +358,17 @@
         reinterpret_cast<uint8_t*>(&testInitializationHeader);
 };
 
-TEST_F(BufferWraparoundReadTest, GetMaxOffsetTest)
+TEST_F(BufferWraparoundReadTest, GetMaxOffsetPassTest)
 {
     EXPECT_EQ(bufferImpl->getMaxOffset(), testMaxOffset);
 }
 
+TEST_F(BufferWraparoundReadTest, GetQueueOffsetPassTest)
+{
+    EXPECT_EQ(bufferImpl->getQueueOffset(),
+              bufferHeaderSize + testUeRegionSize);
+}
+
 TEST_F(BufferWraparoundReadTest, ParamsTooBigFail)
 {
     InSequence s;