-# Copyright (C) 2016-2019 all contributors <meta@public-inbox.org>
+# Copyright (C) 2016-2020 all contributors <meta@public-inbox.org>
# License: AGPL-3.0+ <https://www.gnu.org/licenses/agpl-3.0.txt>
#
# This allows vfork to be used for spawning subprocesses if
-# PERL_INLINE_DIRECTORY is explicitly defined in the environment.
+# ~/.cache/public-inbox/inline-c is writable or if PERL_INLINE_DIRECTORY
+# is explicitly defined in the environment (and writable).
# Under Linux, vfork can make a big difference in spawning performance
# as process size increases (fork still needs to mark pages for CoW use).
# Currently, we only use this for code intended for long running
package PublicInbox::Spawn;
use strict;
-use warnings;
-use base qw(Exporter);
+use parent qw(Exporter);
use Symbol qw(gensym);
-use IO::Handle;
use PublicInbox::ProcessPipe;
our @EXPORT_OK = qw/which spawn popen_rd/;
-sub RLIMITS () { qw(RLIMIT_CPU RLIMIT_CORE RLIMIT_DATA) }
+our @RLIMITS = qw(RLIMIT_CPU RLIMIT_CORE RLIMIT_DATA);
my $vfork_spawn = <<'VFORK_SPAWN';
#include <sys/types.h>
-#include <sys/uio.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <unistd.h>
dst[real_len] = 0; \
} while (0)
-static void *deconst(const char *s)
-{
- union { const char *in; void *out; } u;
- u.in = s;
- return u.out;
-}
-
/* needs to be safe inside a vfork'ed process */
-static void xerr(const char *msg)
+static void exit_err(int *cerrnum)
{
- struct iovec iov[3];
- const char *err = strerror(errno); /* should be safe in practice */
-
- iov[0].iov_base = deconst(msg);
- iov[0].iov_len = strlen(msg);
- iov[1].iov_base = deconst(err);
- iov[1].iov_len = strlen(err);
- iov[2].iov_base = deconst("\n");
- iov[2].iov_len = 1;
- writev(2, iov, 3);
+ *cerrnum = errno;
_exit(1);
}
* whatever we'll need in the future.
* Be sure to update PublicInbox::SpawnPP if this changes
*/
-int pi_fork_exec(SV *redirref, SV *file, SV *cmdref, SV *envref, SV *rlimref)
+int pi_fork_exec(SV *redirref, SV *file, SV *cmdref, SV *envref, SV *rlimref,
+ const char *cd)
{
AV *redir = (AV *)SvRV(redirref);
AV *cmd = (AV *)SvRV(cmdref);
const char *filename = SvPV_nolen(file);
pid_t pid;
char **argv, **envp;
- sigset_t set, old;
- int ret, errnum;
+ sigset_t set, old, cset;
+ int ret, perrnum, cerrnum = 0;
AV2C_COPY(argv, cmd);
AV2C_COPY(envp, env);
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");
pid = vfork();
if (pid == 0) {
int sig;
if (parent_fd == child_fd)
continue;
if (dup2(parent_fd, child_fd) < 0)
- xerr("dup2");
+ exit_err(&cerrnum);
}
for (sig = 1; sig < NSIG; sig++)
signal(sig, SIG_DFL); /* ignore errors on signals */
+ if (*cd && chdir(cd) < 0)
+ exit_err(&cerrnum);
max = av_len(rlim);
for (i = 0; i < max; i += 3) {
rl.rlim_cur = SvIV(*soft);
rl.rlim_max = SvIV(*hard);
if (setrlimit(SvIV(*res), &rl) < 0)
- xerr("sertlimit");
+ exit_err(&cerrnum);
}
/*
- * don't bother unblocking, we don't want signals
- * to the group taking out a subprocess
+ * 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);
execve(filename, argv, envp);
- xerr("execve failed");
+ exit_err(&cerrnum);
}
- errnum = errno;
+ perrnum = errno;
ret = sigprocmask(SIG_SETMASK, &old, NULL);
assert(ret == 0 && "BUG calling sigprocmask to restore");
- errno = errnum;
-
+ if (cerrnum) {
+ if (pid > 0)
+ waitpid(pid, NULL, 0);
+ pid = -1;
+ errno = cerrnum;
+ } else if (perrnum) {
+ errno = perrnum;
+ }
return (int)pid;
}
VFORK_SPAWN
-my $inline_dir = $ENV{PERL_INLINE_DIRECTORY};
-$vfork_spawn = undef unless defined $inline_dir && -d $inline_dir && -w _;
+my $inline_dir = $ENV{PERL_INLINE_DIRECTORY} //= (
+ $ENV{XDG_CACHE_HOME} //
+ ( ($ENV{HOME} // '/nonexistent').'/.cache' )
+ ).'/public-inbox/inline-c';
+
+$vfork_spawn = 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
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'; #, BUILD_NOISY => 1';
+ eval 'use Inline C => $vfork_spawn';
my $err = $@;
flock($fh, LOCK_UN) or die "LOCK_UN failed on $f: $!\n";
die $err if $err;
}
my $rlim = [];
- foreach my $l (RLIMITS()) {
+ foreach my $l (@RLIMITS) {
defined(my $v = $opts->{$l}) or next;
my $r = eval "require BSD::Resource; BSD::Resource::$l();";
unless (defined $r) {
}
push @$rlim, $r, @$v;
}
- my $pid = pi_fork_exec($redir, $f, $cmd, \@env, $rlim);
- $pid < 0 ? undef : $pid;
+ my $cd = $opts->{'-C'} // ''; # undef => NULL mapping doesn't work?
+ my $pid = pi_fork_exec($redir, $f, $cmd, \@env, $rlim, $cd);
+ die "fork_exec failed: $!\n" unless $pid > 0;
+ $pid;
}
sub popen_rd {
$opts ||= {};
$opts->{1} = fileno($w);
my $pid = spawn($cmd, $env, $opts);
- return unless defined $pid;
return ($r, $pid) if wantarray;
my $ret = gensym;
tie *$ret, 'PublicInbox::ProcessPipe', $pid, $r;