X-Git-Url: http://www.git.stargrave.org/?a=blobdiff_plain;f=lib%2FPublicInbox%2FSpawn.pm;h=137b80878a35bced4a0735542908190d3dce1d92;hb=14fa0abdcc7b6513540e529375e53edd74ce13e8;hp=376d219096e7d66d3e781f3e3cf1030c2791ed54;hpb=90de75619d2ec8a59c265fd8f2c6cc1d4a7daba2;p=public-inbox.git diff --git a/lib/PublicInbox/Spawn.pm b/lib/PublicInbox/Spawn.pm index 376d2190..137b8087 100644 --- a/lib/PublicInbox/Spawn.pm +++ b/lib/PublicInbox/Spawn.pm @@ -1,4 +1,4 @@ -# Copyright (C) 2016-2021 all contributors +# Copyright (C) all contributors # License: AGPL-3.0+ # # This allows vfork to be used for spawning subprocesses if @@ -18,17 +18,25 @@ package PublicInbox::Spawn; use strict; use parent qw(Exporter); use Symbol qw(gensym); +use Fcntl qw(LOCK_EX SEEK_SET); +use IO::Handle (); use PublicInbox::ProcessPipe; -our @EXPORT_OK = qw(which spawn popen_rd run_die nodatacow_dir); +our @EXPORT_OK = qw(which spawn popen_rd run_die); our @RLIMITS = qw(RLIMIT_CPU RLIMIT_CORE RLIMIT_DATA); -my $vfork_spawn = <<'VFORK_SPAWN'; +BEGIN { + my $all_libc = <<'ALL_LIBC'; # all *nix systems we support +#include +#include #include #include -#include +#include #include #include #include +#include +#include +#include /* some platforms need alloca.h, but some don't */ #if defined(__GNUC__) && !defined(alloca) @@ -59,9 +67,10 @@ my $vfork_spawn = <<'VFORK_SPAWN'; } while (0) /* needs to be safe inside a vfork'ed process */ -static void exit_err(int *cerrnum) +static void exit_err(const char *fn, volatile int *cerrnum) { *cerrnum = errno; + write(2, fn, strlen(fn)); _exit(1); } @@ -71,7 +80,7 @@ static void exit_err(int *cerrnum) * Be sure to update PublicInbox::SpawnPP if this changes */ int pi_fork_exec(SV *redirref, SV *file, SV *cmdref, SV *envref, SV *rlimref, - const char *cd) + const char *cd, int pgid) { AV *redir = (AV *)SvRV(redirref); AV *cmd = (AV *)SvRV(cmdref); @@ -80,40 +89,44 @@ int pi_fork_exec(SV *redirref, SV *file, SV *cmdref, SV *envref, SV *rlimref, const char *filename = SvPV_nolen(file); pid_t pid; char **argv, **envp; - sigset_t set, old, cset; - int ret, perrnum, cerrnum = 0; + sigset_t set, old; + int ret, perrnum; + volatile int cerrnum = 0; /* shared due to vfork */ + int chld_is_member; + I32 max_fd = av_len(redir); AV2C_COPY(argv, cmd); AV2C_COPY(envp, env); - ret = sigfillset(&set); - assert(ret == 0 && "BUG calling sigfillset"); - ret = sigprocmask(SIG_SETMASK, &set, &old); - assert(ret == 0 && "BUG calling sigprocmask to block"); - ret = sigemptyset(&cset); - assert(ret == 0 && "BUG calling sigemptyset"); - ret = sigaddset(&cset, SIGCHLD); - assert(ret == 0 && "BUG calling sigaddset for SIGCHLD"); + if (sigfillset(&set)) return -1; + if (sigprocmask(SIG_SETMASK, &set, &old)) return -1; + chld_is_member = sigismember(&old, SIGCHLD); + if (chld_is_member < 0) return -1; + if (chld_is_member > 0) + sigdelset(&old, SIGCHLD); + pid = vfork(); if (pid == 0) { int sig; - I32 i, child_fd, max = av_len(redir); + I32 i, child_fd, max_rlim; - for (child_fd = 0; child_fd <= max; child_fd++) { + for (child_fd = 0; child_fd <= max_fd; child_fd++) { SV **parent = av_fetch(redir, child_fd, 0); int parent_fd = SvIV(*parent); if (parent_fd == child_fd) continue; if (dup2(parent_fd, child_fd) < 0) - exit_err(&cerrnum); + exit_err("dup2", &cerrnum); } + if (pgid >= 0 && setpgid(0, pgid) < 0) + exit_err("setpgid", &cerrnum); for (sig = 1; sig < NSIG; sig++) signal(sig, SIG_DFL); /* ignore errors on signals */ if (*cd && chdir(cd) < 0) - exit_err(&cerrnum); + exit_err("chdir", &cerrnum); - max = av_len(rlim); - for (i = 0; i < max; i += 3) { + max_rlim = av_len(rlim); + for (i = 0; i < max_rlim; i += 3) { struct rlimit rl; SV **res = av_fetch(rlim, i, 0); SV **soft = av_fetch(rlim, i + 1, 0); @@ -122,94 +135,54 @@ int pi_fork_exec(SV *redirref, SV *file, SV *cmdref, SV *envref, SV *rlimref, rl.rlim_cur = SvIV(*soft); rl.rlim_max = SvIV(*hard); if (setrlimit(SvIV(*res), &rl) < 0) - exit_err(&cerrnum); + exit_err("setrlimit", &cerrnum); } - /* - * don't bother unblocking other signals for now, just SIGCHLD. - * we don't want signals to the group taking out a subprocess - */ - (void)sigprocmask(SIG_UNBLOCK, &cset, NULL); + (void)sigprocmask(SIG_SETMASK, &old, NULL); execve(filename, argv, envp); - exit_err(&cerrnum); + exit_err("execve", &cerrnum); } perrnum = errno; + if (chld_is_member > 0) + sigaddset(&old, SIGCHLD); ret = sigprocmask(SIG_SETMASK, &old, NULL); assert(ret == 0 && "BUG calling sigprocmask to restore"); if (cerrnum) { + int err_fd = STDERR_FILENO; + if (err_fd <= max_fd) { + SV **parent = av_fetch(redir, err_fd, 0); + err_fd = SvIV(*parent); + } if (pid > 0) waitpid(pid, NULL, 0); pid = -1; + /* continue message started by exit_err in child */ + dprintf(err_fd, ": %s\n", strerror(cerrnum)); errno = cerrnum; } else if (perrnum) { errno = perrnum; } return (int)pid; } -VFORK_SPAWN -# btrfs on Linux is copy-on-write (COW) by default. As of Linux 5.7, -# this still leads to fragmentation for SQLite and Xapian files where -# random I/O happens, so we disable COW just for SQLite files and Xapian -# directories. Disabling COW disables checksumming, so we only do this -# for regeneratable files, and not canonical git storage (git doesn't -# checksum refs, only data under $GIT_DIR/objects). -my $set_nodatacow = $^O eq 'linux' ? <<'SET_NODATACOW' : ''; -#include -#include -#include -#include -#include -#include -#include -#include - -void nodatacow_fd(int fd) +static int sleep_wait(unsigned *tries, int err) { - struct statfs buf; - int val = 0; - - if (fstatfs(fd, &buf) < 0) { - fprintf(stderr, "fstatfs: %s\\n", strerror(errno)); - return; - } - - /* only btrfs is known to have this problem, so skip for non-btrfs */ - if (buf.f_type != BTRFS_SUPER_MAGIC) - return; - - if (ioctl(fd, FS_IOC_GETFLAGS, &val) < 0) { - fprintf(stderr, "FS_IOC_GET_FLAGS: %s\\n", strerror(errno)); - return; + const struct timespec req = { 0, 100000000 }; /* 100ms */ + switch (err) { + case ENOBUFS: case ENOMEM: case ETOOMANYREFS: + if (++*tries < 50) { + fprintf(stderr, "sleeping on sendmsg: %s (#%u)\n", + strerror(err), *tries); + nanosleep(&req, NULL); + return 1; + } + default: + return 0; } - val |= FS_NOCOW_FL; - if (ioctl(fd, FS_IOC_SETFLAGS, &val) < 0) - fprintf(stderr, "FS_IOC_SET_FLAGS: %s\\n", strerror(errno)); } -void nodatacow_dir(const char *dir) -{ - DIR *dh = opendir(dir); - int fd; - - if (!dh) croak("opendir(%s): %s", dir, strerror(errno)); - fd = dirfd(dh); - if (fd >= 0) - nodatacow_fd(fd); - /* ENOTSUP probably won't happen under Linux... */ - closedir(dh); -} -SET_NODATACOW - -# last choice for script/lei, 1st choice for lei internals -# compatible with PublicInbox::CmdIPC4 -my $fdpass = <<'FDPASS'; -#include -#include -#include - #if defined(CMSG_SPACE) && defined(CMSG_LEN) -#define SEND_FD_CAPA 6 +#define SEND_FD_CAPA 10 #define SEND_FD_SPACE (SEND_FD_CAPA * sizeof(int)) union my_cmsg { struct cmsghdr hdr; @@ -226,6 +199,7 @@ SV *send_cmd4(PerlIO *s, SV *svfds, SV *data, int flags) AV *fds = (AV *)SvRV(svfds); I32 i, nfds = av_len(fds) + 1; int *fdp; + unsigned tries = 0; if (SvOK(data)) { iov.iov_base = SvPV(data, dlen); @@ -253,7 +227,9 @@ SV *send_cmd4(PerlIO *s, SV *svfds, SV *data, int flags) *fdp++ = SvIV(*fd); } } - sent = sendmsg(PerlIO_fileno(s), &msg, flags); + do { + sent = sendmsg(PerlIO_fileno(s), &msg, flags); + } while (sent < 0 && sleep_wait(&tries, errno)); return sent >= 0 ? newSViv(sent) : &PL_sv_undef; } @@ -290,60 +266,52 @@ void recv_cmd4(PerlIO *s, SV *buf, STRLEN n) Inline_Stack_Done; } #endif /* defined(CMSG_SPACE) && defined(CMSG_LEN) */ -FDPASS - -my $inline_dir = $ENV{PERL_INLINE_DIRECTORY} //= ( - $ENV{XDG_CACHE_HOME} // - ( ($ENV{HOME} // '/nonexistent').'/.cache' ) - ).'/public-inbox/inline-c'; - -$set_nodatacow = $vfork_spawn = $fdpass = undef unless -d $inline_dir && -w _; -if (defined $vfork_spawn) { - # Inline 0.64 or later has locking in multi-process env, - # but we support 0.5 on Debian wheezy - use Fcntl qw(:flock); - eval { +ALL_LIBC + + my $inline_dir = $ENV{PERL_INLINE_DIRECTORY} //= ( + $ENV{XDG_CACHE_HOME} // + ( ($ENV{HOME} // '/nonexistent').'/.cache' ) + ).'/public-inbox/inline-c'; + warn "$inline_dir exists, not writable\n" if -e $inline_dir && !-w _; + $all_libc = undef unless -d _ && -w _; + if (defined $all_libc) { my $f = "$inline_dir/.public-inbox.lock"; - open my $fh, '>', $f or die "failed to open $f: $!\n"; - flock($fh, LOCK_EX) or die "LOCK_EX failed on $f: $!\n"; - eval 'use Inline C => $vfork_spawn.$fdpass.$set_nodatacow'; - # . ', BUILD_NOISY => 1'; + open my $oldout, '>&', \*STDOUT or die "dup(1): $!"; + open my $olderr, '>&', \*STDERR or die "dup(2): $!"; + open my $fh, '+>', $f or die "open($f): $!"; + open STDOUT, '>&', $fh or die "1>$f: $!"; + open STDERR, '>&', $fh or die "2>$f: $!"; + STDERR->autoflush(1); + STDOUT->autoflush(1); + + # CentOS 7.x ships Inline 0.53, 0.64+ has built-in locking + flock($fh, LOCK_EX) or die "LOCK_EX($f): $!"; + eval <<'EOM'; +use Inline C => $all_libc, BUILD_NOISY => 1; +EOM my $err = $@; - my $ndc_err; - if ($err && $set_nodatacow) { # missing Linux kernel headers - $ndc_err = $err; - undef $set_nodatacow; - eval 'use Inline C => $vfork_spawn . $fdpass'; + my $ndc_err = ''; + $err = $@; + open(STDERR, '>&', $olderr) or warn "restore stderr: $!"; + open(STDOUT, '>&', $oldout) or warn "restore stdout: $!"; + if ($err) { + seek($fh, 0, SEEK_SET); + my @msg = <$fh>; + warn "Inline::C build failed:\n", + $ndc_err, $err, "\n", @msg; + $all_libc = undef; } - flock($fh, LOCK_UN) or die "LOCK_UN failed on $f: $!\n"; - die $err if $err; - warn $ndc_err if $ndc_err; - }; - if ($@) { - warn "Inline::C failed for vfork: $@\n"; - $set_nodatacow = $vfork_spawn = $fdpass = undef; } -} - -unless (defined $vfork_spawn) { - require PublicInbox::SpawnPP; - *pi_fork_exec = \&PublicInbox::SpawnPP::pi_fork_exec -} -unless ($set_nodatacow) { - require PublicInbox::NDC_PP; - no warnings 'once'; - *nodatacow_fd = \&PublicInbox::NDC_PP::nodatacow_fd; - *nodatacow_dir = \&PublicInbox::NDC_PP::nodatacow_dir; -} - -undef $set_nodatacow; -undef $vfork_spawn; -undef $fdpass; + unless ($all_libc) { + require PublicInbox::SpawnPP; + *pi_fork_exec = \&PublicInbox::SpawnPP::pi_fork_exec + } +} # /BEGIN sub which ($) { my ($file) = @_; return $file if index($file, '/') >= 0; - foreach my $p (split(':', $ENV{PATH})) { + for my $p (split(/:/, $ENV{PATH})) { $p .= "/$file"; return $p if -x $p; } @@ -352,20 +320,18 @@ sub which ($) { sub spawn ($;$$) { my ($cmd, $env, $opts) = @_; - my $f = which($cmd->[0]); - defined $f or die "$cmd->[0]: command not found\n"; + my $f = which($cmd->[0]) // die "$cmd->[0]: command not found\n"; my @env; $opts ||= {}; - - my %env = $env ? (%ENV, %$env) : %ENV; + my %env = (%ENV, $env ? %$env : ()); while (my ($k, $v) = each %env) { - push @env, "$k=$v"; + push @env, "$k=$v" if defined($v); } my $redir = []; for my $child_fd (0..2) { my $parent_fd = $opts->{$child_fd}; if (defined($parent_fd) && $parent_fd !~ /\A[0-9]+\z/) { - defined(my $fd = fileno($parent_fd)) or + my $fd = fileno($parent_fd) // die "$parent_fd not an IO GLOB? $!"; $parent_fd = $fd; } @@ -374,7 +340,7 @@ sub spawn ($;$$) { my $rlim = []; foreach my $l (@RLIMITS) { - defined(my $v = $opts->{$l}) or next; + my $v = $opts->{$l} // next; my $r = eval "require BSD::Resource; BSD::Resource::$l();"; unless (defined $r) { warn "$l undefined by BSD::Resource: $@\n"; @@ -383,7 +349,8 @@ sub spawn ($;$$) { push @$rlim, $r, @$v; } my $cd = $opts->{'-C'} // ''; # undef => NULL mapping doesn't work? - my $pid = pi_fork_exec($redir, $f, $cmd, \@env, $rlim, $cd); + my $pgid = $opts->{pgid} // -1; + my $pid = pi_fork_exec($redir, $f, $cmd, \@env, $rlim, $cd, $pgid); die "fork_exec @$cmd failed: $!\n" unless $pid > 0; $pid; }