p5pRT
commented
20 years ago From zefram@fysh.org
Created by zefram@fysh.org
If a signal is caught\, and interrupts a system call\, and the Perl signal handler modifies $!\, then this replaces the EINTR from the system call. Simple test case:
BEGIN t0\<\<\< #!/usr/bin/perl
use warnings; use strict;
$SIG{TSTP} = sub { print "caught SIGTSTP\n"; $! = 0; };
my $a; my $n = sysread(STDIN\, $a\, 1); print "sysread returned "\, defined($n) ? $n : "undef"\, "; errno = "\, 0+$!\, " ("\, $!\, ")\n"; exit 0;
END t0\<\<\<
The program attempts to read one character\, and just displays what it gets back from sysread. To perform the test\, run the program from a terminal and ^Z while it's waiting for input. I get this behaviour:
$ ./t0 caught SIGTSTP sysread returned undef; errno = 0 () $
This is pretty surprising behaviour to the code that was calling sysread; returning undef with $! == 0 should be impossible.
The behaviour is perfectly understandable\, and probably someone is going to argue that it's correct. But it's inconsistent with the behaviour one gets in C. Here's the equivalent C program:
BEGIN t1.c\<\<\< #include \<stdio.h> #include \<stdlib.h> #include \<signal.h> #include \<unistd.h> #include \<errno.h>
void sigtstp(int signum) { printf("caught SIGTSTP\n"); errno = 0; }
int main(void) { struct sigaction act; char c; int n; act.sa_handler = sigtstp; sigemptyset(&act.sa_mask); act.sa_flags = 0; if(sigaction(SIGTSTP\, &act\, NULL)) { perror("sigaction"); exit(1); } n = read(0\, &c\, 1); printf("read returned %d; errno = %d (%s)\n"\, n\, errno\, strerror(errno)); exit(0); }
END t1.c\<\<\<
$ ./t1 caught SIGTSTP read returned -1; errno = 4 (Interrupted system call) $
Obviously the difference is just a question of where errno/$! is set. In C\, read() sets errno just before it returns\, whereas in Perl sysread() has errno set internally and then does other things\, such as invoking the signal handler\, before returning. I argue that $! should be saved and restored in this case\, so that $! *at the time that sysread() returns* accurately reflects the result of the system call.
Code such as I showed above still needs to save and restore errno/$! manually in the signal handler in order to cover all cases: being suspended immediately after [sys]read() returns and before errno/$! has been read is a possibility. However\, there are other situations where the order of events can be guaranteed\, and in such cases I think Perl should match the C semantics that it appears to offer.
Migrated from rt.perl.org#28824 (status was 'resolved')
Searchable as RT28824$