// SPDX-License-Identifier: GPL-2.0-only
/*
 * Basic VM_PFNMAP tests relying on mmap() of '/dev/mem'
 *
 * Copyright 2025, Red Hat, Inc.
 *
 * Author(s): David Hildenbrand <david@redhat.com>
 */
#define _GNU_SOURCE
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <ctype.h>
#include <fcntl.h>
#include <signal.h>
#include <setjmp.h>
#include <linux/mman.h>
#include <sys/mman.h>
#include <sys/wait.h>

#include "../kselftest_harness.h"
#include "vm_util.h"

static sigjmp_buf sigjmp_buf_env;

static void signal_handler(int sig)
{
 siglongjmp(sigjmp_buf_env, -EFAULT);
}

static int test_read_access(char *addr, size_t size, size_t pagesize)
{
 size_t offs;
 int ret;

 if (signal(SIGSEGV, signal_handler) == SIG_ERR)
  return -EINVAL;

 ret = sigsetjmp(sigjmp_buf_env, 1);
 if (!ret) {
  for (offs = 0; offs < size; offs += pagesize)
   /* Force a read that the compiler cannot optimize out. */
   *((volatile char *)(addr + offs));
 }
 if (signal(SIGSEGV, SIG_DFL) == SIG_ERR)
  return -EINVAL;

 return ret;
}

static int find_ram_target(off_t *phys_addr,
  unsigned long long pagesize)
{
 unsigned long long start, end;
 char line[80], *end_ptr;
 FILE *file;

 /* Search /proc/iomem for the first suitable "System RAM" range. */
 file = fopen("/proc/iomem", "r");
 if (!file)
  return -errno;

 while (fgets(line, sizeof(line), file)) {
  /* Ignore any child nodes. */
  if (!isalnum(line[0]))
   continue;

  if (!strstr(line, "System RAM\n"))
   continue;

  start = strtoull(line, &end_ptr, 16);
  /* Skip over the "-" */
  end_ptr++;
  /* Make end "exclusive". */
  end = strtoull(end_ptr, NULL, 16) + 1;

  /* Actual addresses are not exported */
  if (!start && !end)
   break;

  /* We need full pages. */
  start = (start + pagesize - 1) & ~(pagesize - 1);
  end &= ~(pagesize - 1);

  if (start != (off_t)start)
   break;

  /* We need two pages. */
  if (end > start + 2 * pagesize) {
   fclose(file);
   *phys_addr = start;
   return 0;
  }
 }
 return -ENOENT;
}

FIXTURE(pfnmap)
{
 off_t phys_addr;
 size_t pagesize;
 int dev_mem_fd;
 char *addr1;
 size_t size1;
 char *addr2;
 size_t size2;
};

FIXTURE_SETUP(pfnmap)
{
 self->pagesize = getpagesize();

 /* We'll require two physical pages throughout our tests ... */
 if (find_ram_target(&self->phys_addr, self->pagesize))
  SKIP(return, "Cannot find ram target in '/proc/iomem'\n");

 self->dev_mem_fd = open("/dev/mem", O_RDONLY);
 if (self->dev_mem_fd < 0)
  SKIP(return, "Cannot open '/dev/mem'\n");

 self->size1 = self->pagesize * 2;
 self->addr1 = mmap(NULL, self->size1, PROT_READ, MAP_SHARED,
      self->dev_mem_fd, self->phys_addr);
 if (self->addr1 == MAP_FAILED)
  SKIP(return, "Cannot mmap '/dev/mem'\n");

 /* ... and want to be able to read from them. */
 if (test_read_access(self->addr1, self->size1, self->pagesize))
  SKIP(return, "Cannot read-access mmap'ed '/dev/mem'\n");

 self->size2 = 0;
 self->addr2 = MAP_FAILED;
}

FIXTURE_TEARDOWN(pfnmap)
{
 if (self->addr2 != MAP_FAILED)
  munmap(self->addr2, self->size2);
 if (self->addr1 != MAP_FAILED)
  munmap(self->addr1, self->size1);
 if (self->dev_mem_fd >= 0)
  close(self->dev_mem_fd);
}

TEST_F(pfnmap, madvise_disallowed)
{
 int advices[] = {
  MADV_DONTNEED,
  MADV_DONTNEED_LOCKED,
  MADV_FREE,
  MADV_WIPEONFORK,
  MADV_COLD,
  MADV_PAGEOUT,
  MADV_POPULATE_READ,
  MADV_POPULATE_WRITE,
 };
 int i;

 /* All these advices must be rejected. */
 for (i = 0; i < ARRAY_SIZE(advices); i++) {
  EXPECT_LT(madvise(self->addr1, self->pagesize, advices[i]), 0);
  EXPECT_EQ(errno, EINVAL);
 }
}

TEST_F(pfnmap, munmap_split)
{
 /*
  * Unmap the first page. This munmap() call is not really expected to
  * fail, but we might be able to trigger other internal issues.
 */
 ASSERT_EQ(munmap(self->addr1, self->pagesize), 0);

 /*
  * Remap the first page while the second page is still mapped. This
  * makes sure that any PAT tracking on x86 will allow for mmap()'ing
  * a page again while some parts of the first mmap() are still
  * around.
 */
 self->size2 = self->pagesize;
 self->addr2 = mmap(NULL, self->pagesize, PROT_READ, MAP_SHARED,
      self->dev_mem_fd, self->phys_addr);
 ASSERT_NE(self->addr2, MAP_FAILED);
}

TEST_F(pfnmap, mremap_fixed)
{
 char *ret;

 /* Reserve a destination area. */
 self->size2 = self->size1;
 self->addr2 = mmap(NULL, self->size2, PROT_READ, MAP_ANON | MAP_PRIVATE,
      -1, 0);
 ASSERT_NE(self->addr2, MAP_FAILED);

 /* mremap() over our destination. */
 ret = mremap(self->addr1, self->size1, self->size2,
       MREMAP_FIXED | MREMAP_MAYMOVE, self->addr2);
 ASSERT_NE(ret, MAP_FAILED);
}

TEST_F(pfnmap, mremap_shrink)
{
 char *ret;

 /* Shrinking is expected to work. */
 ret = mremap(self->addr1, self->size1, self->size1 - self->pagesize, 0);
 ASSERT_NE(ret, MAP_FAILED);
}

TEST_F(pfnmap, mremap_expand)
{
 /*
  * Growing is not expected to work, and getting it right would
  * be challenging. So this test primarily serves as an early warning
  * that something that probably should never work suddenly works.
 */
 self->size2 = self->size1 + self->pagesize;
 self->addr2 = mremap(self->addr1, self->size1, self->size2, MREMAP_MAYMOVE);
 ASSERT_EQ(self->addr2, MAP_FAILED);
}

TEST_F(pfnmap, fork)
{
 pid_t pid;
 int ret;

 /* fork() a child and test if the child can access the pages. */
 pid = fork();
 ASSERT_GE(pid, 0);

 if (!pid) {
  EXPECT_EQ(test_read_access(self->addr1, self->size1,
        self->pagesize), 0);
  exit(0);
 }

 wait(&ret);
 if (WIFEXITED(ret))
  ret = WEXITSTATUS(ret);
 else
  ret = -EINVAL;
 ASSERT_EQ(ret, 0);
}

TEST_HARNESS_MAIN