Quelle  pidfd_fdinfo_test.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0

#define _GNU_SOURCE
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <linux/types.h>
#include <sched.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syscall.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <sys/mount.h>

#include "pidfd.h"
#include "../kselftest.h"

struct error {
 int  code;
 char msg[512];
};

static int error_set(struct error *err, int code, const char *fmt, ...)
{
 va_list args;
 int r;

 if (code == PIDFD_PASS || !err || err->code != PIDFD_PASS)
  return code;

 err->code = code;
 va_start(args, fmt);
 r = vsnprintf(err->msg, sizeof(err->msg), fmt, args);
 assert((size_t)r < sizeof(err->msg));
 va_end(args);

 return code;
}

static void error_report(struct error *err, const char *test_name)
{
 switch (err->code) {
 case PIDFD_ERROR:
  ksft_exit_fail_msg("%s test: Fatal: %s\n", test_name, err->msg);
  break;

 case PIDFD_FAIL:
  /* will be: not ok %d # error %s test: %s */
  ksft_test_result_error("%s test: %s\n", test_name, err->msg);
  break;

 case PIDFD_SKIP:
  /* will be: not ok %d # SKIP %s test: %s */
  ksft_test_result_skip("%s test: %s\n", test_name, err->msg);
  break;

 case PIDFD_XFAIL:
  ksft_test_result_pass("%s test: Expected failure: %s\n",
          test_name, err->msg);
  break;

 case PIDFD_PASS:
  ksft_test_result_pass("%s test: Passed\n", test_name);
  break;

 default:
  ksft_exit_fail_msg("%s test: Unknown code: %d %s\n",
       test_name, err->code, err->msg);
  break;
 }
}

static inline int error_check(struct error *err, const char *test_name)
{
 /* In case of error we bail out and terminate the test program */
 if (err->code == PIDFD_ERROR)
  error_report(err, test_name);

 return err->code;
}

#define CHILD_STACK_SIZE 8192

struct child {
 char *stack;
 pid_t pid;
 int   fd;
};

static struct child clone_newns(int (*fn)(void *), void *args,
    struct error *err)
{
 static int flags = CLONE_PIDFD | CLONE_NEWPID | CLONE_NEWNS | SIGCHLD;
 struct child ret;

 if (!(flags & CLONE_NEWUSER) && geteuid() != 0)
  flags |= CLONE_NEWUSER;

 ret.stack = mmap(NULL, CHILD_STACK_SIZE, PROT_READ | PROT_WRITE,
    MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
 if (ret.stack == MAP_FAILED) {
  error_set(err, -1, "mmap of stack failed (errno %d)", errno);
  return ret;
 }

#ifdef __ia64__
 ret.pid = __clone2(fn, ret.stack, CHILD_STACK_SIZE, flags, args, &ret.fd);
#else
 ret.pid = clone(fn, ret.stack + CHILD_STACK_SIZE, flags, args, &ret.fd);
#endif

 if (ret.pid < 0) {
  error_set(err, PIDFD_ERROR, "clone failed (ret %d, errno %d)",
     ret.fd, errno);
  return ret;
 }

 ksft_print_msg("New child: %d, fd: %d\n", ret.pid, ret.fd);

 return ret;
}

static inline void child_close(struct child *child)
{
 close(child->fd);
}

static inline int child_join(struct child *child, struct error *err)
{
 int r;

 r = wait_for_pid(child->pid);
 if (r < 0)
  error_set(err, PIDFD_ERROR, "waitpid failed (ret %d, errno %d)",
     r, errno);
 else if (r > 0)
  error_set(err, r, "child %d reported: %d", child->pid, r);

 if (munmap(child->stack, CHILD_STACK_SIZE)) {
  error_set(err, -1, "munmap of child stack failed (errno %d)", errno);
  r = -1;
 }

 ksft_print_msg("waitpid WEXITSTATUS=%d\n", r);
 return r;
}

static inline int child_join_close(struct child *child, struct error *err)
{
 child_close(child);
 return child_join(child, err);
}

static inline void trim_newline(char *str)
{
 char *pos = strrchr(str, '\n');

 if (pos)
  *pos = '\0';
}

static int verify_fdinfo(int pidfd, struct error *err, const char *prefix,
    size_t prefix_len, const char *expect, ...)
{
 char buffer[512] = {0, };
 char path[512] = {0, };
 va_list args;
 FILE *f;
 char *line = NULL;
 size_t n = 0;
 int found = 0;
 int r;

 va_start(args, expect);
 r = vsnprintf(buffer, sizeof(buffer), expect, args);
 assert((size_t)r < sizeof(buffer));
 va_end(args);

 snprintf(path, sizeof(path), "/proc/self/fdinfo/%d", pidfd);
 f = fopen(path, "re");
 if (!f)
  return error_set(err, PIDFD_ERROR, "fdinfo open failed for %d",
     pidfd);

 while (getline(&line, &n, f) != -1) {
  char *val;

  if (strncmp(line, prefix, prefix_len))
   continue;

  found = 1;

  val = line + prefix_len;
  r = strcmp(val, buffer);
  if (r != 0) {
   trim_newline(line);
   trim_newline(buffer);
   error_set(err, PIDFD_FAIL, "%s '%s' != '%s'",
      prefix, val, buffer);
  }
  break;
 }

 free(line);
 fclose(f);

 if (found == 0)
  return error_set(err, PIDFD_FAIL, "%s not found for fd %d",
     prefix, pidfd);

 return PIDFD_PASS;
}

static int child_fdinfo_nspid_test(void *args)
{
 struct error err;
 int pidfd;
 int r;

 /* if we got no fd for the sibling, we are done */
 if (!args)
  return PIDFD_PASS;

 /* verify that we can not resolve the pidfd for a process
 * in a sibling pid namespace, i.e. a pid namespace it is
 * not in our or a descended namespace
 */
 r = mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, 0);
 if (r < 0) {
  ksft_print_msg("Failed to remount / private\n");
  return PIDFD_ERROR;
 }

