Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 35493e7a authored by Valerie Hau's avatar Valerie Hau
Browse files

Capping buffer size to std::numeric_limits<size_t>::max() 

If stride is set to nonsensical (if stride has no meaning for the
particular buffer allocation) or to a stride size such that height *
stride * bpp would overflow size_t, approximate buffer size with stride
= width instead.

Bug: 142767215
Test: build, boot, GraphicBufferAllocation_test
Change-Id: Ia955246f529e46a80164d8b5c7bf59d0ec0def96
parent 13bd8e4d

libs/ui/GraphicBufferAllocator.cpp

+11 −1
Original line number Diff line number Diff line
@@ -140,6 +140,16 @@ status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, 


    status_t error =

            mAllocator->allocate(width, height, format, layerCount, usage, 1, stride, handle);

    size_t bufSize;



    // if stride has no meaning or is too large,

    // approximate size with the input width instead

    if (std::numeric_limits<size_t>::max() / height / (*stride) < static_cast<size_t>(bpp)) {

        bufSize = static_cast<size_t>(width) * height * bpp;

    } else {

        bufSize = static_cast<size_t>((*stride)) * height * bpp;

    }



    if (error == NO_ERROR) {

        Mutex::Autolock _l(sLock);

        KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList);
@@ -150,7 +160,7 @@ status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, 
        rec.format = format;

        rec.layerCount = layerCount;

        rec.usage = usage;

        rec.size = static_cast<size_t>(height * (*stride) * bpp);

        rec.size = bufSize;

        rec.requestorName = std::move(requestorName);

        list.add(*handle, rec);

libs/ui/include/ui/GraphicBufferAllocator.h

+1 −1
Original line number Diff line number Diff line
@@ -54,7 +54,7 @@ public: 
    void dump(std::string& res) const;

    static void dumpToSystemLog();



private:

protected:

    struct alloc_rec_t {

        uint32_t width;

        uint32_t height;

libs/ui/tests/Android.bp

+20 −0
Original line number Diff line number Diff line
@@ -28,6 +28,26 @@ cc_test { 
    cflags: ["-Wall", "-Werror"],

}



cc_test {

    name: "GraphicBufferAllocator_test",

    header_libs: [

        "libdvr_headers",

        "libnativewindow_headers",

    ],

    static_libs: [

        "libgmock",

    ],

    shared_libs: [

        "liblog",

	"libui",

    ],

    srcs: [

        "GraphicBufferAllocator_test.cpp",

        "mock/MockGrallocAllocator.cpp",

    ],

    cflags: ["-Wall", "-Werror"],

}



cc_test {

    name: "GraphicBuffer_test",

    header_libs: [

libs/ui/tests/GraphicBufferAllocator_test.cpp

0 → 100644
+102 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2019 The Android Open Source Project

 *

 * 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,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#define LOG_TAG "GraphicBufferAllocatorTest"



#include <ui/GraphicBuffer.h>

#include <ui/GraphicBufferAllocator.h>

#include <ui/PixelFormat.h>



#include <gtest/gtest.h>



#include "mock/MockGrallocAllocator.h"



#include <algorithm>

#include <limits>



namespace android {



namespace {



constexpr uint32_t kTestWidth = 1024;

constexpr uint32_t kTestHeight = 1;

constexpr uint32_t kTestLayerCount = 1;

constexpr uint64_t kTestUsage = GraphicBuffer::USAGE_SW_WRITE_OFTEN;



} // namespace



using ::testing::DoAll;

using ::testing::Return;

using ::testing::SetArgPointee;



class TestableGraphicBufferAllocator : public GraphicBufferAllocator {

public:

    TestableGraphicBufferAllocator() {

        mAllocator = std::make_unique<const mock::MockGrallocAllocator>();

    }

    void setUpAllocateExpectations(status_t err, uint32_t stride) {

        std::cout << "Setting expected stride to " << stride << std::endl;

        EXPECT_CALL(*(reinterpret_cast<const mock::MockGrallocAllocator*>(mAllocator.get())),

                    allocate)

                .WillOnce(DoAll(SetArgPointee<6>(stride), Return(err)));

    }

    std::unique_ptr<const GrallocAllocator>& getAllocator() { return mAllocator; }

};



class GraphicBufferAllocatorTest : public testing::Test {

public:

    GraphicBufferAllocatorTest() : mAllocator() {}

    const TestableGraphicBufferAllocator& getAllocator() { return mAllocator; }



protected:

    TestableGraphicBufferAllocator mAllocator;

};



TEST_F(GraphicBufferAllocatorTest, AllocateNoError) {

    mAllocator.setUpAllocateExpectations(NO_ERROR, kTestWidth);

    android::PixelFormat format = PIXEL_FORMAT_RGBA_8888;

    uint32_t stride = 0;

    buffer_handle_t handle;

    status_t err = mAllocator.allocate(kTestWidth, kTestHeight, format, kTestLayerCount, kTestUsage,

                                       &handle, &stride, 0, "GraphicBufferAllocatorTest");

    ASSERT_EQ(NO_ERROR, err);

    ASSERT_EQ(kTestWidth, stride);

}



TEST_F(GraphicBufferAllocatorTest, AllocateBadStride) {

    uint32_t height = std::numeric_limits<uint32_t>::max();

    uint32_t bpp = 4;

    android::PixelFormat format = PIXEL_FORMAT_RGBA_8888;



    if (std::numeric_limits<size_t>::max() / height / bpp >= std::numeric_limits<uint32_t>::max()) {

        std::cout << "stride cannot cause overflow" << std::endl;

        GTEST_SUCCEED() << "stride cannot cause overflow";

        return;

    }

    uint32_t width = std::numeric_limits<size_t>::max() / height / bpp;



    uint32_t expectedStride = std::numeric_limits<uint32_t>::max();



    mAllocator.setUpAllocateExpectations(NO_ERROR, expectedStride);

    uint32_t stride = 0;

    buffer_handle_t handle;

    // an overflow would cause a crash

    status_t err = mAllocator.allocate(width, height, format, kTestLayerCount, kTestUsage, &handle,

                                       &stride, 0, "GraphicBufferAllocatorTest");

    ASSERT_EQ(NO_ERROR, err);

    ASSERT_EQ(expectedStride, stride);

}

} // namespace android

libs/ui/tests/mock/MockGrallocAllocator.cpp

0 → 100644
+27 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * 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,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include "MockGrallocAllocator.h"



namespace android {



namespace mock {



MockGrallocAllocator::MockGrallocAllocator() = default;

MockGrallocAllocator::~MockGrallocAllocator() = default;



} // namespace mock

} // namespace android