path: root/tools/testing/selftests/exec/binfmt_misc_common.h

/* SPDX-License-Identifier: GPL-2.0 */
/* Helpers shared by the binfmt_misc selftests. */
#ifndef __SELFTESTS_EXEC_BINFMT_MISC_COMMON_H
#define __SELFTESTS_EXEC_BINFMT_MISC_COMMON_H

#include <elf.h>
#include <errno.h>
#include <fcntl.h>
#include <libgen.h>
#include <limits.h>
#include <link.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mount.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#define BINFMT_DIR	"/proc/sys/fs/binfmt_misc"
#define BINFMT_REG	BINFMT_DIR "/register"

/* comm holds 15 usable chars; a read of /proc/self/comm appends a newline. */
#define TASK_COMM_LEN	16

/* The canonical payload argv: run_payload() passes it, the payloads assert it. */
#define PAYLOAD_ARGV0	"payload-argv0"
#define PAYLOAD_ARG1	"argone"
#define PAYLOAD_ARG2	"argtwo"

/* Marker the loader tests poke into the payload's e_ident padding. */
#define LOADER_MARKER	"LDRTST"

/* Exit status run_payload() reports when the exec was refused as unhandled. */
#define RUN_ENOEXEC	42

static inline int copy_file(const char *src, const char *dst)
{
	char buf[4096];
	int in, out;
	ssize_t n;

	in = open(src, O_RDONLY);
	if (in < 0)
		return -1;
	/* The tests share /tmp, so never write through a name they don't own. */
	unlink(dst);
	out = open(dst, O_WRONLY | O_CREAT | O_EXCL, 0755);
	if (out < 0) {
		close(in);
		return -1;
	}
	while ((n = read(in, buf, sizeof(buf))) > 0) {
		if (write(out, buf, n) != n) {
			close(in);
			close(out);
			return -1;
		}
	}
	close(in);
	close(out);
	return n < 0 ? -1 : 0;
}

/* Write @rule to the register file, preserving the write's errno. */
static inline int write_reg(const char *rule)
{
	int fd, saved;
	ssize_t n;

	fd = open(BINFMT_REG, O_WRONLY);
	if (fd < 0)
		return -1;
	n = write(fd, rule, strlen(rule));
	saved = errno;
	close(fd);
	errno = saved;
	return n < 0 ? -1 : 0;
}

static inline void unregister(const char *name)
{
	char path[PATH_MAX];
	int fd;

	snprintf(path, sizeof(path), BINFMT_DIR "/%s", name);
	fd = open(path, O_WRONLY);
	if (fd >= 0) {
		if (write(fd, "-1", 2) < 0)
			; /* best effort */
		close(fd);
	}
}

/* Write @line to @entry's file, reporting the errno it was refused with. */
static inline int entry_command(const char *entry, const char *line)
{
	char path[PATH_MAX];
	int fd, retval = 0;
	size_t len = strlen(line);

	snprintf(path, sizeof(path), BINFMT_DIR "/%s", entry);
	fd = open(path, O_WRONLY | O_CLOEXEC);
	if (fd < 0)
		return -errno;
	if (write(fd, line, len) != (ssize_t)len)
		retval = -errno;
	close(fd);
	return retval;
}

/* Does @entry's file report @line? */
static inline bool entry_shows(const char *entry, const char *line)
{
	char path[PATH_MAX], buf[PATH_MAX];
	bool found = false;
	FILE *fp;

	snprintf(path, sizeof(path), BINFMT_DIR "/%s", entry);
	fp = fopen(path, "r");
	if (!fp)
		return false;
	while (fgets(buf, sizeof(buf), fp)) {
		buf[strcspn(buf, "\n")] = '\0';
		if (!strcmp(buf, line)) {
			found = true;
			break;
		}
	}
	fclose(fp);
	return found;
}

/* Mount binfmt_misc unless it already is, and report whether it is usable. */
static inline bool binfmt_misc_available(void)
{
	if (access(BINFMT_REG, F_OK) < 0)
		mount("binfmt_misc", BINFMT_DIR, "binfmt_misc", 0, NULL);
	return access(BINFMT_REG, F_OK) == 0;
}

/* Absolute path of @name in the directory this test was built into. */
static inline int artifact_path(char *out, size_t sz, const char *name)
{
	char exe[PATH_MAX];
	ssize_t n;

	n = readlink("/proc/self/exe", exe, sizeof(exe) - 1);
	if (n < 0)
		return -1;
	exe[n] = '\0';
	if ((size_t)snprintf(out, sz, "%s/%s", dirname(exe), name) >= sz)
		return -1;
	return 0;
}

