* [PATCH net-next 1/3] selftests/net: pass socket options to the scm_pidfd test flows
2026-11-02 23:12 [PATCH net-next 0/3] net: add SO_PASSCRED_THREAD to get a thread-specific SCM_CREDENTIALS Andrew Halaney
@ 2026-11-02 23:12 ` Andrew Halaney
2026-11-02 23:12 ` [PATCH net-next 2/3] net: add SO_PASSCRED_THREAD to get a thread-specific SCM_CREDENTIALS Andrew Halaney
2026-11-02 23:12 ` [PATCH net-next 3/3] selftests/net: Add tests for SO_PASSCRED_THREAD Andrew Halaney
2 siblings, 0 replies; 4+ messages in thread
From: Andrew Halaney @ 2026-11-02 23:12 UTC (permalink / raw)
To: Kuniyuki Iwashima, David S. Miller, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Simon Horman, Shuah Khan, Christian Brauner,
Richard Henderson, Matt Turner, Magnus Lindholm,
Thomas Bogendoerfer, James E.J. Bottomley, Helge Deller,
Andreas Larsson, Willem de Bruijn, Arnd Bergmann
Cc: netdev, linux-kselftest, linux-kernel, linux-alpha, linux-mips,
linux-parisc, sparclinux, linux-arch, Andrew Halaney
pidfd_flow() and leader_flow() take booleans that pick between
SO_PASSPIDFD and SO_PASSPIDFD_THREAD. Make them take a zero-terminated
list of socket options for the receiver to enable instead, so tests for
further SO_PASS* options can reuse the same flows rather than copying
them just to muck with options.
Signed-off-by: Andrew Halaney <andrew@amutable.com>
---
tools/testing/selftests/net/af_unix/scm_pidfd.c | 69 ++++++++++++-------------
1 file changed, 34 insertions(+), 35 deletions(-)
diff --git a/tools/testing/selftests/net/af_unix/scm_pidfd.c b/tools/testing/selftests/net/af_unix/scm_pidfd.c
index cbe53fab44fc..7524f3f6a8aa 100644
--- a/tools/testing/selftests/net/af_unix/scm_pidfd.c
+++ b/tools/testing/selftests/net/af_unix/scm_pidfd.c
@@ -765,20 +765,37 @@ static int read_pidfd_msg(int fd, struct pidfd_msg *out)
return 0;
}
+/* Zero-terminated lists of SOL_SOCKET options for the receiver to enable */
+static const int pass_tgid[] = { SO_PASSPIDFD, 0 };
+static const int pass_thread[] = { SO_PASSPIDFD_THREAD, 0 };
+static const int pass_both[] = { SO_PASSPIDFD, SO_PASSPIDFD_THREAD, 0 };
+
+static int set_opts(int fd, const int *opts)
+{
+ int on = 1;
+
+ for (; *opts; opts++) {
+ if (setsockopt(fd, SOL_SOCKET, *opts, &on, sizeof(on))) {
+ log_err("Failed to set socket option %d", *opts);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
/*
* Runs @nwriters threads of one child process against a SOCK_STREAM pair,
- * all of them queued before the parent reads. SO_PASSPIDFD is set when
- * @want_tgid is given, SO_PASSPIDFD_THREAD when @want_thread is. @nread
- * reads are returned in @out.
+ * all of them queued before the parent reads. The receiver enables @opts
+ * first. @nread reads are returned in @out.
*/
-static int pidfd_flow(void *(*sender)(void *), int nwriters, bool want_tgid,
- bool want_thread, struct pidfd_msg *out, int nread)
+static int pidfd_flow(void *(*sender)(void *), int nwriters, const int *opts,
+ struct pidfd_msg *out, int nread)
{
int child_status = 0;
int syncpipe[2];
int ackpipe[2];
int sk[2];
- int on = 1;
char sync;
pid_t child;
int i;
@@ -807,17 +824,8 @@ static int pidfd_flow(void *(*sender)(void *), int nwriters, bool want_tgid,
close(seq_pipe[0]);
close(seq_pipe[1]);
- if (want_tgid &&
- setsockopt(sk[0], SOL_SOCKET, SO_PASSPIDFD, &on, sizeof(on))) {
- log_err("Failed to set SO_PASSPIDFD");
+ if (set_opts(sk[0], opts))
return -1;
- }
-
- if (want_thread &&
- setsockopt(sk[0], SOL_SOCKET, SO_PASSPIDFD_THREAD, &on, sizeof(on))) {
- log_err("Failed to set SO_PASSPIDFD_THREAD");
- return -1;
- }
/* let the child know the options are set, it can write now */
if (write(syncpipe[1], "1", 1) != 1)
@@ -897,7 +905,7 @@ TEST(scm_pidfd_stream_glues_threads)
{
struct pidfd_msg msg[1] = { 0 };
- ASSERT_EQ(0, pidfd_flow(send_ids_thread, 2, true, false, msg, 1));
+ ASSERT_EQ(0, pidfd_flow(send_ids_thread, 2, pass_tgid, msg, 1));
EXPECT_EQ(sizeof(struct thread_ids) * 2, msg[0].len);
EXPECT_TRUE(msg[0].have_tgid);
@@ -914,7 +922,7 @@ TEST(scm_pidfd_thread_stream_splits_on_threads)
struct pidfd_msg msg[2] = { 0 };
int i;
- ASSERT_EQ(0, pidfd_flow(send_ids_thread, 2, true, true, msg, 2));
+ ASSERT_EQ(0, pidfd_flow(send_ids_thread, 2, pass_both, msg, 2));
for (i = 0; i < 2; i++) {
EXPECT_EQ(sizeof(struct thread_ids), msg[i].len);
@@ -937,29 +945,20 @@ TEST(scm_pidfd_thread_stream_splits_on_threads)
}
/* Sends from the thread-group leader */
-static int leader_flow(bool want_thread, struct pidfd_msg *out)
+static int leader_flow(const int *opts, struct pidfd_msg *out)
{
struct thread_ids ids = {
.pid = getpid(),
.tid = gettid(),
};
int sk[2];
- int on = 1;
int ret;
if (socketpair(AF_UNIX, SOCK_STREAM, 0, sk))
return -1;
- if (setsockopt(sk[0], SOL_SOCKET, SO_PASSPIDFD, &on, sizeof(on))) {
- log_err("Failed to set SO_PASSPIDFD");
+ if (set_opts(sk[0], opts))
return -1;
- }
-
- if (want_thread &&
- setsockopt(sk[0], SOL_SOCKET, SO_PASSPIDFD_THREAD, &on, sizeof(on))) {
- log_err("Failed to set SO_PASSPIDFD_THREAD");
- return -1;
- }
if (send(sk[1], &ids, sizeof(ids), 0) != sizeof(ids)) {
log_err("send");
@@ -980,7 +979,7 @@ TEST(scm_pidfd_leader_sender)
ASSERT_EQ(getpid(), gettid());
- ASSERT_EQ(0, leader_flow(false, &msg));
+ ASSERT_EQ(0, leader_flow(pass_tgid, &msg));
ASSERT_TRUE(msg.have_tgid);
EXPECT_FALSE(msg.have_thread);
@@ -995,7 +994,7 @@ TEST(scm_pidfd_thread_leader_sender)
ASSERT_EQ(getpid(), gettid());
- ASSERT_EQ(0, leader_flow(true, &msg));
+ ASSERT_EQ(0, leader_flow(pass_both, &msg));
ASSERT_TRUE(msg.have_tgid);
ASSERT_TRUE(msg.have_thread);
@@ -1012,7 +1011,7 @@ TEST(scm_pidfd_thread_and_group)
{
struct pidfd_msg msg = { 0 };
- ASSERT_EQ(0, pidfd_flow(send_ids_thread, 1, true, true, &msg, 1));
+ ASSERT_EQ(0, pidfd_flow(send_ids_thread, 1, pass_both, &msg, 1));
ASSERT_NE(msg.ids.pid, msg.ids.tid);
ASSERT_TRUE(msg.have_tgid);
ASSERT_TRUE(msg.have_thread);
@@ -1028,7 +1027,7 @@ TEST(scm_pidfd_thread)
{
struct pidfd_msg msg = { 0 };
- ASSERT_EQ(0, pidfd_flow(send_ids_thread, 1, false, true, &msg, 1));
+ ASSERT_EQ(0, pidfd_flow(send_ids_thread, 1, pass_thread, &msg, 1));
ASSERT_NE(msg.ids.pid, msg.ids.tid);
ASSERT_TRUE(msg.have_thread);
EXPECT_FALSE(msg.have_tgid);
@@ -1040,7 +1039,7 @@ TEST(scm_pidfd_thread_group)
{
struct pidfd_msg msg = { 0 };
- ASSERT_EQ(0, pidfd_flow(send_ids_thread, 1, true, false, &msg, 1));
+ ASSERT_EQ(0, pidfd_flow(send_ids_thread, 1, pass_tgid, &msg, 1));
ASSERT_NE(msg.ids.pid, msg.ids.tid);
ASSERT_TRUE(msg.have_tgid);
EXPECT_FALSE(msg.have_thread);
@@ -1052,7 +1051,7 @@ TEST(scm_pidfd_thread_creds)
{
struct pidfd_msg msg = { 0 };
- ASSERT_EQ(0, pidfd_flow(send_ids_creds_thread, 1, true, true, &msg, 1));
+ ASSERT_EQ(0, pidfd_flow(send_ids_creds_thread, 1, pass_both, &msg, 1));
ASSERT_NE(msg.ids.pid, msg.ids.tid);
ASSERT_TRUE(msg.have_tgid);
ASSERT_TRUE(msg.have_thread);
--
2.56.0
^ permalink raw reply [flat|nested] 4+ messages in thread* [PATCH net-next 2/3] net: add SO_PASSCRED_THREAD to get a thread-specific SCM_CREDENTIALS
2026-11-02 23:12 [PATCH net-next 0/3] net: add SO_PASSCRED_THREAD to get a thread-specific SCM_CREDENTIALS Andrew Halaney
2026-11-02 23:12 ` [PATCH net-next 1/3] selftests/net: pass socket options to the scm_pidfd test flows Andrew Halaney
@ 2026-11-02 23:12 ` Andrew Halaney
2026-11-02 23:12 ` [PATCH net-next 3/3] selftests/net: Add tests for SO_PASSCRED_THREAD Andrew Halaney
2 siblings, 0 replies; 4+ messages in thread
From: Andrew Halaney @ 2026-11-02 23:12 UTC (permalink / raw)
To: Kuniyuki Iwashima, David S. Miller, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Simon Horman, Shuah Khan, Christian Brauner,
Richard Henderson, Matt Turner, Magnus Lindholm,
Thomas Bogendoerfer, James E.J. Bottomley, Helge Deller,
Andreas Larsson, Willem de Bruijn, Arnd Bergmann
Cc: netdev, linux-kselftest, linux-kernel, linux-alpha, linux-mips,
linux-parisc, sparclinux, linux-arch, Andrew Halaney
Currently, SCM_CREDENTIALS carries the pid of the thread-group leader,
despite carrying the uid/gid of the actual sending thread.
SO_PASSPIDFD_THREAD lets a receiver identify the sending thread, but
only through a pidfd. If you just want to know what the tid of the
sending thread is you have to do something like:
1. Setup SO_PASSPIDFD_THREAD on the socket
2. ioctl(thread_pidfd, PIDFD_GET_INFO) per message
3. close(thread_pidfd) per message
For example systemd-journald wants to log the tid as "trusted field"
(aka provided by the kernel) but doesn't have a great way to do so
right now, unlike the options for uid/gid/pid which are covered by
SO_PASSCRED currently.
So add SO_PASSCRED_THREAD as a sibling of SO_PASSCRED. It delivers
SCM_CREDENTIALS_THREAD whose ucred carries the tid of the sending
thread instead of the thread-group leader. This is completely
independent of SO_PASSCRED, so a receiver can ask for both. Use
a new cmsg rather than changing SCM_CREDENTIALS because users
expect ucred.pid in that context to be the thread-group leader.
As with SO_PASSPIDFD_THREAD, recvmsg() on SOCK_STREAM sockets stops
merging data at a thread boundary once SO_PASSCRED_THREAD is set.
Signed-off-by: Andrew Halaney <andrew@amutable.com>
---
arch/alpha/include/uapi/asm/socket.h | 2 ++
arch/mips/include/uapi/asm/socket.h | 2 ++
arch/parisc/include/uapi/asm/socket.h | 2 ++
arch/sparc/include/uapi/asm/socket.h | 2 ++
include/linux/socket.h | 1 +
include/net/sock.h | 4 +++-
include/uapi/asm-generic/socket.h | 2 ++
net/core/scm.c | 32 +++++++++++++++++++++-----------
net/core/sock.c | 14 ++++++++++++++
net/unix/af_unix.c | 6 +++---
10 files changed, 52 insertions(+), 15 deletions(-)
diff --git a/arch/alpha/include/uapi/asm/socket.h b/arch/alpha/include/uapi/asm/socket.h
index 5d3524c26b2b..430ef65e51ea 100644
--- a/arch/alpha/include/uapi/asm/socket.h
+++ b/arch/alpha/include/uapi/asm/socket.h
@@ -161,6 +161,8 @@
#define SO_PEERPIDFD_THREAD 87
+#define SO_PASSCRED_THREAD 88
+
#if !defined(__KERNEL__)
#if __BITS_PER_LONG == 64
diff --git a/arch/mips/include/uapi/asm/socket.h b/arch/mips/include/uapi/asm/socket.h
index 245a43f52fb1..7e49b24170d2 100644
--- a/arch/mips/include/uapi/asm/socket.h
+++ b/arch/mips/include/uapi/asm/socket.h
@@ -172,6 +172,8 @@
#define SO_PEERPIDFD_THREAD 87
+#define SO_PASSCRED_THREAD 88
+
#if !defined(__KERNEL__)
#if __BITS_PER_LONG == 64
diff --git a/arch/parisc/include/uapi/asm/socket.h b/arch/parisc/include/uapi/asm/socket.h
index f23710e1c671..e414c2397224 100644
--- a/arch/parisc/include/uapi/asm/socket.h
+++ b/arch/parisc/include/uapi/asm/socket.h
@@ -153,6 +153,8 @@
#define SO_PEERPIDFD_THREAD 0x4055
+#define SO_PASSCRED_THREAD 0x4056
+
#if !defined(__KERNEL__)
#if __BITS_PER_LONG == 64
diff --git a/arch/sparc/include/uapi/asm/socket.h b/arch/sparc/include/uapi/asm/socket.h
index b35b25bdefc2..9ca7ec9ba450 100644
--- a/arch/sparc/include/uapi/asm/socket.h
+++ b/arch/sparc/include/uapi/asm/socket.h
@@ -154,6 +154,8 @@
#define SO_PEERPIDFD_THREAD 0x0060
+#define SO_PASSCRED_THREAD 0x0061
+
#if !defined(__KERNEL__)
diff --git a/include/linux/socket.h b/include/linux/socket.h
index b17fdb7d38a7..37ddcdfc0377 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -194,6 +194,7 @@ static inline size_t msg_data_left(const struct msghdr *msg)
#define SCM_SECURITY 0x03 /* rw: security label */
#define SCM_PIDFD 0x04 /* ro: pidfd (int) */
#define SCM_PIDFD_THREAD 0x05 /* ro: thread pidfd (int) */
+#define SCM_CREDENTIALS_THREAD 0x06 /* ro: struct ucred, thread */
struct ucred {
__u32 pid;
diff --git a/include/net/sock.h b/include/net/sock.h
index 173b37b2b8bb..344057d3aa74 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -357,6 +357,7 @@ struct sk_filter;
* @sk_scm_pidfd: flagged by SO_PASSPIDFD to recv SCM_PIDFD
* @sk_scm_rights: flagged by SO_PASSRIGHTS to recv SCM_RIGHTS
* @sk_scm_pidfd_thread: flagged by SO_PASSPIDFD_THREAD to recv a thread SCM_PIDFD
+ * @sk_scm_credentials_thread: flagged by SO_PASSCRED_THREAD to recv SCM_CREDENTIALS_THREAD
* @sk_scm_unused: unused flags for scm_recv()
* @ns_tracker: tracker for netns reference
* @sk_user_frags: xarray of pages the user is holding a reference on.
@@ -564,7 +565,8 @@ struct sock {
sk_scm_pidfd : 1,
sk_scm_rights : 1,
sk_scm_pidfd_thread : 1,
- sk_scm_unused : 3;
+ sk_scm_credentials_thread : 1,
+ sk_scm_unused : 2;
};
};
u8 sk_clockid;
diff --git a/include/uapi/asm-generic/socket.h b/include/uapi/asm-generic/socket.h
index 56fed7ab27ab..2e5d9db1c9fa 100644
--- a/include/uapi/asm-generic/socket.h
+++ b/include/uapi/asm-generic/socket.h
@@ -156,6 +156,8 @@
#define SO_PEERPIDFD_THREAD 87
+#define SO_PASSCRED_THREAD 88
+
#if !defined(__KERNEL__)
#if __BITS_PER_LONG == 64 || (defined(__x86_64__) && defined(__ILP32__))
diff --git a/net/core/scm.c b/net/core/scm.c
index ae38f3c1165c..d0d453fb811d 100644
--- a/net/core/scm.c
+++ b/net/core/scm.c
@@ -543,28 +543,34 @@ static void scm_pidfd_recv(struct msghdr *msg, struct scm_cookie *scm,
fd_install(pidfd, pidfd_file);
}
+static void scm_creds_recv(struct msghdr *msg, struct scm_cookie *scm,
+ u32 pid, int cmsg_type)
+{
+ struct user_namespace *current_ns = current_user_ns();
+ struct ucred ucreds = {
+ .pid = pid,
+ .uid = from_kuid_munged(current_ns, scm->creds.uid),
+ .gid = from_kgid_munged(current_ns, scm->creds.gid),
+ };
+
+ put_cmsg(msg, SOL_SOCKET, cmsg_type, sizeof(ucreds), &ucreds);
+}
+
static bool __scm_recv_common(struct sock *sk, struct msghdr *msg,
struct scm_cookie *scm, int flags)
{
if (!msg->msg_control) {
if (sk->sk_scm_credentials || sk->sk_scm_pidfd ||
- sk->sk_scm_pidfd_thread || scm->fp || scm_has_secdata(sk))
+ sk->sk_scm_pidfd_thread || sk->sk_scm_credentials_thread ||
+ scm->fp || scm_has_secdata(sk))
msg->msg_flags |= MSG_CTRUNC;
scm_destroy(scm);
return false;
}
- if (sk->sk_scm_credentials) {
- struct user_namespace *current_ns = current_user_ns();
- struct ucred ucreds = {
- .pid = scm->creds.pid,
- .uid = from_kuid_munged(current_ns, scm->creds.uid),
- .gid = from_kgid_munged(current_ns, scm->creds.gid),
- };
-
- put_cmsg(msg, SOL_SOCKET, SCM_CREDENTIALS, sizeof(ucreds), &ucreds);
- }
+ if (sk->sk_scm_credentials)
+ scm_creds_recv(msg, scm, scm->creds.pid, SCM_CREDENTIALS);
scm_passec(sk, msg, scm);
@@ -587,6 +593,10 @@ void scm_recv_unix(struct socket *sock, struct msghdr *msg,
if (!__scm_recv_common(sock->sk, msg, scm, flags))
return;
+ if (sock->sk->sk_scm_credentials_thread)
+ scm_creds_recv(msg, scm, pid_vnr(scm->pid[PIDTYPE_PID]),
+ SCM_CREDENTIALS_THREAD);
+
if (scm->fp) {
struct unix_sock *u;
diff --git a/net/core/sock.c b/net/core/sock.c
index e7405be8941f..6b443bd44581 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -1586,6 +1586,13 @@ int sk_setsockopt(struct sock *sk, int level, int optname,
ret = -EOPNOTSUPP;
break;
+ case SO_PASSCRED_THREAD:
+ if (sk_is_unix(sk))
+ sk->sk_scm_credentials_thread = valbool;
+ else
+ ret = -EOPNOTSUPP;
+ break;
+
case SO_PASSRIGHTS:
if (sk_is_unix(sk))
sk->sk_scm_rights = valbool;
@@ -1952,6 +1959,13 @@ int sk_getsockopt(struct sock *sk, int level, int optname,
v.val = sk->sk_scm_pidfd_thread;
break;
+ case SO_PASSCRED_THREAD:
+ if (!sk_is_unix(sk))
+ return -EOPNOTSUPP;
+
+ v.val = sk->sk_scm_credentials_thread;
+ break;
+
case SO_PASSRIGHTS:
if (!sk_is_unix(sk))
return -EOPNOTSUPP;
diff --git a/net/unix/af_unix.c b/net/unix/af_unix.c
index 98fcfd7301f6..d802463cec45 100644
--- a/net/unix/af_unix.c
+++ b/net/unix/af_unix.c
@@ -800,7 +800,7 @@ static void copy_peercred(struct sock *sk, struct sock *peersk)
static bool unix_may_passcred(const struct sock *sk)
{
return sk->sk_scm_credentials || sk->sk_scm_pidfd ||
- sk->sk_scm_pidfd_thread;
+ sk->sk_scm_pidfd_thread || sk->sk_scm_credentials_thread;
}
static int unix_listen(struct socket *sock, int backlog)
@@ -2047,8 +2047,8 @@ static int unix_maybe_add_creds(struct sk_buff *skb, const struct sock *sk,
static bool unix_skb_scm_eq(const struct sock *sk, struct sk_buff *skb,
struct scm_cookie *scm)
{
- /* Only a thread pidfd receiver can tell threads of one process apart. */
- if (sk->sk_scm_pidfd_thread &&
+ /* Only a thread-aware receiver can tell threads of one process apart. */
+ if ((sk->sk_scm_pidfd_thread || sk->sk_scm_credentials_thread) &&
UNIXCB(skb).pid[PIDTYPE_PID] != scm->pid[PIDTYPE_PID])
return false;
--
2.56.0
^ permalink raw reply [flat|nested] 4+ messages in thread* [PATCH net-next 3/3] selftests/net: Add tests for SO_PASSCRED_THREAD
2026-11-02 23:12 [PATCH net-next 0/3] net: add SO_PASSCRED_THREAD to get a thread-specific SCM_CREDENTIALS Andrew Halaney
2026-11-02 23:12 ` [PATCH net-next 1/3] selftests/net: pass socket options to the scm_pidfd test flows Andrew Halaney
2026-11-02 23:12 ` [PATCH net-next 2/3] net: add SO_PASSCRED_THREAD to get a thread-specific SCM_CREDENTIALS Andrew Halaney
@ 2026-11-02 23:12 ` Andrew Halaney
2 siblings, 0 replies; 4+ messages in thread
From: Andrew Halaney @ 2026-11-02 23:12 UTC (permalink / raw)
To: Kuniyuki Iwashima, David S. Miller, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Simon Horman, Shuah Khan, Christian Brauner,
Richard Henderson, Matt Turner, Magnus Lindholm,
Thomas Bogendoerfer, James E.J. Bottomley, Helge Deller,
Andreas Larsson, Willem de Bruijn, Arnd Bergmann
Cc: netdev, linux-kselftest, linux-kernel, linux-alpha, linux-mips,
linux-parisc, sparclinux, linux-arch, Andrew Halaney
Add SO_PASSCRED_THREAD tests to the af_unix scm_pidfd selftests.
Signed-off-by: Andrew Halaney <andrew@amutable.com>
---
tools/testing/selftests/net/af_unix/scm_pidfd.c | 160 +++++++++++++++++++++++-
1 file changed, 156 insertions(+), 4 deletions(-)
diff --git a/tools/testing/selftests/net/af_unix/scm_pidfd.c b/tools/testing/selftests/net/af_unix/scm_pidfd.c
index 7524f3f6a8aa..75387ede1eeb 100644
--- a/tools/testing/selftests/net/af_unix/scm_pidfd.c
+++ b/tools/testing/selftests/net/af_unix/scm_pidfd.c
@@ -40,6 +40,14 @@
#define SO_PEERPIDFD_THREAD 87
#endif
+#ifndef SO_PASSCRED_THREAD
+#define SO_PASSCRED_THREAD 88
+#endif
+
+#ifndef SCM_CREDENTIALS_THREAD
+#define SCM_CREDENTIALS_THREAD 0x06
+#endif
+
#define CHILD_EXIT_CODE_OK 123
static void child_die()
@@ -689,6 +697,10 @@ struct pidfd_msg {
int thread_flags;
bool have_tgid;
bool have_thread;
+ struct ucred creds;
+ struct ucred thread_creds;
+ bool have_creds;
+ bool have_thread_creds;
};
static int get_pidfd_info(int pidfd, struct pidfd_info *info)
@@ -703,11 +715,12 @@ static int get_pidfd_info(int pidfd, struct pidfd_info *info)
}
/* One recvmsg(), reporting how many bytes came back and what the pidfd
- * cmsgs that came with them say.
+ * and credentials cmsgs that came with them say.
*/
static int read_pidfd_msg(int fd, struct pidfd_msg *out)
{
- char control[CMSG_SPACE(sizeof(int)) * 2] = { 0 };
+ char control[CMSG_SPACE(sizeof(int)) * 2 +
+ CMSG_SPACE(sizeof(struct ucred)) * 2] = { 0 };
int tgid_pidfd = -1, thread_pidfd = -1;
struct thread_ids buf[2] = { 0 };
struct msghdr msg = { 0 };
@@ -739,10 +752,18 @@ static int read_pidfd_msg(int fd, struct pidfd_msg *out)
if (cmsg->cmsg_level != SOL_SOCKET)
continue;
- if (cmsg->cmsg_type == SCM_PIDFD)
+ if (cmsg->cmsg_type == SCM_PIDFD) {
memcpy(&tgid_pidfd, CMSG_DATA(cmsg), sizeof(tgid_pidfd));
- else if (cmsg->cmsg_type == SCM_PIDFD_THREAD)
+ } else if (cmsg->cmsg_type == SCM_PIDFD_THREAD) {
memcpy(&thread_pidfd, CMSG_DATA(cmsg), sizeof(thread_pidfd));
+ } else if (cmsg->cmsg_type == SCM_CREDENTIALS) {
+ memcpy(&out->creds, CMSG_DATA(cmsg), sizeof(out->creds));
+ out->have_creds = true;
+ } else if (cmsg->cmsg_type == SCM_CREDENTIALS_THREAD) {
+ memcpy(&out->thread_creds, CMSG_DATA(cmsg),
+ sizeof(out->thread_creds));
+ out->have_thread_creds = true;
+ }
}
out->have_tgid = tgid_pidfd >= 0;
@@ -769,6 +790,9 @@ static int read_pidfd_msg(int fd, struct pidfd_msg *out)
static const int pass_tgid[] = { SO_PASSPIDFD, 0 };
static const int pass_thread[] = { SO_PASSPIDFD_THREAD, 0 };
static const int pass_both[] = { SO_PASSPIDFD, SO_PASSPIDFD_THREAD, 0 };
+static const int creds_tgid[] = { SO_PASSCRED, 0 };
+static const int creds_thread[] = { SO_PASSCRED_THREAD, 0 };
+static const int creds_both[] = { SO_PASSCRED, SO_PASSCRED_THREAD, 0 };
static int set_opts(int fd, const int *opts)
{
@@ -1061,6 +1085,134 @@ TEST(scm_pidfd_thread_creds)
EXPECT_EQ(msg.ids.pid, msg.thread_info.tgid);
}
+TEST(scm_creds_thread_setsockopt_values)
+{
+ int sk[2];
+ int inet;
+
+ ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, sk));
+
+ /* Verify that the options are truly set independently */
+ ASSERT_EQ(0, sockopt_set(sk[0], SO_PASSCRED_THREAD, 1));
+ ASSERT_EQ(1, sockopt_get(sk[0], SO_PASSCRED_THREAD));
+ ASSERT_EQ(0, sockopt_get(sk[0], SO_PASSCRED));
+
+ ASSERT_EQ(0, sockopt_set(sk[0], SO_PASSCRED, 1));
+ ASSERT_EQ(1, sockopt_get(sk[0], SO_PASSCRED));
+ ASSERT_EQ(1, sockopt_get(sk[0], SO_PASSCRED_THREAD));
+
+ /* Verify that the options are truly cleared independently */
+ ASSERT_EQ(0, sockopt_set(sk[0], SO_PASSCRED, 0));
+ ASSERT_EQ(0, sockopt_get(sk[0], SO_PASSCRED));
+ ASSERT_EQ(1, sockopt_get(sk[0], SO_PASSCRED_THREAD));
+
+ ASSERT_EQ(0, sockopt_set(sk[0], SO_PASSCRED_THREAD, 0));
+ ASSERT_EQ(0, sockopt_get(sk[0], SO_PASSCRED_THREAD));
+ ASSERT_EQ(0, sockopt_get(sk[0], SO_PASSCRED));
+
+ close(sk[0]);
+ close(sk[1]);
+
+ /* Only AF_UNIX records the sending thread */
+ inet = socket(AF_INET, SOCK_DGRAM, 0);
+ ASSERT_LE(0, inet);
+ EXPECT_EQ(-1, sockopt_set(inet, SO_PASSCRED_THREAD, 1));
+ EXPECT_EQ(EOPNOTSUPP, errno);
+ close(inet);
+}
+
+/* A receiver that only asked about the process cannot tell the two
+ * threads apart, so their writes are glued into one read.
+ */
+TEST(scm_creds_stream_glues_threads)
+{
+ struct pidfd_msg msg[1] = { 0 };
+
+ ASSERT_EQ(0, pidfd_flow(send_ids_thread, 2, creds_tgid, msg, 1));
+ EXPECT_EQ(sizeof(struct thread_ids) * 2, msg[0].len);
+
+ EXPECT_TRUE(msg[0].have_creds);
+ EXPECT_FALSE(msg[0].have_thread_creds);
+ EXPECT_EQ(msg[0].ids.pid, msg[0].creds.pid);
+}
+
+/* SO_PASSCRED_THREAD on its own is enough to split a stream per thread */
+TEST(scm_creds_thread_stream_splits_on_threads)
+{
+ struct pidfd_msg msg[2] = { 0 };
+ int i;
+
+ ASSERT_EQ(0, pidfd_flow(send_ids_thread, 2, creds_thread, msg, 2));
+
+ for (i = 0; i < 2; i++) {
+ EXPECT_EQ(sizeof(struct thread_ids), msg[i].len);
+ EXPECT_FALSE(msg[i].have_creds);
+ EXPECT_TRUE(msg[i].have_thread_creds);
+ EXPECT_NE(msg[i].ids.pid, msg[i].ids.tid);
+ EXPECT_EQ(msg[i].ids.tid, msg[i].thread_creds.pid);
+ }
+
+ /* Make sure we really got unique threads per message */
+ EXPECT_NE(msg[0].thread_creds.pid, msg[1].thread_creds.pid);
+}
+
+TEST(scm_creds_thread_leader_sender)
+{
+ struct pidfd_msg msg = { 0 };
+
+ ASSERT_EQ(getpid(), gettid());
+
+ ASSERT_EQ(0, leader_flow(creds_both, &msg));
+ ASSERT_TRUE(msg.have_creds);
+ ASSERT_TRUE(msg.have_thread_creds);
+
+ EXPECT_EQ(getpid(), msg.creds.pid);
+ EXPECT_EQ(getpid(), msg.thread_creds.pid);
+}
+
+TEST(scm_creds_thread_and_group)
+{
+ struct pidfd_msg msg = { 0 };
+
+ ASSERT_EQ(0, pidfd_flow(send_ids_thread, 1, creds_both, &msg, 1));
+ ASSERT_NE(msg.ids.pid, msg.ids.tid);
+ ASSERT_TRUE(msg.have_creds);
+ ASSERT_TRUE(msg.have_thread_creds);
+
+ EXPECT_EQ(msg.ids.pid, msg.creds.pid);
+ EXPECT_EQ(msg.ids.tid, msg.thread_creds.pid);
+ EXPECT_EQ(msg.creds.uid, msg.thread_creds.uid);
+ EXPECT_EQ(msg.creds.gid, msg.thread_creds.gid);
+}
+
+TEST(scm_creds_thread)
+{
+ struct pidfd_msg msg = { 0 };
+
+ ASSERT_EQ(0, pidfd_flow(send_ids_thread, 1, creds_thread, &msg, 1));
+ ASSERT_NE(msg.ids.pid, msg.ids.tid);
+ ASSERT_TRUE(msg.have_thread_creds);
+ EXPECT_FALSE(msg.have_creds);
+
+ EXPECT_EQ(msg.ids.tid, msg.thread_creds.pid);
+ EXPECT_EQ(getuid(), msg.thread_creds.uid);
+ EXPECT_EQ(getgid(), msg.thread_creds.gid);
+}
+
+/* A sender passing its own SCM_CREDENTIALS still reports the sending thread */
+TEST(scm_creds_thread_explicit_creds)
+{
+ struct pidfd_msg msg = { 0 };
+
+ ASSERT_EQ(0, pidfd_flow(send_ids_creds_thread, 1, creds_both, &msg, 1));
+ ASSERT_NE(msg.ids.pid, msg.ids.tid);
+ ASSERT_TRUE(msg.have_creds);
+ ASSERT_TRUE(msg.have_thread_creds);
+
+ EXPECT_EQ(msg.ids.pid, msg.creds.pid);
+ EXPECT_EQ(msg.ids.tid, msg.thread_creds.pid);
+}
+
static void *peer_connect_thread(void *arg)
{
struct sock_addr *sa = arg;
--
2.56.0
^ permalink raw reply [flat|nested] 4+ messages in thread