 (void)umount2("/proc", MNT_DETACH);
 r = mount("proc", "/proc", "proc", 0, NULL);
 if (r < 0) {
  ksft_print_msg("Failed to remount /proc\n");
  return PIDFD_ERROR;
 }

 pidfd = *(int *)args;
 r = verify_fdinfo(pidfd, &err, "NSpid:", 6, "\t0\n");

 if (r != PIDFD_PASS)
  ksft_print_msg("NSpid fdinfo check failed: %s\n", err.msg);

 return r;
}

static void test_pidfd_fdinfo_nspid(void)
{
 struct child a, b;
 struct error err = {0, };
 const char *test_name = "pidfd check for NSpid in fdinfo";

 /* Create a new child in a new pid and mount namespace */
 a = clone_newns(child_fdinfo_nspid_test, NULL, &err);
 error_check(&err, test_name);

 /* Pass the pidfd representing the first child to the
 * second child, which will be in a sibling pid namespace,
 * which means that the fdinfo NSpid entry for the pidfd
 * should only contain '0'.
 */
 b = clone_newns(child_fdinfo_nspid_test, &a.fd, &err);
 error_check(&err, test_name);

 /* The children will have pid 1 in the new pid namespace,
 * so the line must be 'NSPid:\t<pid>\t1'.
 */
 verify_fdinfo(a.fd, &err, "NSpid:", 6, "\t%d\t%d\n", a.pid, 1);
 verify_fdinfo(b.fd, &err, "NSpid:", 6, "\t%d\t%d\n", b.pid, 1);

 /* wait for the process, check the exit status and set
 * 'err' accordingly, if it is not already set.
 */
 child_join_close(&a, &err);
 child_join_close(&b, &err);

 error_report(&err, test_name);
}

static void test_pidfd_dead_fdinfo(void)
{
 struct child a;
 struct error err = {0, };
 const char *test_name = "pidfd check fdinfo for dead process";

 /* Create a new child in a new pid and mount namespace */
 a = clone_newns(child_fdinfo_nspid_test, NULL, &err);
 error_check(&err, test_name);
 child_join(&a, &err);

 verify_fdinfo(a.fd, &err, "Pid:", 4, "\t-1\n");
 verify_fdinfo(a.fd, &err, "NSpid:", 6, "\t-1\n");
 child_close(&a);
 error_report(&err, test_name);
}

int main(int argc, char **argv)
{
 ksft_print_header();
 ksft_set_plan(2);

 test_pidfd_fdinfo_nspid();
 test_pidfd_dead_fdinfo();

 ksft_exit_pass();
}