tools/testing/selftests/pidfd/pidfd_getfd_test.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #define _GNU_SOURCE
   4 #include <errno.h>
   5 #include <fcntl.h>
   6 #include <limits.h>
   7 #include <linux/types.h>
   8 #include <sched.h>
   9 #include <signal.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <syscall.h>
  14 #include <sys/prctl.h>
  15 #include <sys/wait.h>
  16 #include <unistd.h>
  17 #include <sys/socket.h>
  18 #include <linux/kcmp.h>
  19
  20 #include "pidfd.h"
  21 #include "../kselftest_harness.h"
  22
  23 /*
  24  * UNKNOWN_FD is an fd number that should never exist in the child, as it is
  25  * used to check the negative case.
  26  */
  27 #define UNKNOWN_FD 111
  28 #define UID_NOBODY 65535
  29
  30 static int sys_kcmp(pid_t pid1, pid_t pid2, int type, unsigned long idx1,
  31                     unsigned long idx2)
  32 {
  33         return syscall(__NR_kcmp, pid1, pid2, type, idx1, idx2);
  34 }
  35
  36 static int __child(int sk, int memfd)
  37 {
  38         int ret;
  39         char buf;
  40
  41         /*
  42          * Ensure we don't leave around a bunch of orphaned children if our
  43          * tests fail.
  44          */
  45         ret = prctl(PR_SET_PDEATHSIG, SIGKILL);
  46         if (ret) {
  47                 fprintf(stderr, "%s: Child could not set DEATHSIG\n",
  48                         strerror(errno));
  49                 return -1;
  50         }
  51
  52         ret = send(sk, &memfd, sizeof(memfd), 0);
  53         if (ret != sizeof(memfd)) {
  54                 fprintf(stderr, "%s: Child failed to send fd number\n",
  55                         strerror(errno));
  56                 return -1;
  57         }
  58
  59         /*
  60          * The fixture setup is completed at this point. The tests will run.
  61          *
  62          * This blocking recv enables the parent to message the child.
  63          * Either we will read 'P' off of the sk, indicating that we need
  64          * to disable ptrace, or we will read a 0, indicating that the other
  65          * side has closed the sk. This occurs during fixture teardown time,
  66          * indicating that the child should exit.
  67          */
  68         while ((ret = recv(sk, &buf, sizeof(buf), 0)) > 0) {
  69                 if (buf == 'P') {
  70                         ret = prctl(PR_SET_DUMPABLE, 0);
  71                         if (ret < 0) {
  72                                 fprintf(stderr,
  73                                         "%s: Child failed to disable ptrace\n",
  74                                         strerror(errno));
  75                                 return -1;
  76                         }
  77                 } else {
  78                         fprintf(stderr, "Child received unknown command %c\n",
  79                                 buf);
  80                         return -1;
  81                 }
  82                 ret = send(sk, &buf, sizeof(buf), 0);
  83                 if (ret != 1) {
  84                         fprintf(stderr, "%s: Child failed to ack\n",
  85                                 strerror(errno));
  86                         return -1;
  87                 }
  88         }
  89         if (ret < 0) {
  90                 fprintf(stderr, "%s: Child failed to read from socket\n",
  91                         strerror(errno));
  92                 return -1;
  93         }
  94
  95         return 0;
  96 }
  97
  98 static int child(int sk)
  99 {
 100         int memfd, ret;
 101
 102         memfd = sys_memfd_create("test", 0);
 103         if (memfd < 0) {
 104                 fprintf(stderr, "%s: Child could not create memfd\n",
 105                         strerror(errno));
 106                 ret = -1;
 107         } else {
 108                 ret = __child(sk, memfd);
 109                 close(memfd);
 110         }
 111
 112         close(sk);
 113         return ret;
 114 }
 115
 116 FIXTURE(child)
 117 {
 118         /*
 119          * remote_fd is the number of the FD which we are trying to retrieve
 120          * from the child.
 121          */
 122         int remote_fd;
 123         /* pid points to the child which we are fetching FDs from */
 124         pid_t pid;
 125         /* pidfd is the pidfd of the child */
 126         int pidfd;
 127         /*
 128          * sk is our side of the socketpair used to communicate with the child.
 129          * When it is closed, the child will exit.
 130          */
 131         int sk;
 132 };
 133
 134 FIXTURE_SETUP(child)
 135 {
 136         int ret, sk_pair[2];
 137
 138         ASSERT_EQ(0, socketpair(PF_LOCAL, SOCK_SEQPACKET, 0, sk_pair)) {
 139                 TH_LOG("%s: failed to create socketpair", strerror(errno));
 140         }
 141         self->sk = sk_pair[0];
 142
 143         self->pid = fork();
 144         ASSERT_GE(self->pid, 0);
 145
 146         if (self->pid == 0) {
 147                 close(sk_pair[0]);
 148                 if (child(sk_pair[1]))
 149                         _exit(EXIT_FAILURE);
 150                 _exit(EXIT_SUCCESS);
 151         }
 152
 153         close(sk_pair[1]);
 154
 155         self->pidfd = sys_pidfd_open(self->pid, 0);
 156         ASSERT_GE(self->pidfd, 0);
 157
 158         /*
 159          * Wait for the child to complete setup. It'll send the remote memfd's
 160          * number when ready.
 161          */
 162         ret = recv(sk_pair[0], &self->remote_fd, sizeof(self->remote_fd), 0);
 163         ASSERT_EQ(sizeof(self->remote_fd), ret);
 164 }
 165
 166 FIXTURE_TEARDOWN(child)
 167 {
 168         EXPECT_EQ(0, close(self->pidfd));
 169         EXPECT_EQ(0, close(self->sk));
 170
 171         EXPECT_EQ(0, wait_for_pid(self->pid));
 172 }
 173
 174 TEST_F(child, disable_ptrace)
 175 {
 176         int uid, fd;
 177         char c;
 178
 179         /*
 180          * Turn into nobody if we're root, to avoid CAP_SYS_PTRACE
 181          *
 182          * The tests should run in their own process, so even this test fails,
 183          * it shouldn't result in subsequent tests failing.
 184          */
 185         uid = getuid();
 186         if (uid == 0)
 187                 ASSERT_EQ(0, seteuid(UID_NOBODY));
 188
 189         ASSERT_EQ(1, send(self->sk, "P", 1, 0));
 190         ASSERT_EQ(1, recv(self->sk, &c, 1, 0));
 191
 192         fd = sys_pidfd_getfd(self->pidfd, self->remote_fd, 0);
 193         EXPECT_EQ(-1, fd);
 194         EXPECT_EQ(EPERM, errno);
 195
 196         if (uid == 0)
 197                 ASSERT_EQ(0, seteuid(0));
 198 }
 199
 200 TEST_F(child, fetch_fd)
 201 {
 202         int fd, ret;
 203
 204         fd = sys_pidfd_getfd(self->pidfd, self->remote_fd, 0);
 205         ASSERT_GE(fd, 0);
 206
 207         EXPECT_EQ(0, sys_kcmp(getpid(), self->pid, KCMP_FILE, fd, self->remote_fd));
 208
 209         ret = fcntl(fd, F_GETFD);
 210         ASSERT_GE(ret, 0);
 211         EXPECT_GE(ret & FD_CLOEXEC, 0);
 212
 213         close(fd);
 214 }
 215
 216 TEST_F(child, test_unknown_fd)
 217 {
 218         int fd;
 219
 220         fd = sys_pidfd_getfd(self->pidfd, UNKNOWN_FD, 0);
 221         EXPECT_EQ(-1, fd) {
 222                 TH_LOG("getfd succeeded while fetching unknown fd");
 223         };
 224         EXPECT_EQ(EBADF, errno) {
 225                 TH_LOG("%s: getfd did not get EBADF", strerror(errno));
 226         }
 227 }
 228
 229 TEST(flags_set)
 230 {
 231         ASSERT_EQ(-1, sys_pidfd_getfd(0, 0, 1));
 232         EXPECT_EQ(errno, EINVAL);
 233 }
 234
 235 #if __NR_pidfd_getfd == -1
 236 int main(void)
 237 {
 238         fprintf(stderr, "__NR_pidfd_getfd undefined. The pidfd_getfd syscall is unavailable. Test aborting\n");
 239         return KSFT_SKIP;
 240 }
 241 #else
 242 TEST_HARNESS_MAIN
 243 #endif