175 lines
3.8 KiB
C
175 lines
3.8 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* Test that a syscall does not get restarted twice, handled by trap_norestart()
|
|
*
|
|
* Based on Al's description, and a test for the bug fixed in this commit:
|
|
*
|
|
* commit 9a81c16b527528ad307843be5571111aa8d35a80
|
|
* Author: Al Viro <viro@zeniv.linux.org.uk>
|
|
* Date: Mon Sep 20 21:48:57 2010 +0100
|
|
*
|
|
* powerpc: fix double syscall restarts
|
|
*
|
|
* Make sigreturn zero regs->trap, make do_signal() do the same on all
|
|
* paths. As it is, signal interrupting e.g. read() from fd 512 (==
|
|
* ERESTARTSYS) with another signal getting unblocked when the first
|
|
* handler finishes will lead to restart one insn earlier than it ought
|
|
* to. Same for multiple signals with in-kernel handlers interrupting
|
|
* that sucker at the same time. Same for multiple signals of any kind
|
|
* interrupting that sucker on 64bit...
|
|
*/
|
|
#define _GNU_SOURCE
|
|
#include <sys/types.h>
|
|
#include <sys/wait.h>
|
|
#include <sys/syscall.h>
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
#include <errno.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include "utils.h"
|
|
|
|
static void SIGUSR1_handler(int sig)
|
|
{
|
|
kill(getpid(), SIGUSR2);
|
|
/*
|
|
* SIGUSR2 is blocked until the handler exits, at which point it will
|
|
* be raised again and think there is a restart to be done because the
|
|
* pending restarted syscall has 512 (ERESTARTSYS) in r3. The second
|
|
* restart will retreat NIP another 4 bytes to fail case branch.
|
|
*/
|
|
}
|
|
|
|
static void SIGUSR2_handler(int sig)
|
|
{
|
|
}
|
|
|
|
static ssize_t raw_read(int fd, void *buf, size_t count)
|
|
{
|
|
register long nr asm("r0") = __NR_read;
|
|
register long _fd asm("r3") = fd;
|
|
register void *_buf asm("r4") = buf;
|
|
register size_t _count asm("r5") = count;
|
|
|
|
asm volatile(
|
|
" b 0f \n"
|
|
" b 1f \n"
|
|
" 0: sc 0 \n"
|
|
" bns 2f \n"
|
|
" neg %0,%0 \n"
|
|
" b 2f \n"
|
|
" 1: \n"
|
|
" li %0,%4 \n"
|
|
" 2: \n"
|
|
: "+r"(_fd), "+r"(nr), "+r"(_buf), "+r"(_count)
|
|
: "i"(-ENOANO)
|
|
: "memory", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "ctr", "cr0");
|
|
|
|
if (_fd < 0) {
|
|
errno = -_fd;
|
|
_fd = -1;
|
|
}
|
|
|
|
return _fd;
|
|
}
|
|
|
|
#define DATA "test 123"
|
|
#define DLEN (strlen(DATA)+1)
|
|
|
|
int test_restart(void)
|
|
{
|
|
int pipefd[2];
|
|
pid_t pid;
|
|
char buf[512];
|
|
|
|
if (pipe(pipefd) == -1) {
|
|
perror("pipe");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
pid = fork();
|
|
if (pid == -1) {
|
|
perror("fork");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
if (pid == 0) { /* Child reads from pipe */
|
|
struct sigaction act;
|
|
int fd;
|
|
|
|
memset(&act, 0, sizeof(act));
|
|
sigaddset(&act.sa_mask, SIGUSR2);
|
|
act.sa_handler = SIGUSR1_handler;
|
|
act.sa_flags = SA_RESTART;
|
|
if (sigaction(SIGUSR1, &act, NULL) == -1) {
|
|
perror("sigaction");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
memset(&act, 0, sizeof(act));
|
|
act.sa_handler = SIGUSR2_handler;
|
|
act.sa_flags = SA_RESTART;
|
|
if (sigaction(SIGUSR2, &act, NULL) == -1) {
|
|
perror("sigaction");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
/* Let's get ERESTARTSYS into r3 */
|
|
while ((fd = dup(pipefd[0])) != 512) {
|
|
if (fd == -1) {
|
|
perror("dup");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
if (raw_read(fd, buf, 512) == -1) {
|
|
if (errno == ENOANO) {
|
|
fprintf(stderr, "Double restart moved restart before sc instruction.\n");
|
|
_exit(EXIT_FAILURE);
|
|
}
|
|
perror("read");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
if (strncmp(buf, DATA, DLEN)) {
|
|
fprintf(stderr, "bad test string %s\n", buf);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
int wstatus;
|
|
|
|
usleep(100000); /* Hack to get reader waiting */
|
|
kill(pid, SIGUSR1);
|
|
usleep(100000);
|
|
if (write(pipefd[1], DATA, DLEN) != DLEN) {
|
|
perror("write");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
close(pipefd[0]);
|
|
close(pipefd[1]);
|
|
if (wait(&wstatus) == -1) {
|
|
perror("wait");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
if (!WIFEXITED(wstatus)) {
|
|
fprintf(stderr, "child exited abnormally\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
FAIL_IF(WEXITSTATUS(wstatus) != EXIT_SUCCESS);
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
test_harness_set_timeout(10);
|
|
return test_harness(test_restart, "sig sys restart");
|
|
}
|