# fix upstream regressions in 0.25.
#
# See devel/syscall-list in the public-inbox source tree for maintenance
-# <https://80x24.org/public-inbox.git>
+# <https://80x24.org/public-inbox.git>, and machines from the GCC Farm:
+# <https://cfarm.tetaneutral.net/>
#
# This license differs from the rest of public-inbox
#
# You may distribute under the terms of either the GNU General Public
# License or the Artistic License, as specified in the Perl README file.
package PublicInbox::Syscall;
-use strict;
-use v5.10.1;
+use v5.12;
use parent qw(Exporter);
use POSIX qw(ENOENT ENOSYS EINVAL O_NONBLOCK);
use Socket qw(SOL_SOCKET SCM_RIGHTS);
use Config;
+our %SIGNUM = (WINCH => 28); # most Linux, {Free,Net,Open}BSD, *Darwin
# $VERSION = '0.25'; # Sys::Syscall version
our @EXPORT_OK = qw(epoll_ctl epoll_create epoll_wait
EPOLLIN EPOLLOUT EPOLLET
EPOLL_CTL_ADD EPOLL_CTL_DEL EPOLL_CTL_MOD
EPOLLONESHOT EPOLLEXCLUSIVE
- signalfd rename_noreplace);
+ signalfd rename_noreplace %SIGNUM);
our %EXPORT_TAGS = (epoll => [qw(epoll_ctl epoll_create epoll_wait
EPOLLIN EPOLLOUT
EPOLL_CTL_ADD EPOLL_CTL_DEL EPOLL_CTL_MOD
};
my @BYTES_4_hole = BYTES_4_hole ? (0) : ();
-our $loaded_syscall = 0;
-
-sub _load_syscall {
- # props to Gaal for this!
- return if $loaded_syscall++;
- my $clean = sub {
- delete @INC{qw<syscall.ph asm/unistd.ph bits/syscall.ph
- _h2ph_pre.ph sys/syscall.ph>};
- };
- $clean->(); # don't trust modules before us
- my $rv = eval { require 'syscall.ph'; 1 } || eval { require 'sys/syscall.ph'; 1 };
- $clean->(); # don't require modules after us trust us
- $rv;
-}
-
our (
$SYS_epoll_create,
# boundaries.
my $u64_mod_8 = 0;
- # if we're running on an x86_64 kernel, but a 32-bit process,
- # we need to use the x32 or i386 syscall numbers.
- if ($machine eq "x86_64" && $Config{ptrsize} == 4) {
- $machine = $Config{cppsymbols} =~ /\b__ILP32__=1\b/ ? 'x32' : 'i386';
- }
-
- # Similarly for mips64 vs mips
- if ($machine eq "mips64" && $Config{ptrsize} == 4) {
- $machine = "mips";
+ if ($Config{ptrsize} == 4) {
+ # if we're running on an x86_64 kernel, but a 32-bit process,
+ # we need to use the x32 or i386 syscall numbers.
+ if ($machine eq 'x86_64') {
+ my $s = $Config{cppsymbols};
+ $machine = ($s =~ /\b__ILP32__=1\b/ && $s =~ /\b__x86_64__=1\b/) ?
+ 'x32' : 'i386'
+ } elsif ($machine eq 'mips64') { # similarly for mips64 vs mips
+ $machine = 'mips';
+ }
}
if ($machine =~ m/^i[3456]86$/) {
$SYS_renameat2 //= 345;
$SFD_CLOEXEC = 020000000;
$SYS_fstatfs = 158;
+ $SYS_sendmsg = 114;
+ $SYS_recvmsg = 113;
$FS_IOC_GETFLAGS = 0x40086601;
$FS_IOC_SETFLAGS = 0x80086602;
} elsif ($machine =~ m/^parisc/) {
$SYS_epoll_wait = 226;
$u64_mod_8 = 1;
$SYS_signalfd4 = 309;
+ $SIGNUM{WINCH} = 23;
} elsif ($machine =~ m/^ppc64/) {
$SYS_epoll_create = 236;
$SYS_epoll_ctl = 237;
$SYS_signalfd4 = 313;
$SYS_renameat2 //= 357;
$SYS_fstatfs = 100;
+ $SYS_sendmsg = 341;
+ $SYS_recvmsg = 342;
$FS_IOC_GETFLAGS = 0x40086601;
$FS_IOC_SETFLAGS = 0x80086602;
} elsif ($machine eq "ppc") {
$SYS_fstatfs = 100;
$FS_IOC_GETFLAGS = 0x40086601;
$FS_IOC_SETFLAGS = 0x80086602;
- } elsif ($machine =~ m/^s390/) {
+ } elsif ($machine =~ m/^s390/) { # untested, no machine on cfarm
$SYS_epoll_create = 249;
$SYS_epoll_ctl = 250;
$SYS_epoll_wait = 251;
$SYS_signalfd4 = 322;
$SYS_renameat2 //= 347;
$SYS_fstatfs = 100;
- } elsif ($machine eq "ia64") {
+ $SYS_sendmsg = 370;
+ $SYS_recvmsg = 372;
+ } elsif ($machine eq 'ia64') { # untested, no machine on cfarm
$SYS_epoll_create = 1243;
$SYS_epoll_ctl = 1244;
$SYS_epoll_wait = 1245;
$u64_mod_8 = 1;
$SYS_signalfd4 = 289;
- } elsif ($machine eq "alpha") {
+ } elsif ($machine eq "alpha") { # untested, no machine on cfarm
# natural alignment, ints are 32-bits
$SYS_epoll_create = 407;
$SYS_epoll_ctl = 408;
$u64_mod_8 = 1;
$SYS_signalfd4 = 484;
$SFD_CLOEXEC = 010000000;
- } elsif ($machine eq "aarch64") {
+ } elsif ($machine =~ /\A(?:loong)?aarch64\z/ || $machine eq 'riscv64') {
$SYS_epoll_create = 20; # (sys_epoll_create1)
$SYS_epoll_ctl = 21;
$SYS_epoll_wait = 22; # (sys_epoll_pwait)
$SYS_signalfd4 = 74;
$SYS_renameat2 //= 276;
$SYS_fstatfs = 44;
+ $SYS_sendmsg = 211;
+ $SYS_recvmsg = 212;
$FS_IOC_GETFLAGS = 0x80086601;
$FS_IOC_SETFLAGS = 0x40086602;
- } elsif ($machine =~ m/arm(v\d+)?.*l/) {
- # ARM OABI
+ } elsif ($machine =~ m/arm(v\d+)?.*l/) { # ARM OABI (untested on cfarm)
$SYS_epoll_create = 250;
$SYS_epoll_ctl = 251;
$SYS_epoll_wait = 252;
$SYS_signalfd4 = 355;
$SYS_renameat2 //= 382;
$SYS_fstatfs = 100;
- } elsif ($machine =~ m/^mips64/) {
+ $SYS_sendmsg = 296;
+ $SYS_recvmsg = 297;
+ } elsif ($machine =~ m/^mips64/) { # cfarm only has 32-bit userspace
$SYS_epoll_create = 5207;
$SYS_epoll_ctl = 5208;
$SYS_epoll_wait = 5209;
$SYS_signalfd4 = 5283;
$SYS_renameat2 //= 5311;
$SYS_fstatfs = 5135;
+ $SYS_sendmsg = 5045;
+ $SYS_recvmsg = 5046;
$FS_IOC_GETFLAGS = 0x40046601;
$FS_IOC_SETFLAGS = 0x80046602;
- } elsif ($machine =~ m/^mips/) {
+ } elsif ($machine =~ m/^mips/) { # 32-bit, tested on mips64 cfarm machine
$SYS_epoll_create = 4248;
$SYS_epoll_ctl = 4249;
$SYS_epoll_wait = 4250;
$SYS_signalfd4 = 4324;
$SYS_renameat2 //= 4351;
$SYS_fstatfs = 4100;
+ $SYS_sendmsg = 4179;
+ $SYS_recvmsg = 4177;
$FS_IOC_GETFLAGS = 0x40046601;
$FS_IOC_SETFLAGS = 0x80046602;
+ $SIGNUM{WINCH} = 20;
} else {
- # as a last resort, try using the *.ph files which may not
- # exist or may be wrong
- _load_syscall();
- $SYS_epoll_create = eval { &SYS_epoll_create; } || 0;
- $SYS_epoll_ctl = eval { &SYS_epoll_ctl; } || 0;
- $SYS_epoll_wait = eval { &SYS_epoll_wait; } || 0;
-
- # Note: do NOT add new syscalls to depend on *.ph, here.
- # Better to miss syscalls (so we can fallback to IO::Poll)
- # than to use wrong ones, since the names are not stable
- # (at least not on FreeBSD), if the actual numbers are.
+ warn <<EOM;
+machine=$machine ptrsize=$Config{ptrsize} has no syscall definitions
+git clone https://80x24.org/public-inbox.git and
+Send the output of ./devel/syscall-list to meta\@public-inbox.org
+EOM
}
-
if ($u64_mod_8) {
*epoll_wait = \&epoll_wait_mod8;
*epoll_ctl = \&epoll_ctl_mod8;
}
# use Inline::C for *BSD-only or general POSIX stuff.
# Linux guarantees stable syscall numbering, BSDs only offer a stable libc
-# use scripts/syscall-list on Linux to detect new syscall numbers
+# use devel/syscall-list on Linux to detect new syscall numbers
############################################################################
# epoll functions
############################################################################
-sub epoll_defined { $SYS_epoll_create ? 1 : 0; }
-
sub epoll_create {
syscall($SYS_epoll_create, $no_deprecated ? 0 : 100);
}
}
}
-sub nodatacow_fh {
- return if !defined($SYS_fstatfs);
- my $buf = '';
- vec($buf, 120 * 8 - 1, 1) = 0;
+sub nodatacow_fh ($) {
my ($fh) = @_;
- syscall($SYS_fstatfs, fileno($fh), $buf) == 0 or
+ my $buf = "\0" x 120;
+ syscall($SYS_fstatfs // return, fileno($fh), $buf) == 0 or
return warn("fstatfs: $!\n");
my $f_type = unpack('l!', $buf); # statfs.f_type is a signed word
return if $f_type != 0x9123683E; # BTRFS_SUPER_MAGIC
use constant CMSG_ALIGN_SIZEOF_cmsghdr => CMSG_ALIGN(SIZEOF_cmsghdr);
sub CMSG_SPACE ($) { CMSG_ALIGN($_[0]) + CMSG_ALIGN_SIZEOF_cmsghdr }
sub CMSG_LEN ($) { CMSG_ALIGN_SIZEOF_cmsghdr + $_[0] }
+use constant msg_controllen => CMSG_SPACE(10 * SIZEOF_int) + 16; # 10 FDs
if (defined($SYS_sendmsg) && defined($SYS_recvmsg)) {
no warnings 'once';
*recv_cmd4 = sub ($$$) {
my ($sock, undef, $len) = @_;
- vec($_[1], ($len + 1) * 8, 1) = 0;
- vec(my $cmsghdr = '', 256 * 8 - 1, 1) = 1;
+ vec($_[1] //= '', ($len + 1) * 8, 1) = 0;
+ my $cmsghdr = "\0" x msg_controllen; # 10 * sizeof(int)
my $iov = pack('P'.TMPL_size_t, $_[1], $len);
my $mh = pack('PL' . # msg_name, msg_namelen (socklen_t (U32))
BYTES_4_hole . # 4-byte padding on 64-bit
@BYTES_4_hole,
$iov, 1, # msg_iov, msg_iovlen
$cmsghdr, # msg_control
- 256, # msg_controllen
+ msg_controllen,
0); # msg_flags
my $r = syscall($SYS_recvmsg, fileno($sock), $mh, 0);
return (undef) if $r < 0; # $! set