// SPDX-License-Identifier: GPL-2.0
/*
* clone3(CLONE_VM|CLONE_PIDFD) with an unwritable pidfd pointer must
* not leak a GCS VMA. copy_thread() maps one, then put_user() fails
* and copy_process() calls exit_thread(). Without HAVE_EXIT_THREAD
* that free is a no-op and the VMA stays in the parent's mm.
*
* After enabling GCS, do not return from main(): libc frames above
* that point have no GCS entries.
*/
#define _GNU_SOURCE
#include <errno.h>
#include <linux/sched.h>
#include <sched.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/auxv.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include <unistd.h>
#include <asm/hwcap.h>
#include "kselftest.h"
#include "gcs-util.h"
#ifndef HWCAP_GCS
#define HWCAP_GCS (1UL << 32)
#endif
#ifndef __NR_clone3
#define __NR_clone3 435
#endif
#define NCLONE 16
#define STACK_SIZE (64 * 1024)
static int count_ss_vmas(void)
{
FILE *f;
char line[256];
int vmas = 0;
f = fopen("/proc/self/smaps", "r");
if (!f)
ksft_exit_fail_msg("fopen /proc/self/smaps: %s\n",
strerror(errno));
while (fgets(line, sizeof(line), f)) {
if (!strncmp(line, "VmFlags:", 8) && strstr(line, " ss"))
vmas++;
}
fclose(f);
return vmas;
}
/*
* CLONE_VM maps a new GCS. CLONE_PIDFD lets put_user() fail after that.
* Use a raw svc: the child resumes on an empty GCS, so a libc return
* after clone3 would fault; exit the same way.
*/
static long clone_pidfd(void *stack, size_t stack_size, int *pidfd_ptr)
{
struct clone_args args = {
.flags = CLONE_VM | CLONE_PIDFD,
.pidfd = (uint64_t)(uintptr_t)pidfd_ptr,
.exit_signal = SIGCHLD,
.stack = (uint64_t)(uintptr_t)stack,
.stack_size = stack_size,
};
register long num __asm__("x8") = __NR_clone3;
register long ret __asm__("x0") = (long)&args;
register long sz __asm__("x1") = sizeof(args);
int st;
asm volatile("svc #0"
: "+r"(ret)
: "r"(num), "r"(sz)
: "memory", "cc");
if (ret == 0) {
register long n __asm__("x8") = __NR_exit;
register long e __asm__("x0") = 0;
asm volatile("svc #0" : : "r"(n), "r"(e) : "memory");
__builtin_unreachable();
}
if (ret < 0)
return ret;
if (waitpid((pid_t)ret, &st, 0) < 0)
return -errno;
if (!WIFEXITED(st) || WEXITSTATUS(st) != 0)
return 1;
return 0;
}
int main(void)
{
void *stack;
void *bad_pidfd;
unsigned long gcs_mode;
long rc;
int pidfd = -1;
int vmas0, vmas1;
int i, n_efault = 0;
ksft_print_header();
if (!(getauxval(AT_HWCAP) & HWCAP_GCS))
ksft_exit_skip("GCS not supported\n");
stack = mmap(NULL, STACK_SIZE, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
if (stack == MAP_FAILED)
ksft_exit_fail_msg("mmap stack: %s\n", strerror(errno));
bad_pidfd = mmap(NULL, 4096, PROT_NONE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (bad_pidfd == MAP_FAILED)
ksft_exit_fail_msg("mmap pidfd page: %s\n", strerror(errno));
rc = my_syscall2(__NR_prctl, PR_GET_SHADOW_STACK_STATUS, &gcs_mode);
if (rc)
ksft_exit_fail_msg("PR_GET_SHADOW_STACK_STATUS: %ld\n", rc);
if (!(gcs_mode & PR_SHADOW_STACK_ENABLE)) {
rc = my_syscall2(__NR_prctl, PR_SET_SHADOW_STACK_STATUS,
PR_SHADOW_STACK_ENABLE);
if (rc == -EOPNOTSUPP || rc == -EINVAL || rc == -EBUSY)
ksft_exit_skip("cannot enable GCS: %ld\n", rc);
if (rc)
ksft_exit_fail_msg("PR_SET_SHADOW_STACK_STATUS: %ld\n",
rc);
}
rc = clone_pidfd(stack, STACK_SIZE, &pidfd);
if (rc == -ENOSYS || rc == -EINVAL || rc == -EPERM)
ksft_exit_skip("clone3 valid pidfd unavailable: %s\n",
strerror(-rc));
ksft_set_plan(3);
ksft_test_result(rc == 0 && pidfd >= 0,
"clone3 valid pidfd (rc=%ld pidfd=%d)\n",
rc, pidfd);
if (pidfd >= 0)
close(pidfd);
vmas0 = count_ss_vmas();
for (i = 0; i < NCLONE; i++) {
rc = clone_pidfd(stack, STACK_SIZE, bad_pidfd);
if (rc == -EFAULT)
n_efault++;
}
ksft_test_result(n_efault == NCLONE,
"clone3 bad pidfd returns -EFAULT x%d\n", NCLONE);
vmas1 = count_ss_vmas();
ksft_test_result(vmas1 == vmas0,
"no GCS VMA leak (%d -> %d)\n", vmas0, vmas1);
ksft_finished();
}