kcmp: add KCMP_EPOLL_TFD support

* configure.ac (AC_CHECK_TYPES): Add check for struct kcmp_epoll_slot.
* kcmp.c (SYS_FUNC(kcmp)) <case KCMP_EPOLL_TFD>: Implement idx1/idx2
argument parsing.
* tests/kcmp.c: Update test.
* xlat/kcmp_types.in (KCMP_EPOLL_TFD): New entry.

diff --git a/configure.ac b/configure.ac
index 7e3b6be4ef4bec21ecba4112e6a4636ea8f559d7..38783893911cd7306b32008f461f55fb5d328b81 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -333,6 +333,10 @@ AC_CHECK_TYPES(m4_normalize([
        struct crypto_report_rng
 ]),,, [#include <linux/cryptouser.h>])
 
+AC_CHECK_TYPES(m4_normalize([
+       struct kcmp_epoll_slot
+]),,, [#include <linux/kcmp.h>])
+
 AC_CHECK_TYPES(m4_normalize([
        struct keyctl_kdf_params
 ]),,, [#include <linux/keyctl.h>])

diff --git a/kcmp.c b/kcmp.c
index e1c6e9ed0532bd299c201f0a3b2ff99011a46d96..ec537a67952bee00e138e39972e469b37b83f7b5 100644 (file)
--- a/kcmp.c
+++ b/kcmp.c
@@ -30,6 +30,12 @@
 #include "print_fields.h"
 #include "xlat/kcmp_types.h"
 
+struct strace_kcmp_epoll_slot {
+       uint32_t efd;
+       uint32_t tfd;
+       uint32_t toff;
+};
+
 static void
 printpidfd(struct tcb *tcp, pid_t pid, int fd)
 {
@@ -65,6 +71,25 @@ SYS_FUNC(kcmp)
                        printpidfd(tcp, pid1, idx2);
 
                        break;
+
+               case KCMP_EPOLL_TFD: {
+                       struct strace_kcmp_epoll_slot slot;
+
+                       tprints(", ");
+                       printpidfd(tcp, pid1, idx1);
+                       tprints(", ");
+
+                       if (umove_or_printaddr(tcp, idx2, &slot))
+                               break;
+
+                       PRINT_FIELD_PIDFD("{",  slot, efd, tcp, pid2);
+                       PRINT_FIELD_PIDFD(", ", slot, tfd, tcp, pid2);
+                       PRINT_FIELD_U(", ", slot, toff);
+                       tprints("}");
+
+                       break;
+               }
+
                case KCMP_FILES:
                case KCMP_FS:
                case KCMP_IO:

diff --git a/tests/kcmp.c b/tests/kcmp.c
index 652352e918b0046273213b76d498a9c952f0999c..5714481815e5d492bea72b984f430c6a3a459dee 100644 (file)
--- a/tests/kcmp.c
+++ b/tests/kcmp.c
@@ -35,7 +35,10 @@
 #ifdef __NR_kcmp
 
 # include <fcntl.h>
+# include <stdarg.h>
+# include <stdint.h>
 # include <stdio.h>
+# include <string.h>
 # include <unistd.h>
 
 # ifndef VERBOSE_FD
@@ -59,6 +62,19 @@
 #  define KCMP_SYSVSEM 6
 # endif
 
+/* All other kcmp types have been added atomically */
+# define KCMP_EPOLL_TFD        7
+
+# ifndef HAVE_STRUCT_KCMP_EPOLL_SLOT
+struct kcmp_epoll_slot {
+       uint32_t efd;
+       uint32_t tfd;
+       uint32_t toff;
+};
+# endif
+
+static const kernel_ulong_t kcmp_max_type = KCMP_EPOLL_TFD;
+
 static const char null_path[] = "/dev/null";
 static const char zero_path[] = "/dev/zero";
 
@@ -71,9 +87,14 @@ printpidfd(const char *prefix, pid_t pid, unsigned fd)
        printf("%s%d", prefix, fd);
 }
 
+/*
+ * Last argument is optional and is used as follows:
+ *  * When type is KCMP_EPOLL_TFD, it signalises whether idx2 is a valid
+ *    pointer.
+ */
 static void
 do_kcmp(kernel_ulong_t pid1, kernel_ulong_t pid2, kernel_ulong_t type,
-       const char *type_str, kernel_ulong_t idx1, kernel_ulong_t idx2)
+       const char *type_str, kernel_ulong_t idx1, kernel_ulong_t idx2, ...)
 {
        long rc;
        const char *errstr;
@@ -91,7 +112,31 @@ do_kcmp(kernel_ulong_t pid1, kernel_ulong_t pid2, kernel_ulong_t type,
        if (type == KCMP_FILE) {
                printpidfd(", ", pid1, idx1);
                printpidfd(", ", pid2, idx2);
-       } else if (type > KCMP_SYSVSEM) {
+       } else if (type == KCMP_EPOLL_TFD) {
+               va_list ap;
+               int valid_ptr;
+
+               va_start(ap, idx2);
+               valid_ptr = va_arg(ap, int);
+               va_end(ap);
+
+               printpidfd(", ", pid1, idx1);
+               printf(", ");
+
+               if (valid_ptr) {
+                       struct kcmp_epoll_slot *slot =
+                               (struct kcmp_epoll_slot *) (uintptr_t) idx2;
+
+                       printpidfd("{efd=", pid2, slot->efd);
+                       printpidfd(", tfd=", pid2, slot->tfd);
+                       printf(", toff=%llu}", (unsigned long long) slot->toff);
+               } else {
+                       if (idx2)
+                               printf("%#llx", (unsigned long long) idx2);
+                       else
+                               printf("NULL");
+               }
+       } else if (type > kcmp_max_type) {
                printf(", %#llx, %#llx",
                       (unsigned long long) idx1, (unsigned long long) idx2);
        }
@@ -112,8 +157,17 @@ main(void)
                (kernel_ulong_t) 0xdec0ded3dec0ded4ULL;
        static const kernel_ulong_t bogus_idx2 =
                (kernel_ulong_t) 0xba5e1e55deadc0deULL;
+       static const struct kcmp_epoll_slot slot_data[] = {
+               { 0xdeadc0de, 0xfacef157, 0xbadc0ded },
+               { NULL_FD, ZERO_FD, 0 },
+               { 0, 0, 0 },
+       };
+       static kernel_ulong_t ptr_check =
+               F8ILL_KULONG_SUPPORTED ? F8ILL_KULONG_MASK : 0;
 
        int fd;
+       unsigned i;
+       struct kcmp_epoll_slot *slot = tail_alloc(sizeof(*slot));
 
        /* Open some files to test printpidfd */
        fd = open(null_path, O_RDONLY);
@@ -134,10 +188,12 @@ main(void)
                close(fd);
        }
 
+       close(0);
+
        /* Invalid values */
        do_kcmp(bogus_pid1, bogus_pid2, bogus_type, NULL, bogus_idx1,
                bogus_idx2);
-       do_kcmp(F8ILL_KULONG_MASK, F8ILL_KULONG_MASK, KCMP_SYSVSEM + 1, NULL,
+       do_kcmp(F8ILL_KULONG_MASK, F8ILL_KULONG_MASK, kcmp_max_type + 1, NULL,
                0, 0);
 
        /* KCMP_FILE is the only type which has additional args */
@@ -153,6 +209,19 @@ main(void)
        do_kcmp(-1, -1, ARG_STR(KCMP_IO), bogus_idx1, bogus_idx2);
        do_kcmp(-1, -1, ARG_STR(KCMP_SYSVSEM), bogus_idx1, bogus_idx2);
 
+       /* KCMP_EPOLL_TFD checks */
+       do_kcmp(-1, -1, ARG_STR(KCMP_EPOLL_TFD),
+               F8ILL_KULONG_MASK | 2718281828U, ptr_check, 0);
+       do_kcmp(-1, -1, ARG_STR(KCMP_EPOLL_TFD),
+               3141592653U, (uintptr_t) slot + 1, 0);
+
+       for (i = 0; i < ARRAY_SIZE(slot_data); i++) {
+               memcpy(slot, slot_data + i, sizeof(*slot));
+
+               do_kcmp(getpid(), getppid(), ARG_STR(KCMP_EPOLL_TFD), NULL_FD,
+                       (uintptr_t) slot, 1);
+       }
+
        puts("+++ exited with 0 +++");
 
        return 0;

diff --git a/xlat/kcmp_types.in b/xlat/kcmp_types.in
index 4357776c713d8cfb5218bf88799a3ff8caef551d..c37cf22b4205a7113c7ee2104a5ac024e4dbe09f 100644 (file)
--- a/xlat/kcmp_types.in
+++ b/xlat/kcmp_types.in
@@ -5,3 +5,4 @@ KCMP_FS         3
 KCMP_SIGHAND   4
 KCMP_IO                5
 KCMP_SYSVSEM   6
+KCMP_EPOLL_TFD 7