Quelle  setup.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
#include <fcntl.h>
#include <pthread.h>
#include <sched.h>
#include <signal.h>
#include "aolib.h"

/*
 * Can't be included in the header: it defines static variables which
 * will be unique to every object. Let's include it only once here.
 */
#include "../../../kselftest.h"

/* Prevent overriding of one thread's output by another */
static pthread_mutex_t ksft_print_lock = PTHREAD_MUTEX_INITIALIZER;

void __test_msg(const char *buf)
{
 pthread_mutex_lock(&ksft_print_lock);
 ksft_print_msg("%s", buf);
 pthread_mutex_unlock(&ksft_print_lock);
}
void __test_ok(const char *buf)
{
 pthread_mutex_lock(&ksft_print_lock);
 ksft_test_result_pass("%s", buf);
 pthread_mutex_unlock(&ksft_print_lock);
}
void __test_fail(const char *buf)
{
 pthread_mutex_lock(&ksft_print_lock);
 ksft_test_result_fail("%s", buf);
 pthread_mutex_unlock(&ksft_print_lock);
}
void __test_xfail(const char *buf)
{
 pthread_mutex_lock(&ksft_print_lock);
 ksft_test_result_xfail("%s", buf);
 pthread_mutex_unlock(&ksft_print_lock);
}
void __test_error(const char *buf)
{
 pthread_mutex_lock(&ksft_print_lock);
 ksft_test_result_error("%s", buf);
 pthread_mutex_unlock(&ksft_print_lock);
}
void __test_skip(const char *buf)
{
 pthread_mutex_lock(&ksft_print_lock);
 ksft_test_result_skip("%s", buf);
 pthread_mutex_unlock(&ksft_print_lock);
}

static volatile int failed;
static volatile int skipped;

void test_failed(void)
{
 failed = 1;
}

static void test_exit(void)
{
 if (failed) {
  ksft_exit_fail();
 } else if (skipped) {
  /* ksft_exit_skip() is different from ksft_exit_*() */
  ksft_print_cnts();
  exit(KSFT_SKIP);
 } else {
  ksft_exit_pass();
 }
}

struct dlist_t {
 void (*destruct)(void);
 struct dlist_t *next;
};
static struct dlist_t *destructors_list;

void test_add_destructor(void (*d)(void))
{
 struct dlist_t *p;

 p = malloc(sizeof(struct dlist_t));
 if (p == NULL)
  test_error("malloc() failed");

 p->next = destructors_list;
 p->destruct = d;
 destructors_list = p;
}

static void test_destructor(void) __attribute__((destructor));
static void test_destructor(void)
{
 while (destructors_list) {
  struct dlist_t *p = destructors_list->next;

  destructors_list->destruct();
  free(destructors_list);
  destructors_list = p;
 }
 test_exit();
}

static void sig_int(int signo)
{
 test_error("Caught SIGINT - exiting");
}

int open_netns(void)
{
 const char *netns_path = "/proc/thread-self/ns/net";
 int fd;

 fd = open(netns_path, O_RDONLY);
 if (fd < 0)
  test_error("open(%s)", netns_path);
 return fd;
}

int unshare_open_netns(void)
{
 if (unshare(CLONE_NEWNET) != 0)
  test_error("unshare()");

 return open_netns();
}

void switch_ns(int fd)
{
 if (setns(fd, CLONE_NEWNET))
  test_error("setns()");
}

int switch_save_ns(int new_ns)
{
 int ret = open_netns();

 switch_ns(new_ns);
 return ret;
}

void switch_close_ns(int fd)
{
 if (setns(fd, CLONE_NEWNET))
  test_error("setns()");
 close(fd);
}

static int nsfd_outside = -1;
static int nsfd_parent = -1;
static int nsfd_child = -1;
const char veth_name[] = "ktst-veth";

static void init_namespaces(void)
{
 nsfd_outside = open_netns();
 nsfd_parent = unshare_open_netns();
 nsfd_child = unshare_open_netns();
}

static void link_init(const char *veth, int family, uint8_t prefix,
        union tcp_addr addr, union tcp_addr dest)
{
 if (link_set_up(veth))
  test_error("Failed to set link up");
 if (ip_addr_add(veth, family, addr, prefix))
  test_error("Failed to add ip address");
 if (ip_route_add(veth, family, addr, dest))
  test_error("Failed to add route");
}

static unsigned int nr_threads = 1;

static pthread_mutex_t sync_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t sync_cond = PTHREAD_COND_INITIALIZER;
static volatile unsigned int stage_threads[2];
static volatile unsigned int stage_nr;

/* synchronize all threads in the same stage */
void synchronize_threads(void)
{
 unsigned int q = stage_nr;

 pthread_mutex_lock(&sync_lock);
 stage_threads[q]++;
 if (stage_threads[q] == nr_threads) {
  stage_nr ^= 1;
  stage_threads[stage_nr] = 0;
  pthread_cond_signal(&sync_cond);
 }
 while (stage_threads[q] < nr_threads)
  pthread_cond_wait(&sync_cond, &sync_lock);
 pthread_mutex_unlock(&sync_lock);
}

__thread union tcp_addr this_ip_addr;
__thread union tcp_addr this_ip_dest;
int test_family;

