Quelle  set_syscall_info.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (c) 2018-2025 Dmitry V. Levin <ldv@strace.io>
 * All rights reserved.
 *
 * Check whether PTRACE_SET_SYSCALL_INFO semantics implemented in the kernel
 * matches userspace expectations.
 */

#include "../kselftest_harness.h"
#include <err.h>
#include <fcntl.h>
#include <signal.h>
#include <asm/unistd.h>
#include <linux/types.h>
#include <linux/ptrace.h>

#if defined(_MIPS_SIM) && _MIPS_SIM == _MIPS_SIM_NABI32
/*
 * MIPS N32 is the only architecture where __kernel_ulong_t
 * does not match the bitness of syscall arguments.
 */
typedef unsigned long long kernel_ulong_t;
#else
typedef __kernel_ulong_t kernel_ulong_t;
#endif

struct si_entry {
 int nr;
 kernel_ulong_t args[6];
};
struct si_exit {
 unsigned int is_error;
 int rval;
};

static unsigned int ptrace_stop;
static pid_t tracee_pid;

static int
kill_tracee(pid_t pid)
{
 if (!pid)
  return 0;

 int saved_errno = errno;

 int rc = kill(pid, SIGKILL);

 errno = saved_errno;
 return rc;
}

static long
sys_ptrace(int request, pid_t pid, unsigned long addr, unsigned long data)
{
 return syscall(__NR_ptrace, request, pid, addr, data);
}

