X-Git-Url: http://www.git.stargrave.org/?a=blobdiff_plain;f=lib%2FPublicInbox%2FSyscall.pm;h=a1f532353eab391020be7a94710433839fc2d278;hb=af0b0fb7a454470a32c452119d0392e0dedb3fe1;hp=da8a6c86f70c9acdbec94ad235f530afceec68e2;hpb=424723f76541180fc445d2b983691ef5de9655ec;p=public-inbox.git diff --git a/lib/PublicInbox/Syscall.pm b/lib/PublicInbox/Syscall.pm index da8a6c86..a1f53235 100644 --- a/lib/PublicInbox/Syscall.pm +++ b/lib/PublicInbox/Syscall.pm @@ -5,7 +5,7 @@ # This license differs from the rest of public-inbox # # This module is Copyright (c) 2005 Six Apart, Ltd. -# Copyright (C) 2019 all contributors +# Copyright (C) 2019-2021 all contributors # # All rights reserved. # @@ -13,35 +13,35 @@ # License or the Artistic License, as specified in the Perl README file. package PublicInbox::Syscall; use strict; -use POSIX qw(ENOSYS SEEK_CUR); +use parent qw(Exporter); +use POSIX qw(ENOSYS O_NONBLOCK); use Config; -require Exporter; -use vars qw(@ISA @EXPORT_OK %EXPORT_TAGS $VERSION); - -$VERSION = "0.25"; -@ISA = qw(Exporter); -@EXPORT_OK = qw(epoll_ctl epoll_create epoll_wait +# $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); -%EXPORT_TAGS = (epoll => [qw(epoll_ctl epoll_create epoll_wait + EPOLLONESHOT EPOLLEXCLUSIVE + signalfd SFD_NONBLOCK); +our %EXPORT_TAGS = (epoll => [qw(epoll_ctl epoll_create epoll_wait EPOLLIN EPOLLOUT EPOLL_CTL_ADD EPOLL_CTL_DEL EPOLL_CTL_MOD EPOLLONESHOT EPOLLEXCLUSIVE)], ); -use constant EPOLLIN => 1; -use constant EPOLLOUT => 4; -# use constant EPOLLERR => 8; -# use constant EPOLLHUP => 16; -# use constant EPOLLRDBAND => 128; -use constant EPOLLEXCLUSIVE => (1 << 28); -use constant EPOLLONESHOT => (1 << 30); -use constant EPOLLET => (1 << 31); -use constant EPOLL_CTL_ADD => 1; -use constant EPOLL_CTL_DEL => 2; -use constant EPOLL_CTL_MOD => 3; +use constant { + EPOLLIN => 1, + EPOLLOUT => 4, + # EPOLLERR => 8, + # EPOLLHUP => 16, + # EPOLLRDBAND => 128, + EPOLLEXCLUSIVE => (1 << 28), + EPOLLONESHOT => (1 << 30), + EPOLLET => (1 << 31), + EPOLL_CTL_ADD => 1, + EPOLL_CTL_DEL => 2, + EPOLL_CTL_MOD => 3, +}; our $loaded_syscall = 0; @@ -63,8 +63,11 @@ our ( $SYS_epoll_create, $SYS_epoll_ctl, $SYS_epoll_wait, + $SYS_signalfd4, ); +my $SFD_CLOEXEC = 02000000; # Perl does not expose O_CLOEXEC +sub SFD_NONBLOCK () { O_NONBLOCK } our $no_deprecated = 0; if ($^O eq "linux") { @@ -74,9 +77,9 @@ if ($^O eq "linux") { my $u64_mod_8 = 0; # if we're running on an x86_64 kernel, but a 32-bit process, - # we need to use the i386 syscall numbers. + # we need to use the x32 or i386 syscall numbers. if ($machine eq "x86_64" && $Config{ptrsize} == 4) { - $machine = "i386"; + $machine = $Config{cppsymbols} =~ /\b__ILP32__=1\b/ ? 'x32' : 'i386'; } # Similarly for mips64 vs mips @@ -88,63 +91,88 @@ if ($^O eq "linux") { $SYS_epoll_create = 254; $SYS_epoll_ctl = 255; $SYS_epoll_wait = 256; + $SYS_signalfd4 = 327; } elsif ($machine eq "x86_64") { $SYS_epoll_create = 213; $SYS_epoll_ctl = 233; $SYS_epoll_wait = 232; + $SYS_signalfd4 = 289; + } elsif ($machine eq 'x32') { + $SYS_epoll_create = 1073742037; + $SYS_epoll_ctl = 1073742057; + $SYS_epoll_wait = 1073742056; + $SYS_signalfd4 = 1073742113; + } elsif ($machine eq 'sparc64') { + $SYS_epoll_create = 193; + $SYS_epoll_ctl = 194; + $SYS_epoll_wait = 195; + $u64_mod_8 = 1; + $SYS_signalfd4 = 317; + $SFD_CLOEXEC = 020000000; } elsif ($machine =~ m/^parisc/) { $SYS_epoll_create = 224; $SYS_epoll_ctl = 225; $SYS_epoll_wait = 226; $u64_mod_8 = 1; + $SYS_signalfd4 = 309; } elsif ($machine =~ m/^ppc64/) { $SYS_epoll_create = 236; $SYS_epoll_ctl = 237; $SYS_epoll_wait = 238; $u64_mod_8 = 1; + $SYS_signalfd4 = 313; } elsif ($machine eq "ppc") { $SYS_epoll_create = 236; $SYS_epoll_ctl = 237; $SYS_epoll_wait = 238; $u64_mod_8 = 1; + $SYS_signalfd4 = 313; } elsif ($machine =~ m/^s390/) { $SYS_epoll_create = 249; $SYS_epoll_ctl = 250; $SYS_epoll_wait = 251; $u64_mod_8 = 1; + $SYS_signalfd4 = 322; } elsif ($machine eq "ia64") { $SYS_epoll_create = 1243; $SYS_epoll_ctl = 1244; $SYS_epoll_wait = 1245; $u64_mod_8 = 1; + $SYS_signalfd4 = 289; } elsif ($machine eq "alpha") { # natural alignment, ints are 32-bits $SYS_epoll_create = 407; $SYS_epoll_ctl = 408; $SYS_epoll_wait = 409; $u64_mod_8 = 1; + $SYS_signalfd4 = 484; + $SFD_CLOEXEC = 010000000; } elsif ($machine eq "aarch64") { $SYS_epoll_create = 20; # (sys_epoll_create1) $SYS_epoll_ctl = 21; $SYS_epoll_wait = 22; # (sys_epoll_pwait) $u64_mod_8 = 1; $no_deprecated = 1; + $SYS_signalfd4 = 74; } elsif ($machine =~ m/arm(v\d+)?.*l/) { # ARM OABI $SYS_epoll_create = 250; $SYS_epoll_ctl = 251; $SYS_epoll_wait = 252; $u64_mod_8 = 1; + $SYS_signalfd4 = 355; } elsif ($machine =~ m/^mips64/) { $SYS_epoll_create = 5207; $SYS_epoll_ctl = 5208; $SYS_epoll_wait = 5209; $u64_mod_8 = 1; + $SYS_signalfd4 = 5283; } elsif ($machine =~ m/^mips/) { $SYS_epoll_create = 4248; $SYS_epoll_ctl = 4249; $SYS_epoll_wait = 4250; $u64_mod_8 = 1; + $SYS_signalfd4 = 4324; } else { # as a last resort, try using the *.ph files which may not # exist or may be wrong @@ -152,6 +180,11 @@ if ($^O eq "linux") { $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. } if ($u64_mod_8) { @@ -194,38 +227,60 @@ sub epoll_ctl_mod8 { our $epoll_wait_events; our $epoll_wait_size = 0; sub epoll_wait_mod4 { - # resize our static buffer if requested size is bigger than we've ever done - if ($_[1] > $epoll_wait_size) { - $epoll_wait_size = $_[1]; - $epoll_wait_events = "\0" x 12 x $epoll_wait_size; - } - my $ct = syscall($SYS_epoll_wait, $_[0]+0, $epoll_wait_events, $_[1]+0, $_[2]+0); - for (0..$ct-1) { - @{$_[3]->[$_]}[1,0] = unpack("LL", substr($epoll_wait_events, 12*$_, 8)); - } - return $ct; + my ($epfd, $maxevents, $timeout_msec, $events) = @_; + # resize our static buffer if maxevents bigger than we've ever done + if ($maxevents > $epoll_wait_size) { + $epoll_wait_size = $maxevents; + vec($epoll_wait_events, $maxevents * 12 * 8 - 1, 1) = 0; + } + @$events = (); + my $ct = syscall($SYS_epoll_wait, $epfd, $epoll_wait_events, + $maxevents, $timeout_msec); + for (0..$ct - 1) { + # 12-byte struct epoll_event + # 4 bytes uint32_t events mask (skipped, useless to us) + # 8 bytes: epoll_data_t union (first 4 bytes are the fd) + # So we skip the first 4 bytes and take the middle 4: + $events->[$_] = unpack('L', substr($epoll_wait_events, + 12 * $_ + 4, 4)); + } } sub epoll_wait_mod8 { - # resize our static buffer if requested size is bigger than we've ever done - if ($_[1] > $epoll_wait_size) { - $epoll_wait_size = $_[1]; - $epoll_wait_events = "\0" x 16 x $epoll_wait_size; - } - my $ct; - if ($no_deprecated) { - $ct = syscall($SYS_epoll_wait, $_[0]+0, $epoll_wait_events, $_[1]+0, $_[2]+0, undef); - } else { - $ct = syscall($SYS_epoll_wait, $_[0]+0, $epoll_wait_events, $_[1]+0, $_[2]+0); - } - for (0..$ct-1) { - # 16 byte epoll_event structs, with format: - # 4 byte mask [idx 1] - # 4 byte padding (we put it into idx 2, useless) - # 8 byte data (first 4 bytes are fd, into idx 0) - @{$_[3]->[$_]}[1,2,0] = unpack("LLL", substr($epoll_wait_events, 16*$_, 12)); - } - return $ct; + my ($epfd, $maxevents, $timeout_msec, $events) = @_; + + # resize our static buffer if maxevents bigger than we've ever done + if ($maxevents > $epoll_wait_size) { + $epoll_wait_size = $maxevents; + vec($epoll_wait_events, $maxevents * 16 * 8 - 1, 1) = 0; + } + @$events = (); + my $ct = syscall($SYS_epoll_wait, $epfd, $epoll_wait_events, + $maxevents, $timeout_msec, + $no_deprecated ? undef : ()); + for (0..$ct - 1) { + # 16-byte struct epoll_event + # 4 bytes uint32_t events mask (skipped, useless to us) + # 4 bytes padding (skipped, useless) + # 8 bytes epoll_data_t union (first 4 bytes are the fd) + # So skip the first 8 bytes, take 4, and ignore the last 4: + $events->[$_] = unpack('L', substr($epoll_wait_events, + 16 * $_ + 8, 4)); + } +} + +sub signalfd ($$$) { + my ($fd, $signos, $flags) = @_; + if ($SYS_signalfd4) { + my $set = POSIX::SigSet->new(@$signos); + syscall($SYS_signalfd4, $fd, "$$set", + # $Config{sig_count} is NSIG, so this is NSIG/8: + int($Config{sig_count}/8), + $flags|$SFD_CLOEXEC); + } else { + $! = ENOSYS; + undef; + } } 1;