/* Probe kernel support for a registration flag with a throwaway entry. */
static inline bool binfmt_flag_supported(char flag)
{
	char rule[64];

	snprintf(rule, sizeof(rule), ":bm_flag_probe:E::bmprobe::/bin/true:%c",
		 flag);
	if (write_reg(rule))
		return false;
	unregister("bm_flag_probe");
	return true;
}

/*
 * Run @path with the canonical payload argv and return its exit status, or
 * RUN_ENOEXEC when the exec itself was refused as unhandled.
 */
static inline int run_payload(const char *path)
{
	int status;
	pid_t pid;

	pid = fork();
	if (pid == 0) {
		execl(path, PAYLOAD_ARGV0, PAYLOAD_ARG1, PAYLOAD_ARG2,
		      (char *)NULL);
		_exit(errno == ENOEXEC ? RUN_ENOEXEC : 126);
	}
	if (pid < 0 || waitpid(pid, &status, 0) != pid || !WIFEXITED(status))
		return -1;
	return WEXITSTATUS(status);
}

/* Does the exe link name @path? */
static inline bool exe_is(const char *path)
{
	char exe[PATH_MAX], real[PATH_MAX];
	ssize_t n;

	n = readlink("/proc/self/exe", exe, sizeof(exe) - 1);
	if (n <= 0 || !realpath(path, real))
		return false;
	exe[n] = '\0';
	return !strcmp(exe, real);
}

/* Is comm @name truncated to what a comm can hold? */
static inline bool comm_is(const char *name)
{
	char comm[TASK_COMM_LEN + 2], expect[TASK_COMM_LEN];
	ssize_t n;
	int fd;

	fd = open("/proc/self/comm", O_RDONLY);
	if (fd < 0)
		return false;
	n = read(fd, comm, sizeof(comm) - 1);
	close(fd);
	if (n <= 0)
		return false;
	if (comm[n - 1] == '\n')
		n--;
	comm[n] = '\0';
	snprintf(expect, sizeof(expect), "%s", name);
	return !strcmp(comm, expect);
}

/* Opening @path for writing has to fail with ETXTBSY. */
static inline bool write_denied(const char *path)
{
	int fd = open(path, O_WRONLY);

	if (fd >= 0) {
		close(fd);
		return false;
	}
	return errno == ETXTBSY;
}

static inline int patch_file(const char *path, off_t off, const void *data, size_t len)
{
	ssize_t n;
	int fd;

	fd = open(path, O_WRONLY);
	if (fd < 0)
		return -1;
	n = pwrite(fd, data, len, off);
	close(fd);
	return n == (ssize_t)len ? 0 : -1;
}

/* start_code and end_code are the 26th and 27th fields of /proc/pid/stat. */
static inline int stat_codes(pid_t pid, unsigned long *start_code,
			     unsigned long *end_code)
{
	char buf[4096], path[64], *p;
	ssize_t n;
	int fd, i;

	snprintf(path, sizeof(path), "/proc/%d/stat", pid);
	fd = open(path, O_RDONLY);
	if (fd < 0)
		return -1;
	n = read(fd, buf, sizeof(buf) - 1);
	close(fd);
	if (n <= 0)
		return -1;
	buf[n] = '\0';

	/* Skip "pid (comm)", then start_code is the 24th field after it. */
	p = strrchr(buf, ')');
	if (!p)
		return -1;
	p++;
	for (i = 0; i < 23; i++) {
		p = strchr(p + 1, ' ');
		if (!p)
			return -1;
	}
	if (sscanf(p, " %lu %lu", start_code, end_code) != 2)
		return -1;
	return 0;
}

/* Find the system loader through our own PT_INTERP. */
static inline int find_loader(char *out, size_t sz)
{
	ElfW(Ehdr) eh;
	ElfW(Phdr) ph;
	int fd, i, ret = -1;

	fd = open("/proc/self/exe", O_RDONLY);
	if (fd < 0)
		return -1;
	if (pread(fd, &eh, sizeof(eh), 0) != sizeof(eh))
		goto out;
	for (i = 0; i < eh.e_phnum; i++) {
		if (pread(fd, &ph, sizeof(ph),
			  eh.e_phoff + i * eh.e_phentsize) != sizeof(ph))
			goto out;
		if (ph.p_type != PT_INTERP)
			continue;
		if (!ph.p_filesz || ph.p_filesz > sz)
			goto out;
		if (pread(fd, out, ph.p_filesz, ph.p_offset) !=
		    (ssize_t)ph.p_filesz)
			goto out;
		out[ph.p_filesz - 1] = '\0';
		ret = 0;
		break;
	}
out:
	close(fd);
	return ret;
}

#endif /* __SELFTESTS_EXEC_BINFMT_MISC_COMMON_H */