struct new_pthread_arg {
 thread_fn func;
 union tcp_addr my_ip;
 union tcp_addr dest_ip;
};
static void *new_pthread_entry(void *arg)
{
 struct new_pthread_arg *p = arg;

 this_ip_addr = p->my_ip;
 this_ip_dest = p->dest_ip;
 p->func(NULL); /* shouldn't return */
 exit(KSFT_FAIL);
}

static void __test_skip_all(const char *msg)
{
 ksft_set_plan(1);
 ksft_print_header();
 skipped = 1;
 test_skip("%s", msg);
 exit(KSFT_SKIP);
}

void __test_init(unsigned int ntests, int family, unsigned int prefix,
   union tcp_addr addr1, union tcp_addr addr2,
   thread_fn peer1, thread_fn peer2)
{
 struct sigaction sa = {
  .sa_handler = sig_int,
  .sa_flags = SA_RESTART,
 };
 time_t seed = time(NULL);

 sigemptyset(&sa.sa_mask);
 if (sigaction(SIGINT, &sa, NULL))
  test_error("Can't set SIGINT handler");

 test_family = family;
 if (!kernel_config_has(KCONFIG_NET_NS))
  __test_skip_all(tests_skip_reason[KCONFIG_NET_NS]);
 if (!kernel_config_has(KCONFIG_VETH))
  __test_skip_all(tests_skip_reason[KCONFIG_VETH]);
 if (!kernel_config_has(KCONFIG_TCP_AO))
  __test_skip_all(tests_skip_reason[KCONFIG_TCP_AO]);

 ksft_set_plan(ntests);
 test_print("rand seed %u", (unsigned int)seed);
 srand(seed);

 ksft_print_header();
 init_namespaces();
 test_init_ftrace(nsfd_parent, nsfd_child);

 if (add_veth(veth_name, nsfd_parent, nsfd_child))
  test_error("Failed to add veth");

 switch_ns(nsfd_child);
 link_init(veth_name, family, prefix, addr2, addr1);
 if (peer2) {
  struct new_pthread_arg targ;
  pthread_t t;

  targ.my_ip = addr2;
  targ.dest_ip = addr1;
  targ.func = peer2;
  nr_threads++;
  if (pthread_create(&t, NULL, new_pthread_entry, &targ))
   test_error("Failed to create pthread");
 }
 switch_ns(nsfd_parent);
 link_init(veth_name, family, prefix, addr1, addr2);

 this_ip_addr = addr1;
 this_ip_dest = addr2;
 peer1(NULL);
 if (failed)
  exit(KSFT_FAIL);
 else
  exit(KSFT_PASS);
}

/* /proc/sys/net/core/optmem_max artifically limits the amount of memory
 * that can be allocated with sock_kmalloc() on each socket in the system.
 * It is not virtualized in v6.7, so it has to written outside test
 * namespaces. To be nice a test will revert optmem back to the old value.
 * Keeping it simple without any file lock, which means the tests that
 * need to set/increase optmem value shouldn't run in parallel.
 * Also, not re-entrant.
 * Since commit f5769faeec36 ("net: Namespace-ify sysctl_optmem_max")
 * it is per-namespace, keeping logic for non-virtualized optmem_max
 * for v6.7, which supports TCP-AO.
 */
static const char *optmem_file = "/proc/sys/net/core/optmem_max";
static size_t saved_optmem;
static int optmem_ns = -1;

static bool is_optmem_namespaced(void)
{
 if (optmem_ns == -1) {
  int old_ns = switch_save_ns(nsfd_child);

  optmem_ns = !access(optmem_file, F_OK);
  switch_close_ns(old_ns);
 }
 return !!optmem_ns;
}

size_t test_get_optmem(void)
{
 int old_ns = 0;
 FILE *foptmem;
 size_t ret;

 if (!is_optmem_namespaced())
  old_ns = switch_save_ns(nsfd_outside);
 foptmem = fopen(optmem_file, "r");
 if (!foptmem)
  test_error("failed to open %s", optmem_file);

 if (fscanf(foptmem, "%zu", &ret) != 1)
  test_error("can't read from %s", optmem_file);
 fclose(foptmem);
 if (!is_optmem_namespaced())
  switch_close_ns(old_ns);
 return ret;
}

static void __test_set_optmem(size_t new, size_t *old)
{
 int old_ns = 0;
 FILE *foptmem;

 if (old != NULL)
  *old = test_get_optmem();

 if (!is_optmem_namespaced())
  old_ns = switch_save_ns(nsfd_outside);
 foptmem = fopen(optmem_file, "w");
 if (!foptmem)
  test_error("failed to open %s", optmem_file);

 if (fprintf(foptmem, "%zu", new) <= 0)
  test_error("can't write %zu to %s", new, optmem_file);
 fclose(foptmem);
 if (!is_optmem_namespaced())
  switch_close_ns(old_ns);
}

static void test_revert_optmem(void)
{
 if (saved_optmem == 0)
  return;

 __test_set_optmem(saved_optmem, NULL);
}

void test_set_optmem(size_t value)
{
 if (saved_optmem == 0) {
  __test_set_optmem(value, &saved_optmem);
  test_add_destructor(test_revert_optmem);
 } else {
  __test_set_optmem(value, NULL);
 }
}