Quelle  hotplug.c   Sprache: C

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (c) 2024 Meta Platforms, Inc. and affiliates.
 * Copyright (c) 2024 David Vernet <dvernet@meta.com>
 */
#include <bpf/bpf.h>
#include <sched.h>
#include <scx/common.h>
#include <sys/wait.h>
#include <unistd.h>

#include "hotplug_test.h"
#include "hotplug.bpf.skel.h"
#include "scx_test.h"
#include "util.h"

const char *online_path = "/sys/devices/system/cpu/cpu1/online";

static bool is_cpu_online(void)
{
 return file_read_long(online_path) > 0;
}

static void toggle_online_status(bool online)
{
 long val = online ? 1 : 0;
 int ret;

 ret = file_write_long(online_path, val);
 if (ret != 0)
  fprintf(stderr, "Failed to bring CPU %s (%s)",
   online ? "online" : "offline", strerror(errno));
}

static enum scx_test_status setup(void **ctx)
{
 if (!is_cpu_online())
  return SCX_TEST_SKIP;

 return SCX_TEST_PASS;
}

static enum scx_test_status test_hotplug(bool onlining, bool cbs_defined)
{
 struct hotplug *skel;
 struct bpf_link *link;
 long kind, code;

 SCX_ASSERT(is_cpu_online());

 skel = hotplug__open();
 SCX_FAIL_IF(!skel, "Failed to open");
 SCX_ENUM_INIT(skel);
 SCX_FAIL_IF(hotplug__load(skel), "Failed to load skel");

 /* Testing the offline -> online path, so go offline before starting */
 if (onlining)
  toggle_online_status(0);

 if (cbs_defined) {
  kind = SCX_KIND_VAL(SCX_EXIT_UNREG_BPF);
  code = SCX_ECODE_VAL(SCX_ECODE_ACT_RESTART) | HOTPLUG_EXIT_RSN;
  if (onlining)
   code |= HOTPLUG_ONLINING;
 } else {
  kind = SCX_KIND_VAL(SCX_EXIT_UNREG_KERN);
  code = SCX_ECODE_VAL(SCX_ECODE_ACT_RESTART) |
         SCX_ECODE_VAL(SCX_ECODE_RSN_HOTPLUG);
 }

 if (cbs_defined)
  link = bpf_map__attach_struct_ops(skel->maps.hotplug_cb_ops);
 else
  link = bpf_map__attach_struct_ops(skel->maps.hotplug_nocb_ops);

 if (!link) {
  SCX_ERR("Failed to attach scheduler");
  hotplug__destroy(skel);
  return SCX_TEST_FAIL;
 }

 toggle_online_status(onlining ? 1 : 0);

 while (!UEI_EXITED(skel, uei))
  sched_yield();

 SCX_EQ(skel->data->uei.kind, kind);
 SCX_EQ(UEI_REPORT(skel, uei), code);

 if (!onlining)
  toggle_online_status(1);

 bpf_link__destroy(link);
 hotplug__destroy(skel);

 return SCX_TEST_PASS;
}

static enum scx_test_status test_hotplug_attach(void)
{
 struct hotplug *skel;
 struct bpf_link *link;
 enum scx_test_status status = SCX_TEST_PASS;
 long kind, code;

 SCX_ASSERT(is_cpu_online());
 SCX_ASSERT(scx_hotplug_seq() > 0);

 skel = SCX_OPS_OPEN(hotplug_nocb_ops, hotplug);
 SCX_ASSERT(skel);

 SCX_OPS_LOAD(skel, hotplug_nocb_ops, hotplug, uei);

 /*
 * Take the CPU offline to increment the global hotplug seq, which
 * should cause attach to fail due to us setting the hotplug seq above
 */
 toggle_online_status(0);
 link = bpf_map__attach_struct_ops(skel->maps.hotplug_nocb_ops);

 toggle_online_status(1);

 SCX_ASSERT(link);
 while (!UEI_EXITED(skel, uei))
  sched_yield();

 kind = SCX_KIND_VAL(SCX_EXIT_UNREG_KERN);
 code = SCX_ECODE_VAL(SCX_ECODE_ACT_RESTART) |
        SCX_ECODE_VAL(SCX_ECODE_RSN_HOTPLUG);
 SCX_EQ(skel->data->uei.kind, kind);
 SCX_EQ(UEI_REPORT(skel, uei), code);

 bpf_link__destroy(link);
 hotplug__destroy(skel);

 return status;
}

static enum scx_test_status run(void *ctx)
{

#define HP_TEST(__onlining, __cbs_defined) ({    \
 if (test_hotplug(__onlining, __cbs_defined) != SCX_TEST_PASS) \
  return SCX_TEST_FAIL;     \
})

 HP_TEST(true, true);
 HP_TEST(false, true);
 HP_TEST(true, false);
 HP_TEST(false, false);

#undef HP_TEST

 return test_hotplug_attach();
}

static void cleanup(void *ctx)
{
 toggle_online_status(1);
}

struct scx_test hotplug_test = {
 .name = "hotplug",
 .description = "Verify hotplug behavior",
 .setup = setup,
 .run = run,
 .cleanup = cleanup,
};
REGISTER_SCX_TEST(&hotplug_test)