/*
* Copyright (C) 2023 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 <chrono>
#include <condition_variable>
#include <filesystem>
#include <mutex>
#include <string>
#include <thread>
#include <android-base/file.h>
#include <android-base/logging.h>
#include <bpf/BpfUtils.h>
#include <gtest/gtest.h>
#include <poll.h>
#include <signal.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/sysinfo.h>
#include <unistd.h>
#include <BpfSyscallWrappers.h>
#include <memevents/memevents.h>
#include <memevents/memevents_test.h>
using namespace ::android::base;
using namespace ::android::bpf::memevents;
using android::bpf::isAtLeastKernelVersion;
namespace fs = std::filesystem;
static const MemEventClient mem_test_client = MemEventClient::TEST_CLIENT;
static const int page_size = getpagesize();
static const bool isBpfRingBufferSupported = isAtLeastKernelVersion(5, 8, 0);
static const std::string bpfRbsPaths[MemEventClient::NR_CLIENTS] = {
MEM_EVENTS_AMS_RB, MEM_EVENTS_LMKD_RB, MEM_EVENTS_TEST_RB};
static const std::string testBpfSkfilterProgPaths[NR_MEM_EVENTS] = {
MEM_EVENTS_TEST_OOM_KILL_TP, MEM_EVENTS_TEST_DIRECT_RECLAIM_START_TP,
MEM_EVENTS_TEST_DIRECT_RECLAIM_END_TP, MEM_EVENTS_TEST_KSWAPD_WAKE_TP,
MEM_EVENTS_TEST_KSWAPD_SLEEP_TP};
static const std::filesystem::path sysrq_trigger_path = "proc/sysrq-trigger";
/*
* Test suite to test on devices that don't support BPF, kernel <= 5.8.
* We allow for the listener to iniailize gracefully, but every public API will
* return false/fail.
*/
class MemEventListenerUnsupportedKernel : public ::testing::Test {
protected:
MemEventListener memevent_listener = MemEventListener(mem_test_client);
static void SetUpTestSuite() {
if (isBpfRingBufferSupported) {
GTEST_SKIP()
<< "BPF ring buffers is supported on this kernel, running alternative tests";
}
}
void SetUp() override {
ASSERT_FALSE(memevent_listener.ok()) << "BPF ring buffer manager shouldn't initialize";
}
void TearDown() override { memevent_listener.deregisterAllEvents(); }
};
/*
* Listener shouldn't fail when initializing on a kernel that doesn't support BPF.
*/
TEST_F(MemEventListenerUnsupportedKernel, initialize_invalid_client) {
std::unique_ptr<MemEventListener> listener =
std::make_unique<MemEventListener>(MemEventClient::AMS);
ASSERT_TRUE(listener) << "Failed to initialize listener on older kernel";
}
/*
* Register will fail when running on a older kernel, even when we pass a valid event type.
*/
TEST_F(MemEventListenerUnsupportedKernel, fail_to_register) {
ASSERT_FALSE(memevent_listener.registerEvent(MEM_EVENT_OOM_KILL))
<< "Listener should fail to register valid event type on an unsupported kernel";
ASSERT_FALSE(memevent_listener.registerEvent(NR_MEM_EVENTS))
<< "Listener should fail to register invalid event type";
}
/*
* Listen will fail when running on a older kernel.
* The listen() function always checks first if we are running on an older kernel,
* therefore we don't need to register for an event before trying to call listen.
*/
TEST_F(MemEventListenerUnsupportedKernel, fail_to_listen) {
ASSERT_FALSE(memevent_listener.listen()) << "listen() should fail on unsupported kernel";
}
/*
* Just like the other APIs, deregister will return false immediately on an older
* kernel.
*/
TEST_F(MemEventListenerUnsupportedKernel, fail_to_unregister_event) {
ASSERT_FALSE(memevent_listener.deregisterEvent(MEM_EVENT_OOM_KILL))
<< "Listener should fail to deregister valid event type on an older kernel";
ASSERT_FALSE(memevent_listener.deregisterEvent(NR_MEM_EVENTS))
<< "Listener should fail to deregister invalid event type, regardless of kernel "
"version";
}
/*
* The `getMemEvents()` API should fail on an older kernel.
*/
TEST_F(MemEventListenerUnsupportedKernel, fail_to_get_mem_events) {
std::vector<mem_event_t> mem_events;
ASSERT_FALSE(memevent_listener.getMemEvents(mem_events))
<< "Fetching memory events should fail on an older kernel";
}
/*
* The `getRingBufferFd()` API should fail on an older kernel
*/
TEST_F(MemEventListenerUnsupportedKernel, fail_to_get_rb_fd) {
ASSERT_LT(memevent_listener.getRingBufferFd(), 0)
<< "Fetching bpf-rb file descriptor should fail on an older kernel";
}
/*
* Test suite verifies that all the BPF programs and ring buffers are loaded.
*/
class MemEventsBpfSetupTest : public ::testing::Test {
protected:
static void SetUpTestSuite() {
if (!isBpfRingBufferSupported) {
GTEST_SKIP() << "BPF ring buffers not supported in kernels below 5.8";
}
}
};
/*
* Verify that all the ams bpf-programs are loaded.
*/
TEST_F(MemEventsBpfSetupTest, loaded_ams_progs) {
ASSERT_TRUE(std::filesystem::exists(MEM_EVENTS_AMS_OOM_MARK_VICTIM_TP))
<< "Failed to find ams mark_victim bpf-program";
}
/*
* Verify that all the lmkd bpf-programs are loaded.
*/
TEST_F(MemEventsBpfSetupTest, loaded_lmkd_progs) {
ASSERT_TRUE(std::filesystem::exists(MEM_EVENTS_LMKD_VMSCAN_DR_BEGIN_TP))
<< "Failed to find lmkd direct_reclaim_begin bpf-program";
ASSERT_TRUE(std::filesystem::exists(MEM_EVENTS_LMKD_VMSCAN_DR_END_TP))
<< "Failed to find lmkd direct_reclaim_end bpf-program";
ASSERT_TRUE(std::filesystem::exists(MEM_EVENTS_LMKD_VMSCAN_KSWAPD_WAKE_TP))
<< "Failed to find lmkd kswapd_wake bpf-program";
ASSERT_TRUE(std::filesystem::exists(MEM_EVENTS_LMKD_VMSCAN_KSWAPD_SLEEP_TP))
<< "Failed to find lmkd kswapd_sleep bpf-program";
}
/*
* Verify that all the memevents test bpf-skfilter-programs are loaded.
*/
TEST_F(MemEventsBpfSetupTest, loaded_test_skfilter_progs) {
for (int i = 0; i < NR_MEM_EVENTS; i++) {
ASSERT_TRUE(std::filesystem::exists(testBpfSkfilterProgPaths[i]))
<< "Failed to find testing bpf-prog: " << testBpfSkfilterProgPaths[i];
}
}
/*
* Verify that all [bpf] ring buffer's are loaded.
* We expect to have at least 1 ring buffer for each client in `MemEventClient`.
*/
TEST_F(MemEventsBpfSetupTest, loaded_ring_buffers) {
for (int i = 0; i < MemEventClient::NR_CLIENTS; i++) {
ASSERT_TRUE(std::filesystem::exists(bpfRbsPaths[i]))
<< "Failed to find bpf ring-buffer: " << bpfRbsPaths[i];
}
}
class MemEventsListenerTest : public ::testing::Test {
protected:
MemEventListener memevent_listener = MemEventListener(mem_test_client);
static void SetUpTestSuite() {
if (!isBpfRingBufferSupported) {
GTEST_SKIP() << "BPF ring buffers not supported in kernels below 5.8";
}
}
void SetUp() override {
ASSERT_TRUE(memevent_listener.ok())
<< "Memory listener failed to initialize bpf ring buffer manager";
}
void TearDown() override { memevent_listener.deregisterAllEvents(); }
};
/*
* MemEventListener should fail, through a `std::abort()`, when attempted to initialize
* with an invalid `MemEventClient`. By passing `MemEventClient::NR_CLIENTS`, and attempting
* to convert/pass `-1` as a client, we expect the listener initialization to fail.
*/
TEST_F(MemEventsListenerTest, initialize_invalid_client) {
EXPECT_DEATH(MemEventListener listener(MemEventClient::NR_CLIENTS), "");
EXPECT_DEATH(MemEventListener listener(static_cast<MemEventClient>(-1)), "");
}
/*
* MemEventListener should fail when a valid, non-testing, client tries to initialize
* by passing the optional test flag.
*/
TEST_F(MemEventsListenerTest, initialize_valid_client_with_test_flag) {
for (int i = 0; i < MemEventClient::TEST_CLIENT; i++) {
const MemEventClient valid_client = static_cast<MemEventClient>(i);
EXPECT_DEATH(MemEventListener listener(valid_client, true), "")
<< "Only test client is allowed to set the test flag to true";
}
}
/*
* MemEventListener should NOT fail when initializing for all valid `MemEventClient`.
* We considered a `MemEventClient` valid if its between 0 and MemEventClient::NR_CLIENTS.
*/
TEST_F(MemEventsListenerTest, initialize_valid_clients) {
std::unique_ptr<MemEventListener> listener;
for (int i = 0; i < MemEventClient::NR_CLIENTS; i++) {
const MemEventClient client = static_cast<MemEventClient>(i);
listener = std::make_unique<MemEventListener>(client);
ASSERT_TRUE(listener) << "MemEventListener failed to initialize with valid client value: "
<< client;
ASSERT_TRUE(listener->ok()) << "MemEventListener failed to initialize with bpf rb manager";
}
}
/*
* MemEventClient base client should equal to AMS client.
*/
TEST_F(MemEventsListenerTest, base_client_equal_ams_client) {
ASSERT_EQ(static_cast<int>(MemEventClient::BASE), static_cast<int>(MemEventClient::AMS))
<< "Base client should be equal to AMS client";
}
/*
* Validate `registerEvent()` fails with values >= `NR_MEM_EVENTS`.
*/
TEST_F(MemEventsListenerTest, register_event_invalid_values) {
ASSERT_FALSE(memevent_listener.registerEvent(NR_MEM_EVENTS));
ASSERT_FALSE(memevent_listener.registerEvent(NR_MEM_EVENTS + 1));
ASSERT_FALSE(memevent_listener.registerEvent(-1));
}
/*
* Validate that `registerEvent()` always returns true when we try registering
* the same [valid] event/value.
*/
TEST_F(MemEventsListenerTest, register_event_repeated_event) {
const int event_type = MEM_EVENT_OOM_KILL;
ASSERT_TRUE(memevent_listener.registerEvent(event_type));
ASSERT_TRUE(memevent_listener.registerEvent(event_type));
ASSERT_TRUE(memevent_listener.registerEvent(event_type));
}
/*
* Validate that `registerEvent()` is able to register all the `MEM_EVENT_*` values
* from `bpf_types.h`.
*/
TEST_F(MemEventsListenerTest, register_event_valid_values) {
for (unsigned int i = 0; i < NR_MEM_EVENTS; i++)
ASSERT_TRUE(memevent_listener.registerEvent(i)) << "Failed to register event: " << i;
}
/*
* `listen()` should return false when no events have been registered.
*/
TEST_F(MemEventsListenerTest, listen_no_registered_events) {
ASSERT_FALSE(memevent_listener.listen());
}
/*
* Validate `deregisterEvent()` fails with values >= `NR_MEM_EVENTS`.
* Exactly like `register_event_invalid_values` test.
*/
TEST_F(MemEventsListenerTest, deregister_event_invalid_values) {
ASSERT_FALSE(memevent_listener.deregisterEvent(NR_MEM_EVENTS));
ASSERT_FALSE(memevent_listener.deregisterEvent(NR_MEM_EVENTS + 1));
ASSERT_FALSE(memevent_listener.deregisterEvent(-1));
}
/*
* Validate that `deregisterEvent()` always returns true when we try
* deregistering the same [valid] event/value.
*/
TEST_F(MemEventsListenerTest, deregister_repeated_event) {
const int event_type = MEM_EVENT_DIRECT_RECLAIM_BEGIN;
ASSERT_TRUE(memevent_listener.registerEvent(event_type));
ASSERT_TRUE(memevent_listener.deregisterEvent(event_type));
ASSERT_TRUE(memevent_listener.deregisterEvent(event_type));
}
/*
* Verify that the `deregisterEvent()` will return true
* when we deregister a non-registered, valid, event.
*/
TEST_F(MemEventsListenerTest, deregister_unregistered_event) {
ASSERT_TRUE(memevent_listener.deregisterEvent(MEM_EVENT_DIRECT_RECLAIM_END));
}
/*
* Validate that the `deregisterAllEvents()` closes all the registered
* events.
*/
TEST_F(MemEventsListenerTest, deregister_all_events) {
ASSERT_TRUE(memevent_listener.registerEvent(MEM_EVENT_OOM_KILL));
ASSERT_TRUE(memevent_listener.registerEvent(MEM_EVENT_DIRECT_RECLAIM_BEGIN));
memevent_listener.deregisterAllEvents();
ASSERT_FALSE(memevent_listener.listen())
<< "Expected to fail since we are not registered to any events";
}
/*
* Validating that `MEM_EVENT_BASE` is equal to `MEM_EVENT_OOM_KILL`.
*/
TEST_F(MemEventsListenerTest, base_and_oom_events_are_equal) {
ASSERT_EQ(MEM_EVENT_OOM_KILL, MEM_EVENT_BASE)
<< "MEM_EVENT_BASE should be equal to MEM_EVENT_OOM_KILL";
}
/*
* Validate that `getRingBufferFd()` returns a valid file descriptor.
*/
TEST_F(MemEventsListenerTest, get_client_rb_fd) {
ASSERT_GE(memevent_listener.getRingBufferFd(), 0)
<< "Failed to get a valid bpf-rb file descriptor";
}
class MemEventsListenerBpf : public ::testing::Test {
private:
android::base::unique_fd mProgram;
void setUpProgram(unsigned int event_type) {
ASSERT_TRUE(event_type < NR_MEM_EVENTS) << "Invalid event type provided";
int bpf_fd = android::bpf::retrieveProgram(testBpfSkfilterProgPaths[event_type].c_str());
ASSERT_NE(bpf_fd, -1) << "Retrieve bpf program failed with prog path: "
<< testBpfSkfilterProgPaths[event_type];
mProgram.reset(bpf_fd);
ASSERT_GE(mProgram.get(), 0)
<< testBpfSkfilterProgPaths[event_type] << " was either not found or inaccessible.";
}
/*
* Always call this after `setUpProgram()`, in order to make sure that the
* correct `mProgram` was set.
*/
void RunProgram(unsigned int event_type) {
errno = 0;
switch (event_type) {
case MEM_EVENT_OOM_KILL:
struct mark_victim_args mark_victim_fake_args;
android::bpf::runProgram(mProgram, &mark_victim_fake_args,
sizeof(mark_victim_fake_args));
break;
case MEM_EVENT_DIRECT_RECLAIM_BEGIN:
struct direct_reclaim_begin_args dr_begin_fake_args;
android::bpf::runProgram(mProgram, &dr_begin_fake_args, sizeof(dr_begin_fake_args));
break;
case MEM_EVENT_DIRECT_RECLAIM_END:
struct direct_reclaim_end_args dr_end_fake_args;
android::bpf::runProgram(mProgram, &dr_end_fake_args, sizeof(dr_end_fake_args));
break;
case MEM_EVENT_KSWAPD_WAKE:
struct kswapd_wake_args kswapd_wake_fake_args;
android::bpf::runProgram(mProgram, &kswapd_wake_fake_args,
sizeof(kswapd_wake_fake_args));
break;
case MEM_EVENT_KSWAPD_SLEEP:
struct kswapd_sleep_args kswapd_sleep_fake_args;
android::bpf::runProgram(mProgram, &kswapd_sleep_fake_args,
sizeof(kswapd_sleep_fake_args));
break;
default:
FAIL() << "Invalid event type provided";
}
EXPECT_EQ(errno, 0);
}
protected:
MemEventListener mem_listener = MemEventListener(mem_test_client);
static void SetUpTestSuite() {
if (!isAtLeastKernelVersion(5, 8, 0)) {
GTEST_SKIP() << "BPF ring buffers not supported below 5.8";
}
}
void SetUp() override {
ASSERT_TRUE(mem_listener.ok()) << "Listener failed to initialize bpf rb manager";
}
void TearDown() override { mem_listener.deregisterAllEvents(); }
/*
* Helper function to insert mocked data into the testing [bpf] ring buffer.
* This will trigger the `listen()` if its registered to the given `event_type`.
*/
void setMockDataInRb(mem_event_type_t event_type) {
setUpProgram(event_type);
RunProgram(event_type);
}
/*
* Test that the `listen()` returns true.
* We setup some mocked event data into the testing [bpf] ring-buffer, to make
* sure the `listen()` is triggered.
*/
void testListenEvent(unsigned int event_type) {
ASSERT_TRUE(event_type < NR_MEM_EVENTS) << "Invalid event type provided";
setMockDataInRb(event_type);
ASSERT_TRUE(mem_listener.listen(5000)); // 5 second timeout
}
void validateMockedEvent(const mem_event_t& mem_event) {
/*
* These values are set inside the testing prog `memevents_test.h`,
* they can't be passed from the test to the bpf-prog.
*/
switch (mem_event.type) {
case MEM_EVENT_OOM_KILL:
ASSERT_EQ(mem_event.event_data.oom_kill.pid,
mocked_oom_event.event_data.oom_kill.pid)
<< "MEM_EVENT_OOM_KILL: Didn't receive expected PID";
ASSERT_EQ(mem_event.event_data.oom_kill.uid,
mocked_oom_event.event_data.oom_kill.uid)
<< "MEM_EVENT_OOM_KILL: Didn't receive expected UID";
ASSERT_EQ(mem_event.event_data.oom_kill.oom_score_adj,
mocked_oom_event.event_data.oom_kill.oom_score_adj)
<< "MEM_EVENT_OOM_KILL: Didn't receive expected OOM score";
ASSERT_EQ(strcmp(mem_event.event_data.oom_kill.process_name,
mocked_oom_event.event_data.oom_kill.process_name),
0)
<< "MEM_EVENT_OOM_KILL: Didn't receive expected process name";
ASSERT_EQ(mem_event.event_data.oom_kill.timestamp_ms,
mocked_oom_event.event_data.oom_kill.timestamp_ms)
<< "MEM_EVENT_OOM_KILL: Didn't receive expected timestamp";
ASSERT_EQ(mem_event.event_data.oom_kill.total_vm_kb,
mocked_oom_event.event_data.oom_kill.total_vm_kb)
<< "MEM_EVENT_OOM_KILL: Didn't receive expected total vm";
ASSERT_EQ(mem_event.event_data.oom_kill.anon_rss_kb,
mocked_oom_event.event_data.oom_kill.anon_rss_kb)
<< "MEM_EVENT_OOM_KILL: Didn't receive expected anon rss";
ASSERT_EQ(mem_event.event_data.oom_kill.file_rss_kb,
mocked_oom_event.event_data.oom_kill.file_rss_kb)
<< "MEM_EVENT_OOM_KILL: Didn't receive expected file rss";
ASSERT_EQ(mem_event.event_data.oom_kill.shmem_rss_kb,
mocked_oom_event.event_data.oom_kill.shmem_rss_kb)
<< "MEM_EVENT_OOM_KILL: Didn't receive expected shmem rss";
ASSERT_EQ(mem_event.event_data.oom_kill.pgtables_kb,
mocked_oom_event.event_data.oom_kill.pgtables_kb)
<< "MEM_EVENT_OOM_KILL: Didn't receive expected pgtables";
break;
case MEM_EVENT_DIRECT_RECLAIM_BEGIN:
/* TP doesn't contain any data to mock */
break;
case MEM_EVENT_DIRECT_RECLAIM_END:
/* TP doesn't contain any data to mock */
break;
case MEM_EVENT_KSWAPD_WAKE:
ASSERT_EQ(mem_event.event_data.kswapd_wake.node_id,
mocked_kswapd_wake_event.event_data.kswapd_wake.node_id)
<< "MEM_EVENT_KSWAPD_WAKE: Didn't receive expected node id";
ASSERT_EQ(mem_event.event_data.kswapd_wake.zone_id,
mocked_kswapd_wake_event.event_data.kswapd_wake.zone_id)
<< "MEM_EVENT_KSWAPD_WAKE: Didn't receive expected zone id";
ASSERT_EQ(mem_event.event_data.kswapd_wake.alloc_order,
mocked_kswapd_wake_event.event_data.kswapd_wake.alloc_order)
<< "MEM_EVENT_KSWAPD_WAKE: Didn't receive expected alloc_order";
break;
case MEM_EVENT_KSWAPD_SLEEP:
ASSERT_EQ(mem_event.event_data.kswapd_sleep.node_id,
mocked_kswapd_sleep_event.event_data.kswapd_sleep.node_id)
<< "MEM_EVENT_KSWAPD_SLEEP: Didn't receive expected node id";
break;
}
}
};
/*
* Validate that `listen()` is triggered when we the bpf-rb receives
* a OOM event.
*/
TEST_F(MemEventsListenerBpf, listener_bpf_oom_kill) {
const mem_event_type_t event_type = MEM_EVENT_OOM_KILL;
ASSERT_TRUE(mem_listener.registerEvent(event_type));
testListenEvent(event_type);
std::vector<mem_event_t> mem_events;
ASSERT_TRUE(mem_listener.getMemEvents(mem_events)) << "Failed fetching events";
ASSERT_FALSE(mem_events.empty()) << "Expected for mem_events to have at least 1 mocked event";
ASSERT_EQ(mem_events[0].type, event_type) << "Didn't receive a OOM event";
validateMockedEvent(mem_events[0]);
}
/*
* Validate that `listen()` is triggered when we the bpf-rb receives
* a direct reclain start event.
*/
TEST_F(MemEventsListenerBpf, listener_bpf_direct_reclaim_begin) {
const mem_event_type_t event_type = MEM_EVENT_DIRECT_RECLAIM_BEGIN;
ASSERT_TRUE(mem_listener.registerEvent(event_type));
testListenEvent(event_type);
std::vector<mem_event_t> mem_events;
ASSERT_TRUE(mem_listener.getMemEvents(mem_events)) << "Failed fetching events";
ASSERT_FALSE(mem_events.empty()) << "Expected for mem_events to have at least 1 mocked event";
ASSERT_EQ(mem_events[0].type, event_type) << "Didn't receive a direct reclaim begin event";
validateMockedEvent(mem_events[0]);
}
/*
* Validate that `listen()` is triggered when we the bpf-rb receives
* a direct reclain end event.
*/
TEST_F(MemEventsListenerBpf, listener_bpf_direct_reclaim_end) {
const mem_event_type_t event_type = MEM_EVENT_DIRECT_RECLAIM_END;
ASSERT_TRUE(mem_listener.registerEvent(event_type));
testListenEvent(event_type);
std::vector<mem_event_t> mem_events;
ASSERT_TRUE(mem_listener.getMemEvents(mem_events)) << "Failed fetching events";
ASSERT_FALSE(mem_events.empty()) << "Expected for mem_events to have at least 1 mocked event";
ASSERT_EQ(mem_events[0].type, event_type) << "Didn't receive a direct reclaim end event";
validateMockedEvent(mem_events[0]);
}
TEST_F(MemEventsListenerBpf, listener_bpf_kswapd_wake) {
const mem_event_type_t event_type = MEM_EVENT_KSWAPD_WAKE;
ASSERT_TRUE(mem_listener.registerEvent(event_type));
testListenEvent(event_type);
std::vector<mem_event_t> mem_events;
ASSERT_TRUE(mem_listener.getMemEvents(mem_events)) << "Failed fetching events";
ASSERT_FALSE(mem_events.empty()) << "Expected for mem_events to have at least 1 mocked event";
ASSERT_EQ(mem_events[0].type, event_type) << "Didn't receive a kswapd wake event";
validateMockedEvent(mem_events[0]);
}
TEST_F(MemEventsListenerBpf, listener_bpf_kswapd_sleep) {
const mem_event_type_t event_type = MEM_EVENT_KSWAPD_SLEEP;
ASSERT_TRUE(mem_listener.registerEvent(event_type));
testListenEvent(event_type);
std::vector<mem_event_t> mem_events;
ASSERT_TRUE(mem_listener.getMemEvents(mem_events)) << "Failed fetching events";
ASSERT_FALSE(mem_events.empty()) << "Expected for mem_events to have at least 1 mocked event";
ASSERT_EQ(mem_events[0].type, event_type) << "Didn't receive a kswapd sleep event";
validateMockedEvent(mem_events[0]);
}
/*
* `listen()` should timeout, and return false, when a memory event that
* we are not registered for is triggered.
*/
TEST_F(MemEventsListenerBpf, no_register_events_listen_fails) {
const mem_event_type_t event_type = MEM_EVENT_DIRECT_RECLAIM_END;
setMockDataInRb(event_type);
ASSERT_FALSE(mem_listener.listen(5000)); // 5 second timeout
}
/*
* `getMemEvents()` should return an empty list, when a memory event that
* we are not registered for, is triggered.
*/
TEST_F(MemEventsListenerBpf, getMemEvents_no_register_events) {
const mem_event_type_t event_type = MEM_EVENT_OOM_KILL;
setMockDataInRb(event_type);
std::vector<mem_event_t> mem_events;
ASSERT_TRUE(mem_listener.getMemEvents(mem_events)) << "Failed fetching events";
ASSERT_TRUE(mem_events.empty());
}
/*
* Verify that the listener receives a notification when:
* 1. We start listening
* 2. Memory event is added in the bpf ring-buffer
* 3. Listening is notified of the new event.
*/
TEST_F(MemEventsListenerBpf, listen_then_create_event) {
const mem_event_type_t event_type = MEM_EVENT_DIRECT_RECLAIM_BEGIN;
std::mutex mtx;
std::condition_variable cv;
bool didReceiveEvent = false;
ASSERT_TRUE(mem_listener.registerEvent(event_type));
std::thread t([&] {
bool listen_result = mem_listener.listen(10000);
std::lock_guard lk(mtx);
didReceiveEvent = listen_result;
cv.notify_one();
});
setMockDataInRb(event_type);
std::unique_lock lk(mtx);
cv.wait_for(lk, std::chrono::seconds(10), [&] { return didReceiveEvent; });
ASSERT_TRUE(didReceiveEvent) << "Listen never received a memory event notification";
t.join();
}
/*
* Similarly to `listen_then_create_event`, but instead of using
* `listen()`, we want to poll from `getRingBufferFd()` value.
*/
TEST_F(MemEventsListenerBpf, getRb_poll_and_create_event) {
const mem_event_type_t event_type = MEM_EVENT_DIRECT_RECLAIM_BEGIN;
std::mutex mtx;
std::condition_variable cv;
bool didReceiveEvent = false;
ASSERT_TRUE(mem_listener.registerEvent(event_type));
int rb_fd = mem_listener.getRingBufferFd();
ASSERT_GE(rb_fd, 0) << "Received invalid file descriptor";
std::thread t([&] {
struct pollfd pfd = {
.fd = rb_fd,
.events = POLLIN,
};
int poll_result = poll(&pfd, 1, 10000);
std::lock_guard lk(mtx);
didReceiveEvent = poll_result > 0;
cv.notify_one();
});
setMockDataInRb(event_type);
std::unique_lock lk(mtx);
cv.wait_for(lk, std::chrono::seconds(10), [&] { return didReceiveEvent; });
ASSERT_TRUE(didReceiveEvent) << "Poll never received a memory event notification";
t.join();
}
class MemoryPressureTest : public ::testing::Test {
public:
static void SetUpTestSuite() {
if (!isAtLeastKernelVersion(5, 8, 0))
GTEST_SKIP() << "BPF ring buffers not supported below 5.8";
if (!std::filesystem::exists(sysrq_trigger_path))
GTEST_SKIP() << "sysrq-trigger is required to wake up the OOM killer";
ASSERT_TRUE(std::filesystem::exists(MEM_EVENTS_TEST_OOM_MARK_VICTIM_TP))
<< "Failed to find test bpf program: " << MEM_EVENTS_TEST_OOM_MARK_VICTIM_TP;
}
protected:
MemEventListener mem_listener = MemEventListener(mem_test_client, true);
void SetUp() override {
ASSERT_TRUE(mem_listener.ok()) << "listener failed to initialize bpf ring buffer manager";
}
void TearDown() override { mem_listener.deregisterAllEvents(); }
/**
* Helper function that will force the OOM killer to claim a [random]
* victim. Note that there is no deterministic way to ensure what process
* will be claimed by the OOM killer.
*
* We utilize [sysrq]
* (https://www.kernel.org/doc/html/v4.10/admin-guide/sysrq.html)
* to help us attempt to wake up the out-of-memory killer.
*
* @return true if we were able to trigger an OOM event, false otherwise.
*/
bool triggerOom() {
const std::filesystem::path process_oom_path = "proc/self/oom_score_adj";
// Make sure that we don't kill the parent process
if (!android::base::WriteStringToFile("-999", process_oom_path)) {
LOG(ERROR) << "Failed writing oom score adj for parent process";
return false;
}
int pid = fork();
if (pid < 0) {
LOG(ERROR) << "Failed to fork";
return false;
}
if (pid == 0) {
/*
* We want to make sure that the OOM killer claims our child
* process, this way we ensure we don't kill anything critical
* (including this test).
*/
if (!android::base::WriteStringToFile("1000", process_oom_path)) {
LOG(ERROR) << "Failed writing oom score adj for child process";
return false;
}
struct sysinfo info;
if (sysinfo(&info) != 0) {
LOG(ERROR) << "Failed to get sysinfo";
return false;
}
size_t length = info.freeram / 2;
// Allocate memory
void* addr =
mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
if (addr == MAP_FAILED) {
LOG(ERROR) << "Failed creating mmap";
return false;
}
// Fault pages
srand(67);
for (int i = 0; i < length; i += page_size) memset((char*)addr + i, (char)rand(), 1);
// Use sysrq-trigger to attempt waking up the OOM killer
if (!android::base::WriteStringToFile("f", sysrq_trigger_path)) {
LOG(ERROR) << "Failed calling sysrq to trigger OOM killer";
return false;
}
sleep(10); // Give some time in for sysrq to wake up the OOM killer
} else {
/*
* Wait for child process to finish, this will prevent scenario where the `listen()`
* is called by the parent, but the child hasn't even been scheduled to run yet.
*/
wait(NULL);
if (!mem_listener.listen(2000)) {
LOG(ERROR) << "Failed to receive a memory event";
return false;
}
}
return true;
}
/*
* This wrapper function exists to facilitate the use of ASSERT, with
* non-void helper functions, that want to use `ReadFileToString()`.
* We can only assert on void functions.
*/
void fileToString(const std::string& file_path, std::string* content) {
ASSERT_TRUE(android::base::ReadFileToString(file_path, content))
<< "Failed to read file: " << file_path;
}
/*
* Check if the current device supports the new oom/mark_victim tracepoints.
* The original oom/mark_victim tracepoint only supports the `pid` field, while
* the newer version supports: pid, uid, comm, oom score, pgtables, and rss stats.
*/
bool isUpdatedMarkVictimTpSupported() {
const std::string path_mark_victim_format =
"/sys/kernel/tracing/events/oom/mark_victim/format";
std::string mark_victim_format_content;
fileToString(path_mark_victim_format, &mark_victim_format_content);
/*
* Check if the device is running the with latest mark_victim fields:
* total_vm, anon_rss, file_rss, shmem_rss, uid, pgtables.
*/
return (mark_victim_format_content.find("total_vm") != std::string::npos) &&
(mark_victim_format_content.find("anon_rss") != std::string::npos) &&
(mark_victim_format_content.find("file_rss") != std::string::npos) &&
(mark_victim_format_content.find("shmem_rss") != std::string::npos) &&
(mark_victim_format_content.find("uid") != std::string::npos) &&
(mark_victim_format_content.find("pgtables") != std::string::npos);
}
};
/**
* End-to-end test for listening, and consuming, out-of-memory (OOM) events.
*
* We don't perform a listen here since the `triggerOom()` already does
* that for us.
*/
TEST_F(MemoryPressureTest, oom_e2e_flow) {
if (!isUpdatedMarkVictimTpSupported())
GTEST_SKIP() << "New oom/mark_victim fields not supported";
ASSERT_TRUE(mem_listener.registerEvent(MEM_EVENT_OOM_KILL))
<< "Failed registering OOM events as an event of interest";
ASSERT_TRUE(triggerOom()) << "Failed to trigger OOM killer";
std::vector<mem_event_t> oom_events;
ASSERT_TRUE(mem_listener.getMemEvents(oom_events)) << "Failed to fetch memory oom events";
ASSERT_FALSE(oom_events.empty()) << "We expect at least 1 OOM event";
}
/*
* Verify that we can register to an event after deregistering from it.
*/
TEST_F(MemoryPressureTest, register_after_deregister_event) {
if (!isUpdatedMarkVictimTpSupported())
GTEST_SKIP() << "New oom/mark_victim fields not supported";
ASSERT_TRUE(mem_listener.registerEvent(MEM_EVENT_OOM_KILL))
<< "Failed registering OOM events as an event of interest";
ASSERT_TRUE(mem_listener.deregisterEvent(MEM_EVENT_OOM_KILL))
<< "Failed deregistering OOM events";
ASSERT_TRUE(mem_listener.registerEvent(MEM_EVENT_OOM_KILL))
<< "Failed to register for OOM events after deregister it";
}
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
::android::base::InitLogging(argv, android::base::StderrLogger);
return RUN_ALL_TESTS();
}