#define LOG_KILL_TRACEE(fmt, ...)    \
 do {       \
  kill_tracee(tracee_pid);   \
  TH_LOG("wait #%d: " fmt,   \
         ptrace_stop, ##__VA_ARGS__);  \
 } while (0)

static void
check_psi_entry(struct __test_metadata *_metadata,
  const struct ptrace_syscall_info *info,
  const struct si_entry *exp_entry,
  const char *text)
{
 unsigned int i;
 int exp_nr = exp_entry->nr;
#if defined __s390__ || defined __s390x__
 /* s390 is the only architecture that has 16-bit syscall numbers */
 exp_nr &= 0xffff;
#endif

 ASSERT_EQ(PTRACE_SYSCALL_INFO_ENTRY, info->op) {
  LOG_KILL_TRACEE("%s: entry stop mismatch", text);
 }
 ASSERT_TRUE(info->arch) {
  LOG_KILL_TRACEE("%s: entry stop mismatch", text);
 }
 ASSERT_TRUE(info->instruction_pointer) {
  LOG_KILL_TRACEE("%s: entry stop mismatch", text);
 }
 ASSERT_TRUE(info->stack_pointer) {
  LOG_KILL_TRACEE("%s: entry stop mismatch", text);
 }
 ASSERT_EQ(exp_nr, info->entry.nr) {
  LOG_KILL_TRACEE("%s: syscall nr mismatch", text);
 }
 for (i = 0; i < ARRAY_SIZE(exp_entry->args); ++i) {
  ASSERT_EQ(exp_entry->args[i], info->entry.args[i]) {
   LOG_KILL_TRACEE("%s: syscall arg #%u mismatch",
     text, i);
  }
 }
}

static void
check_psi_exit(struct __test_metadata *_metadata,
        const struct ptrace_syscall_info *info,
        const struct si_exit *exp_exit,
        const char *text)
{
 ASSERT_EQ(PTRACE_SYSCALL_INFO_EXIT, info->op) {
  LOG_KILL_TRACEE("%s: exit stop mismatch", text);
 }
 ASSERT_TRUE(info->arch) {
  LOG_KILL_TRACEE("%s: exit stop mismatch", text);
 }
 ASSERT_TRUE(info->instruction_pointer) {
  LOG_KILL_TRACEE("%s: exit stop mismatch", text);
 }
 ASSERT_TRUE(info->stack_pointer) {
  LOG_KILL_TRACEE("%s: exit stop mismatch", text);
 }
 ASSERT_EQ(exp_exit->is_error, info->exit.is_error) {
  LOG_KILL_TRACEE("%s: exit stop mismatch", text);
 }
 ASSERT_EQ(exp_exit->rval, info->exit.rval) {
  LOG_KILL_TRACEE("%s: exit stop mismatch", text);
 }
}

TEST(set_syscall_info)
{
 const pid_t tracer_pid = getpid();
 const kernel_ulong_t dummy[] = {
  (kernel_ulong_t) 0xdad0bef0bad0fed0ULL,
  (kernel_ulong_t) 0xdad1bef1bad1fed1ULL,
  (kernel_ulong_t) 0xdad2bef2bad2fed2ULL,
  (kernel_ulong_t) 0xdad3bef3bad3fed3ULL,
  (kernel_ulong_t) 0xdad4bef4bad4fed4ULL,
  (kernel_ulong_t) 0xdad5bef5bad5fed5ULL,
 };
 int splice_in[2], splice_out[2];

 ASSERT_EQ(0, pipe(splice_in));
 ASSERT_EQ(0, pipe(splice_out));
 ASSERT_EQ(sizeof(dummy), write(splice_in[1], dummy, sizeof(dummy)));

 const struct {
  struct si_entry entry[2];
  struct si_exit exit[2];
 } si[] = {
  /* change scno, keep non-error rval */
  {
   {
    {
     __NR_gettid,
     {
      dummy[0], dummy[1], dummy[2],
      dummy[3], dummy[4], dummy[5]
     }
    }, {
     __NR_getppid,
     {
      dummy[0], dummy[1], dummy[2],
      dummy[3], dummy[4], dummy[5]
     }
    }
   }, {
    { 0, tracer_pid }, { 0, tracer_pid }
   }
  },

  /* set scno to -1, keep error rval */
  {
   {
    {
     __NR_chdir,
     {
      (uintptr_t) ".",
      dummy[1], dummy[2],
      dummy[3], dummy[4], dummy[5]
     }
    }, {
     -1,
     {
      (uintptr_t) ".",
      dummy[1], dummy[2],
      dummy[3], dummy[4], dummy[5]
     }
    }
   }, {
    { 1, -ENOSYS }, { 1, -ENOSYS }
   }
  },

  /* keep scno, change non-error rval */
  {
   {
    {
     __NR_getppid,
     {
      dummy[0], dummy[1], dummy[2],
      dummy[3], dummy[4], dummy[5]
     }
    }, {
     __NR_getppid,
     {
      dummy[0], dummy[1], dummy[2],
      dummy[3], dummy[4], dummy[5]
     }
    }
   }, {
    { 0, tracer_pid }, { 0, tracer_pid + 1 }
   }
  },

  /* change arg1, keep non-error rval */
  {
   {
    {
     __NR_chdir,
     {
      (uintptr_t) "",
      dummy[1], dummy[2],
      dummy[3], dummy[4], dummy[5]
     }
    }, {
     __NR_chdir,
     {
      (uintptr_t) ".",
      dummy[1], dummy[2],
      dummy[3], dummy[4], dummy[5]
     }
    }
   }, {
    { 0, 0 }, { 0, 0 }
   }
  },

  /* set scno to -1, change error rval to non-error */
  {
   {
    {
     __NR_gettid,
     {
      dummy[0], dummy[1], dummy[2],
      dummy[3], dummy[4], dummy[5]
     }
    }, {
     -1,
     {
      dummy[0], dummy[1], dummy[2],
      dummy[3], dummy[4], dummy[5]
     }
    }
   }, {
    { 1, -ENOSYS }, { 0, tracer_pid }
   }
  },

  /* change scno, change non-error rval to error */
  {
   {
    {
     __NR_chdir,
     {
      dummy[0], dummy[1], dummy[2],
      dummy[3], dummy[4], dummy[5]
     }
    }, {
     __NR_getppid,
     {
      dummy[0], dummy[1], dummy[2],
      dummy[3], dummy[4], dummy[5]
     }
    }
   }, {
    { 0, tracer_pid }, { 1, -EISDIR }
   }
  },

  /* change scno and all args, change non-error rval */
  {
   {
    {
     __NR_gettid,
     {
      dummy[0], dummy[1], dummy[2],
      dummy[3], dummy[4], dummy[5]
     }
    }, {
     __NR_splice,
     {
      splice_in[0], 0, splice_out[1], 0,
      sizeof(dummy), SPLICE_F_NONBLOCK
     }
    }
   }, {
    { 0, sizeof(dummy) }, { 0, sizeof(dummy) + 1 }
   }
  },

  /* change arg1, no exit stop */
  {
   {
    {
     __NR_exit_group,
     {
      dummy[0], dummy[1], dummy[2],
      dummy[3], dummy[4], dummy[5]
     }
    }, {
     __NR_exit_group,
     {
      0, dummy[1], dummy[2],
      dummy[3], dummy[4], dummy[5]
     }
    }
   }, {
    { 0, 0 }, { 0, 0 }
   }
  },
 };

 long rc;
 unsigned int i;

 tracee_pid = fork();

 ASSERT_LE(0, tracee_pid) {
  TH_LOG("fork: %m");
 }

 if (tracee_pid == 0) {
  /* get the pid before PTRACE_TRACEME */
  tracee_pid = getpid();
  ASSERT_EQ(0, sys_ptrace(PTRACE_TRACEME, 0, 0, 0)) {
   TH_LOG("PTRACE_TRACEME: %m");
  }
  ASSERT_EQ(0, kill(tracee_pid, SIGSTOP)) {
   /* cannot happen */
   TH_LOG("kill SIGSTOP: %m");
  }
  for (i = 0; i < ARRAY_SIZE(si); ++i) {
   rc = syscall(si[i].entry[0].nr,
         si[i].entry[0].args[0],
         si[i].entry[0].args[1],
         si[i].entry[0].args[2],
         si[i].entry[0].args[3],
         si[i].entry[0].args[4],
         si[i].entry[0].args[5]);
   if (si[i].exit[1].is_error) {
    if (rc != -1 || errno != -si[i].exit[1].rval)
     break;
   } else {
    if (rc != si[i].exit[1].rval)
     break;
   }
  }
  /*
 * Something went wrong, but in this state tracee
 * cannot reliably issue syscalls, so just crash.
 */
  *(volatile unsigned char *) (uintptr_t) i = 42;
  /* unreachable */
  _exit(i + 1);
 }

 for (ptrace_stop = 0; ; ++ptrace_stop) {
  struct ptrace_syscall_info info = {
   .op = 0xff /* invalid PTRACE_SYSCALL_INFO_* op */
  };
  const size_t size = sizeof(info);
  const int expected_entry_size =
   (void *) &info.entry.args[6] - (void *) &info;
  const int expected_exit_size =
   (void *) (&info.exit.is_error + 1) -
   (void *) &info;
  int status;

  ASSERT_EQ(tracee_pid, wait(&status)) {
   /* cannot happen */
   LOG_KILL_TRACEE("wait: %m");
  }
  if (WIFEXITED(status)) {
   tracee_pid = 0; /* the tracee is no more */
   ASSERT_EQ(0, WEXITSTATUS(status)) {
    LOG_KILL_TRACEE("unexpected exit status %u",
      WEXITSTATUS(status));
   }
   break;
  }
  ASSERT_FALSE(WIFSIGNALED(status)) {
   tracee_pid = 0; /* the tracee is no more */
   LOG_KILL_TRACEE("unexpected signal %u",
     WTERMSIG(status));
  }
  ASSERT_TRUE(WIFSTOPPED(status)) {
   /* cannot happen */
   LOG_KILL_TRACEE("unexpected wait status %#x", status);
  }

  ASSERT_LT(ptrace_stop, ARRAY_SIZE(si) * 2) {
   LOG_KILL_TRACEE("ptrace stop overflow");
  }

  switch (WSTOPSIG(status)) {
  case SIGSTOP:
   ASSERT_EQ(0, ptrace_stop) {
    LOG_KILL_TRACEE("unexpected signal stop");
   }
   ASSERT_EQ(0, sys_ptrace(PTRACE_SETOPTIONS, tracee_pid,
      0, PTRACE_O_TRACESYSGOOD)) {
    LOG_KILL_TRACEE("PTRACE_SETOPTIONS: %m");
   }
   break;

  case SIGTRAP | 0x80:
   ASSERT_LT(0, ptrace_stop) {
    LOG_KILL_TRACEE("unexpected syscall stop");
   }
   ASSERT_LT(0, (rc = sys_ptrace(PTRACE_GET_SYSCALL_INFO,
            tracee_pid, size,
            (uintptr_t) &info))) {
    LOG_KILL_TRACEE("PTRACE_GET_SYSCALL_INFO #1: %m");
   }
   if (ptrace_stop & 1) {
    /* entering syscall */
    const struct si_entry *exp_entry =
     &si[ptrace_stop / 2].entry[0];
    const struct si_entry *set_entry =
     &si[ptrace_stop / 2].entry[1];

    /* check ptrace_syscall_info before the changes */
    ASSERT_EQ(expected_entry_size, rc) {
     LOG_KILL_TRACEE("PTRACE_GET_SYSCALL_INFO #1"
       ": entry stop mismatch");
    }
    check_psi_entry(_metadata, &info, exp_entry,
      "PTRACE_GET_SYSCALL_INFO #1");

    /* apply the changes */
    info.entry.nr = set_entry->nr;
    for (i = 0; i < ARRAY_SIZE(set_entry->args); ++i)
     info.entry.args[i] = set_entry->args[i];
    ASSERT_EQ(0, sys_ptrace(PTRACE_SET_SYSCALL_INFO,
       tracee_pid, size,
       (uintptr_t) &info)) {
     LOG_KILL_TRACEE("PTRACE_SET_SYSCALL_INFO: %m");
    }

    /* check ptrace_syscall_info after the changes */
    memset(&info, 0, sizeof(info));
    info.op = 0xff;
    ASSERT_LT(0, (rc = sys_ptrace(PTRACE_GET_SYSCALL_INFO,
             tracee_pid, size,
             (uintptr_t) &info))) {
     LOG_KILL_TRACEE("PTRACE_GET_SYSCALL_INFO: %m");
    }
    ASSERT_EQ(expected_entry_size, rc) {
     LOG_KILL_TRACEE("PTRACE_GET_SYSCALL_INFO #2"
       ": entry stop mismatch");
    }
    check_psi_entry(_metadata, &info, set_entry,
      "PTRACE_GET_SYSCALL_INFO #2");
   } else {
    /* exiting syscall */
    const struct si_exit *exp_exit =
     &si[ptrace_stop / 2 - 1].exit[0];
    const struct si_exit *set_exit =
     &si[ptrace_stop / 2 - 1].exit[1];

    /* check ptrace_syscall_info before the changes */
    ASSERT_EQ(expected_exit_size, rc) {
     LOG_KILL_TRACEE("PTRACE_GET_SYSCALL_INFO #1"
       ": exit stop mismatch");
    }
    check_psi_exit(_metadata, &info, exp_exit,
      "PTRACE_GET_SYSCALL_INFO #1");

    /* apply the changes */
    info.exit.is_error = set_exit->is_error;
    info.exit.rval = set_exit->rval;
    ASSERT_EQ(0, sys_ptrace(PTRACE_SET_SYSCALL_INFO,
       tracee_pid, size,
       (uintptr_t) &info)) {
     LOG_KILL_TRACEE("PTRACE_SET_SYSCALL_INFO: %m");
    }

    /* check ptrace_syscall_info after the changes */
    memset(&info, 0, sizeof(info));
    info.op = 0xff;
    ASSERT_LT(0, (rc = sys_ptrace(PTRACE_GET_SYSCALL_INFO,
             tracee_pid, size,
             (uintptr_t) &info))) {
     LOG_KILL_TRACEE("PTRACE_GET_SYSCALL_INFO #2: %m");
    }
    ASSERT_EQ(expected_exit_size, rc) {
     LOG_KILL_TRACEE("PTRACE_GET_SYSCALL_INFO #2"
       ": exit stop mismatch");
    }
    check_psi_exit(_metadata, &info, set_exit,
      "PTRACE_GET_SYSCALL_INFO #2");
   }
   break;

  default:
   LOG_KILL_TRACEE("unexpected stop signal %u",
     WSTOPSIG(status));
   abort();
  }

  ASSERT_EQ(0, sys_ptrace(PTRACE_SYSCALL, tracee_pid, 0, 0)) {
   LOG_KILL_TRACEE("PTRACE_SYSCALL: %m");
  }
 }

 ASSERT_EQ(ptrace_stop, ARRAY_SIZE(si) * 2);
}

TEST_HARNESS_MAIN