From 899e1c78900e6893abdee4d932600a037fe7f64a Mon Sep 17 00:00:00 2001 From: Joakim Date: Sun, 17 Feb 2019 15:39:05 +0530 Subject: [PATCH] ninja: Update from 1.8.2 to 1.9.0 and switch to posix_spawn from Bionic 9. --- build-package.sh | 5 +- packages/ninja/build.sh | 5 +- packages/ninja/configure.py.patch | 2 +- packages/ninja/src-posix_spawn.c.patch | 162 -------- packages/ninja/src-posix_spawn.h.patch | 59 --- packages/ninja/src-spawn.cc.patch | 387 +++++++++++++++++++ packages/ninja/src-spawn.h.patch | 96 +++++ packages/ninja/src-subprocess-posix.cc.patch | 61 +-- 8 files changed, 499 insertions(+), 278 deletions(-) delete mode 100644 packages/ninja/src-posix_spawn.c.patch delete mode 100644 packages/ninja/src-posix_spawn.h.patch create mode 100644 packages/ninja/src-spawn.cc.patch create mode 100644 packages/ninja/src-spawn.h.patch diff --git a/build-package.sh b/build-package.sh index 0b2d1db3f..7926175c9 100755 --- a/build-package.sh +++ b/build-package.sh @@ -116,15 +116,16 @@ termux_setup_rust() { # Utility function to setup a current ninja build system. termux_setup_ninja() { - local NINJA_VERSION=1.8.2 + local NINJA_VERSION=1.9.0 local NINJA_FOLDER=$TERMUX_COMMON_CACHEDIR/ninja-$NINJA_VERSION if [ ! -x "$NINJA_FOLDER/ninja" ]; then mkdir -p "$NINJA_FOLDER" local NINJA_ZIP_FILE=$TERMUX_PKG_TMPDIR/ninja-$NINJA_VERSION.zip termux_download https://github.com/ninja-build/ninja/releases/download/v$NINJA_VERSION/ninja-linux.zip \ "$NINJA_ZIP_FILE" \ - d2fea9ff33b3ef353161ed906f260d565ca55b8ca0568fa07b1d2cab90a84a07 + 609cc10d0f226a4d9050e4d4a57be9ea706858cce64b9132102c3789c868da92 unzip "$NINJA_ZIP_FILE" -d "$NINJA_FOLDER" + chmod 755 $NINJA_FOLDER/ninja fi export PATH=$NINJA_FOLDER:$PATH } diff --git a/packages/ninja/build.sh b/packages/ninja/build.sh index e19dc7a83..0a8f5427e 100644 --- a/packages/ninja/build.sh +++ b/packages/ninja/build.sh @@ -1,9 +1,8 @@ TERMUX_PKG_HOMEPAGE=https://ninja-build.org TERMUX_PKG_DESCRIPTION="A small build system with a focus on speed" TERMUX_PKG_LICENSE="Apache-2.0" -TERMUX_PKG_VERSION=1.8.2 -TERMUX_PKG_REVISION=1 -TERMUX_PKG_SHA256=86b8700c3d0880c2b44c2ff67ce42774aaf8c28cbf57725cb881569288c1c6f4 +TERMUX_PKG_VERSION=1.9.0 +TERMUX_PKG_SHA256=5d7ec75828f8d3fd1a0c2f31b5b0cea780cdfe1031359228c428c1a48bfcd5b9 TERMUX_PKG_SRCURL=https://github.com/ninja-build/ninja/archive/v${TERMUX_PKG_VERSION}.tar.gz termux_step_configure() { diff --git a/packages/ninja/configure.py.patch b/packages/ninja/configure.py.patch index 559681e45..7892c38fa 100644 --- a/packages/ninja/configure.py.patch +++ b/packages/ninja/configure.py.patch @@ -6,7 +6,7 @@ index a443748..697a110 100755 objs += cxx('minidump-win32') objs += cc('getopt') else: -+ objs += cc('posix_spawn') ++ objs += cxx('spawn') objs += cxx('subprocess-posix') if platform.is_aix(): objs += cc('getopt') diff --git a/packages/ninja/src-posix_spawn.c.patch b/packages/ninja/src-posix_spawn.c.patch deleted file mode 100644 index aa0ad9935..000000000 --- a/packages/ninja/src-posix_spawn.c.patch +++ /dev/null @@ -1,162 +0,0 @@ -diff --git a/src/posix_spawn.c b/src/posix_spawn.c -new file mode 100644 -index 0000000..18ceb06 ---- /dev/null -+++ b/src/posix_spawn.c -@@ -0,0 +1,156 @@ -+/* -+ * dhcpcd - DHCP client daemon -+ * Copyright (c) 2006-2012 Roy Marples -+ * All rights reserved -+ -+ * Redistribution and use in source and binary forms, with or without -+ * modification, are permitted provided that the following conditions -+ * are met: -+ * 1. Redistributions of source code must retain the above copyright -+ * notice, this list of conditions and the following disclaimer. -+ * 2. Redistributions in binary form must reproduce the above copyright -+ * notice, this list of conditions and the following disclaimer in the -+ * documentation and/or other materials provided with the distribution. -+ * -+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND -+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE -+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -+ * SUCH DAMAGE. -+ */ -+ -+/* This implementation of posix_spawn is only suitable for the needs of dhcpcd -+ * but it could easily be extended to other applications. */ -+ -+#include -+#include -+ -+#include -+#include -+#include -+#include -+#include -+ -+#include "posix_spawn.h" -+ -+#ifndef _NSIG -+#ifdef _SIG_MAXSIG -+#define _NSIG _SIG_MAXSIG + 1 -+#else -+/* Guess */ -+#define _NSIG SIGPWR + 1 -+#endif -+#endif -+ -+extern char **environ; -+ -+static int -+posix_spawnattr_handle(const posix_spawnattr_t *attrp) -+{ -+ struct sigaction sa; -+ int i; -+ -+ if (attrp->posix_attr_flags & POSIX_SPAWN_SETSIGMASK) -+ sigprocmask(SIG_SETMASK, &attrp->posix_attr_sigmask, NULL); -+ -+ if (attrp->posix_attr_flags & POSIX_SPAWN_SETSIGDEF) { -+ memset(&sa, 0, sizeof(sa)); -+ sa.sa_handler = SIG_DFL; -+ for (i = 1; i < _NSIG; i++) { -+ if (sigismember(&attrp->posix_attr_sigdefault, i)) { -+ if (sigaction(i, &sa, NULL) == -1) -+ return -1; -+ } -+ } -+ } -+ -+ return 0; -+} -+ -+inline static int -+is_vfork_safe(short int flags) -+{ -+ return !(flags & (POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK)); -+} -+ -+int -+posix_spawn(pid_t *pid, const char *path, -+ const posix_spawn_file_actions_t *file_actions, -+ const posix_spawnattr_t *attrp, -+ char *const argv[], char *const envp[]) -+{ -+ short int flags; -+ pid_t p; -+ volatile int error; -+ -+ error = 0; -+ flags = attrp ? attrp->posix_attr_flags : 0; -+ if (file_actions == NULL && is_vfork_safe(flags)) -+ p = vfork(); -+ else -+#ifdef THERE_IS_NO_FORK -+ return ENOSYS; -+#else -+ p = fork(); -+#endif -+ switch (p) { -+ case -1: -+ return errno; -+ case 0: -+ if (attrp) { -+ error = posix_spawnattr_handle(attrp); -+ if (error) -+ _exit(127); -+ } -+ execve(path, argv, envp); -+ error = errno; -+ _exit(127); -+ default: -+ if (error != 0) -+ waitpid(p, NULL, WNOHANG); -+ else if (pid != NULL) -+ *pid = p; -+ return error; -+ } -+} -+ -+int -+posix_spawnattr_init(posix_spawnattr_t *attr) -+{ -+ -+ memset(attr, 0, sizeof(*attr)); -+ attr->posix_attr_flags = 0; -+ sigprocmask(0, NULL, &attr->posix_attr_sigmask); -+ sigemptyset(&attr->posix_attr_sigdefault); -+ return 0; -+} -+ -+int -+posix_spawnattr_setflags(posix_spawnattr_t *attr, short flags) -+{ -+ -+ attr->posix_attr_flags = flags; -+ return 0; -+} -+ -+int -+posix_spawnattr_setsigmask(posix_spawnattr_t *attr, const sigset_t *sigmask) -+{ -+ -+ attr->posix_attr_sigmask = *sigmask; -+ return 0; -+} -+ -+int -+posix_spawnattr_setsigdefault(posix_spawnattr_t *attr, const sigset_t *sigmask) -+{ -+ -+ attr->posix_attr_sigdefault = *sigmask; -+ return 0; -+} diff --git a/packages/ninja/src-posix_spawn.h.patch b/packages/ninja/src-posix_spawn.h.patch deleted file mode 100644 index 1b7b81689..000000000 --- a/packages/ninja/src-posix_spawn.h.patch +++ /dev/null @@ -1,59 +0,0 @@ -diff --git a/src/posix_spawn.h b/src/posix_spawn.h -new file mode 100644 -index 0000000..ccfb0f0 ---- /dev/null -+++ b/src/posix_spawn.h -@@ -0,0 +1,53 @@ -+/* -+ * dhcpcd - DHCP client daemon -+ * Copyright (c) 2006-2012 Roy Marples -+ * All rights reserved -+ -+ * Redistribution and use in source and binary forms, with or without -+ * modification, are permitted provided that the following conditions -+ * are met: -+ * 1. Redistributions of source code must retain the above copyright -+ * notice, this list of conditions and the following disclaimer. -+ * 2. Redistributions in binary form must reproduce the above copyright -+ * notice, this list of conditions and the following disclaimer in the -+ * documentation and/or other materials provided with the distribution. -+ * -+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND -+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE -+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -+ * SUCH DAMAGE. -+ */ -+ -+#ifndef POSIX_SPAWN_H -+#define POSIX_SPAWN_H -+ -+#include -+ -+typedef struct { -+ short posix_attr_flags; -+#define POSIX_SPAWN_SETSIGDEF 0x10 -+#define POSIX_SPAWN_SETSIGMASK 0x20 -+ sigset_t posix_attr_sigmask; -+ sigset_t posix_attr_sigdefault; -+} posix_spawnattr_t; -+ -+typedef struct { -+// int unused; -+} posix_spawn_file_actions_t; -+ -+int posix_spawn(pid_t *, const char *, -+ const posix_spawn_file_actions_t *, const posix_spawnattr_t *, -+ char *const [], char *const []); -+int posix_spawnattr_init(posix_spawnattr_t *); -+int posix_spawnattr_setflags(posix_spawnattr_t *, short); -+int posix_spawnattr_setsigmask(posix_spawnattr_t *, const sigset_t *); -+int posix_spawnattr_setsigdefault(posix_spawnattr_t *, const sigset_t *); -+ -+#endif diff --git a/packages/ninja/src-spawn.cc.patch b/packages/ninja/src-spawn.cc.patch new file mode 100644 index 000000000..abc853b26 --- /dev/null +++ b/packages/ninja/src-spawn.cc.patch @@ -0,0 +1,387 @@ +diff --git a/src/spawn.cc b/src/spawn.cc +new file mode 100644 +index 0000000..1eed715 +--- /dev/null ++++ b/src/spawn.cc +@@ -0,0 +1,381 @@ ++/* ++ * Copyright (C) 2017 The Android Open Source Project ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * * Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * * Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ++ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ++ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, ++ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, ++ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS ++ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED ++ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, ++ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT ++ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include ++ ++#include "spawn.h" ++ ++// Bionic "private/ScopedSignalBlocker.h" + one macro needed ++#define BIONIC_DISALLOW_COPY_AND_ASSIGN(TypeName) \ ++ TypeName(const TypeName&) = delete; \ ++ void operator=(const TypeName&) = delete ++ ++class ScopedSignalBlocker { ++ public: ++ // Block all signals. ++ explicit ScopedSignalBlocker() { ++ sigset_t set; ++ sigfillset(&set); ++ sigprocmask(SIG_BLOCK, &set, &old_set_); ++ } ++ ++ // Block just the specified signal. ++ explicit ScopedSignalBlocker(int signal) { ++ sigset_t set = {}; ++ sigaddset(&set, signal); ++ sigprocmask(SIG_BLOCK, &set, &old_set_); ++ } ++ ++ ~ScopedSignalBlocker() { ++ reset(); ++ } ++ ++ void reset() { ++ sigprocmask(SIG_SETMASK, &old_set_, nullptr); ++ } ++ ++ sigset_t old_set_; ++ ++ BIONIC_DISALLOW_COPY_AND_ASSIGN(ScopedSignalBlocker); ++}; ++ ++// Bionic "private/SigSetConverter.h" ++union SigSetConverter { ++ int bsd; ++ sigset_t sigset; ++ sigset64_t sigset64; ++}; ++ ++enum Action { ++ kOpen, ++ kClose, ++ kDup2 ++}; ++ ++struct __posix_spawn_file_action { ++ __posix_spawn_file_action* next; ++ ++ Action what; ++ int fd; ++ int new_fd; ++ char* path; ++ int flags; ++ mode_t mode; ++ ++ void Do() { ++ if (what == kOpen) { ++ fd = open(path, flags, mode); ++ if (fd == -1) _exit(127); ++ // If it didn't land where we wanted it, move it. ++ if (fd != new_fd) { ++ if (dup2(fd, new_fd) == -1) _exit(127); ++ close(fd); ++ } ++ } else if (what == kClose) { ++ // Failure to close is ignored. ++ close(fd); ++ } else { ++ if (dup2(fd, new_fd) == -1) _exit(127); ++ } ++ } ++}; ++ ++struct __posix_spawn_file_actions { ++ __posix_spawn_file_action* head; ++ __posix_spawn_file_action* last; ++ ++ void Do() { ++ for (__posix_spawn_file_action* action = head; action != nullptr; action = action->next) { ++ action->Do(); ++ } ++ } ++}; ++ ++struct __posix_spawnattr { ++ short flags; ++ pid_t pgroup; ++ sched_param schedparam; ++ int schedpolicy; ++ SigSetConverter sigmask; ++ SigSetConverter sigdefault; ++}; ++ ++static void ApplyAttrs(short flags, const posix_spawnattr_t* attr) { ++ // POSIX: "If POSIX_SPAWN_SETSIGDEF is set ... signals in sigdefault ... ++ // shall be set to their default actions in the child process." ++ // POSIX: "Signals set to be caught by the calling process shall be ++ // set to the default action in the child process." ++ bool use_sigdefault = ((flags & POSIX_SPAWN_SETSIGDEF) != 0); ++ const struct sigaction default_sa = { .sa_handler = SIG_DFL }; ++ for (int s = 1; s < _NSIG; ++s) { ++ bool reset = false; ++ if (use_sigdefault && sigismember(&(*attr)->sigdefault.sigset, s)) { ++ reset = true; ++ } else { ++ struct sigaction current; ++ if (sigaction(s, nullptr, ¤t) == -1) _exit(127); ++ reset = (current.sa_handler != SIG_IGN && current.sa_handler != SIG_DFL); ++ } ++ if (reset && sigaction(s, &default_sa, nullptr) == -1) _exit(127); ++ } ++ ++ if ((flags & POSIX_SPAWN_SETPGROUP) != 0 && setpgid(0, (*attr)->pgroup) == -1) _exit(127); ++ if ((flags & POSIX_SPAWN_SETSID) != 0 && setsid() == -1) _exit(127); ++ ++ // POSIX_SPAWN_SETSCHEDULER overrides POSIX_SPAWN_SETSCHEDPARAM, but it is not an error ++ // to set both. ++ if ((flags & POSIX_SPAWN_SETSCHEDULER) != 0) { ++ if (sched_setscheduler(0, (*attr)->schedpolicy, &(*attr)->schedparam) == -1) _exit(127); ++ } else if ((flags & POSIX_SPAWN_SETSCHEDPARAM) != 0) { ++ if (sched_setparam(0, &(*attr)->schedparam) == -1) _exit(127); ++ } ++ ++ if ((flags & POSIX_SPAWN_RESETIDS) != 0) { ++ if (seteuid(getuid()) == -1 || setegid(getgid()) == -1) _exit(127); ++ } ++ ++ if ((flags & POSIX_SPAWN_SETSIGMASK) != 0) { ++ if (sigprocmask(SIG_SETMASK, &(*attr)->sigmask.sigset, nullptr)) _exit(127); ++ } ++} ++ ++static int posix_spawn(pid_t* pid_ptr, ++ const char* path, ++ const posix_spawn_file_actions_t* actions, ++ const posix_spawnattr_t* attr, ++ char* const argv[], ++ char* const env[], ++ int exec_fn(const char* path, char* const argv[], char* const env[])) { ++ // See http://man7.org/linux/man-pages/man3/posix_spawn.3.html ++ // and http://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_spawn.html ++ ++ ScopedSignalBlocker ssb; ++ ++ short flags = attr ? (*attr)->flags : 0; ++ bool use_vfork = ((flags & POSIX_SPAWN_USEVFORK) != 0) || (actions == nullptr && flags == 0); ++ ++ pid_t pid = use_vfork ? vfork() : fork(); ++ if (pid == -1) return errno; ++ ++ if (pid == 0) { ++ // Child. ++ ApplyAttrs(flags, attr); ++ if (actions) (*actions)->Do(); ++ if ((flags & POSIX_SPAWN_SETSIGMASK) == 0) ssb.reset(); ++ exec_fn(path, argv, env ? env : environ); ++ _exit(127); ++ } ++ ++ // Parent. ++ if (pid_ptr) *pid_ptr = pid; ++ return 0; ++} ++ ++int posix_spawn(pid_t* pid, const char* path, const posix_spawn_file_actions_t* actions, ++ const posix_spawnattr_t* attr, char* const argv[], char* const env[]) { ++ return posix_spawn(pid, path, actions, attr, argv, env, execve); ++} ++ ++int posix_spawnp(pid_t* pid, const char* file, const posix_spawn_file_actions_t* actions, ++ const posix_spawnattr_t* attr, char* const argv[], char* const env[]) { ++ return posix_spawn(pid, file, actions, attr, argv, env, execvpe); ++} ++ ++int posix_spawnattr_init(posix_spawnattr_t* attr) { ++ *attr = reinterpret_cast<__posix_spawnattr*>(calloc(1, sizeof(__posix_spawnattr))); ++ return (*attr == nullptr) ? errno : 0; ++} ++ ++int posix_spawnattr_destroy(posix_spawnattr_t* attr) { ++ free(*attr); ++ *attr = nullptr; ++ return 0; ++} ++ ++int posix_spawnattr_setflags(posix_spawnattr_t* attr, short flags) { ++ if ((flags & ~(POSIX_SPAWN_RESETIDS | POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_SETSIGDEF | ++ POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_SETSCHEDPARAM | POSIX_SPAWN_SETSCHEDULER | ++ POSIX_SPAWN_USEVFORK | POSIX_SPAWN_SETSID)) != 0) { ++ return EINVAL; ++ } ++ (*attr)->flags = flags; ++ return 0; ++} ++ ++int posix_spawnattr_getflags(const posix_spawnattr_t* attr, short* flags) { ++ *flags = (*attr)->flags; ++ return 0; ++} ++ ++int posix_spawnattr_setpgroup(posix_spawnattr_t* attr, pid_t pgroup) { ++ (*attr)->pgroup = pgroup; ++ return 0; ++} ++ ++int posix_spawnattr_getpgroup(const posix_spawnattr_t* attr, pid_t* pgroup) { ++ *pgroup = (*attr)->pgroup; ++ return 0; ++} ++ ++int posix_spawnattr_setsigmask(posix_spawnattr_t* attr, const sigset_t* mask) { ++ (*attr)->sigmask.sigset = *mask; ++ return 0; ++} ++ ++int posix_spawnattr_setsigmask64(posix_spawnattr_t* attr, const sigset64_t* mask) { ++ (*attr)->sigmask.sigset64 = *mask; ++ return 0; ++} ++ ++int posix_spawnattr_getsigmask(const posix_spawnattr_t* attr, sigset_t* mask) { ++ *mask = (*attr)->sigmask.sigset; ++ return 0; ++} ++ ++int posix_spawnattr_getsigmask64(const posix_spawnattr_t* attr, sigset64_t* mask) { ++ *mask = (*attr)->sigmask.sigset64; ++ return 0; ++} ++ ++int posix_spawnattr_setsigdefault(posix_spawnattr_t* attr, const sigset_t* mask) { ++ (*attr)->sigdefault.sigset = *mask; ++ return 0; ++} ++ ++int posix_spawnattr_setsigdefault64(posix_spawnattr_t* attr, const sigset64_t* mask) { ++ (*attr)->sigdefault.sigset64 = *mask; ++ return 0; ++} ++ ++int posix_spawnattr_getsigdefault(const posix_spawnattr_t* attr, sigset_t* mask) { ++ *mask = (*attr)->sigdefault.sigset; ++ return 0; ++} ++ ++int posix_spawnattr_getsigdefault64(const posix_spawnattr_t* attr, sigset64_t* mask) { ++ *mask = (*attr)->sigdefault.sigset64; ++ return 0; ++} ++ ++int posix_spawnattr_setschedparam(posix_spawnattr_t* attr, const struct sched_param* param) { ++ (*attr)->schedparam = *param; ++ return 0; ++} ++ ++int posix_spawnattr_getschedparam(const posix_spawnattr_t* attr, struct sched_param* param) { ++ *param = (*attr)->schedparam; ++ return 0; ++} ++ ++int posix_spawnattr_setschedpolicy(posix_spawnattr_t* attr, int policy) { ++ (*attr)->schedpolicy = policy; ++ return 0; ++} ++ ++int posix_spawnattr_getschedpolicy(const posix_spawnattr_t* attr, int* policy) { ++ *policy = (*attr)->schedpolicy; ++ return 0; ++} ++ ++int posix_spawn_file_actions_init(posix_spawn_file_actions_t* actions) { ++ *actions = reinterpret_cast<__posix_spawn_file_actions*>(calloc(1, sizeof(**actions))); ++ return (*actions == nullptr) ? errno : 0; ++} ++ ++int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t* actions) { ++ __posix_spawn_file_action* a = (*actions)->head; ++ while (a) { ++ __posix_spawn_file_action* last = a; ++ a = a->next; ++ free(last->path); ++ free(last); ++ } ++ free(*actions); ++ *actions = nullptr; ++ return 0; ++} ++ ++static int posix_spawn_add_file_action(posix_spawn_file_actions_t* actions, ++ Action what, ++ int fd, ++ int new_fd, ++ const char* path, ++ int flags, ++ mode_t mode) { ++ __posix_spawn_file_action* action = ++ reinterpret_cast<__posix_spawn_file_action*>(malloc(sizeof(*action))); ++ if (action == nullptr) return errno; ++ ++ action->next = nullptr; ++ if (path != nullptr) { ++ action->path = strdup(path); ++ if (action->path == nullptr) { ++ free(action); ++ return errno; ++ } ++ } else { ++ action->path = nullptr; ++ } ++ action->what = what; ++ action->fd = fd; ++ action->new_fd = new_fd; ++ action->flags = flags; ++ action->mode = mode; ++ ++ if ((*actions)->head == nullptr) { ++ (*actions)->head = (*actions)->last = action; ++ } else { ++ (*actions)->last->next = action; ++ (*actions)->last = action; ++ } ++ ++ return 0; ++} ++ ++int posix_spawn_file_actions_addopen(posix_spawn_file_actions_t* actions, ++ int fd, const char* path, int flags, mode_t mode) { ++ if (fd < 0) return EBADF; ++ return posix_spawn_add_file_action(actions, kOpen, -1, fd, path, flags, mode); ++} ++ ++int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t* actions, int fd) { ++ if (fd < 0) return EBADF; ++ return posix_spawn_add_file_action(actions, kClose, fd, -1, nullptr, 0, 0); ++} ++ ++int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t* actions, int fd, int new_fd) { ++ if (fd < 0 || new_fd < 0) return EBADF; ++ return posix_spawn_add_file_action(actions, kDup2, fd, new_fd, nullptr, 0, 0); ++} diff --git a/packages/ninja/src-spawn.h.patch b/packages/ninja/src-spawn.h.patch new file mode 100644 index 000000000..b6880958d --- /dev/null +++ b/packages/ninja/src-spawn.h.patch @@ -0,0 +1,96 @@ +diff --git a/src/spawn.h b/src/spawn.h +new file mode 100644 +index 0000000..2e239bf +--- /dev/null ++++ b/src/spawn.h +@@ -0,0 +1,90 @@ ++/* ++ * Copyright (C) 2017 The Android Open Source Project ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * * Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * * Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in ++ * the documentation and/or other materials provided with the ++ * distribution. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ++ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ++ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, ++ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, ++ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS ++ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED ++ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, ++ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT ++ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ */ ++ ++#ifndef _SPAWN_H_ ++#define _SPAWN_H_ ++ ++#include ++#include ++#include ++#include ++ ++__BEGIN_DECLS ++ ++#define POSIX_SPAWN_RESETIDS 1 ++#define POSIX_SPAWN_SETPGROUP 2 ++#define POSIX_SPAWN_SETSIGDEF 4 ++#define POSIX_SPAWN_SETSIGMASK 8 ++#define POSIX_SPAWN_SETSCHEDPARAM 16 ++#define POSIX_SPAWN_SETSCHEDULER 32 ++#if defined(__USE_GNU) ++#define POSIX_SPAWN_USEVFORK 64 ++#define POSIX_SPAWN_SETSID 128 ++#endif ++ ++typedef struct __posix_spawnattr* posix_spawnattr_t; ++typedef struct __posix_spawn_file_actions* posix_spawn_file_actions_t; ++ ++int posix_spawn(pid_t* __pid, const char* __path, const posix_spawn_file_actions_t* __actions, const posix_spawnattr_t* __attr, char* const __argv[], char* const __env[]) __INTRODUCED_IN(28); ++int posix_spawnp(pid_t* __pid, const char* __file, const posix_spawn_file_actions_t* __actions, const posix_spawnattr_t* __attr, char* const __argv[], char* const __env[]) __INTRODUCED_IN(28); ++ ++int posix_spawnattr_init(posix_spawnattr_t* __attr) __INTRODUCED_IN(28); ++int posix_spawnattr_destroy(posix_spawnattr_t* __attr) __INTRODUCED_IN(28); ++ ++int posix_spawnattr_setflags(posix_spawnattr_t* __attr, short __flags) __INTRODUCED_IN(28); ++int posix_spawnattr_getflags(const posix_spawnattr_t* __attr, short* __flags) __INTRODUCED_IN(28); ++ ++int posix_spawnattr_setpgroup(posix_spawnattr_t* __attr, pid_t __pgroup) __INTRODUCED_IN(28); ++int posix_spawnattr_getpgroup(const posix_spawnattr_t* __attr, pid_t* __pgroup) __INTRODUCED_IN(28); ++ ++int posix_spawnattr_setsigmask(posix_spawnattr_t* __attr, const sigset_t* __mask) __INTRODUCED_IN(28); ++int posix_spawnattr_setsigmask64(posix_spawnattr_t* __attr, const sigset64_t* __mask) __INTRODUCED_IN(28); ++int posix_spawnattr_getsigmask(const posix_spawnattr_t* __attr, sigset_t* __mask) __INTRODUCED_IN(28); ++int posix_spawnattr_getsigmask64(const posix_spawnattr_t* __attr, sigset64_t* __mask) __INTRODUCED_IN(28); ++ ++int posix_spawnattr_setsigdefault(posix_spawnattr_t* __attr, const sigset_t* __mask) __INTRODUCED_IN(28); ++int posix_spawnattr_setsigdefault64(posix_spawnattr_t* __attr, const sigset64_t* __mask) __INTRODUCED_IN(28); ++int posix_spawnattr_getsigdefault(const posix_spawnattr_t* __attr, sigset_t* __mask) __INTRODUCED_IN(28); ++int posix_spawnattr_getsigdefault64(const posix_spawnattr_t* __attr, sigset64_t* __mask) __INTRODUCED_IN(28); ++ ++int posix_spawnattr_setschedparam(posix_spawnattr_t* __attr, const struct sched_param* __param) __INTRODUCED_IN(28); ++int posix_spawnattr_getschedparam(const posix_spawnattr_t* __attr, struct sched_param* __param) __INTRODUCED_IN(28); ++ ++int posix_spawnattr_setschedpolicy(posix_spawnattr_t* __attr, int __policy) __INTRODUCED_IN(28); ++int posix_spawnattr_getschedpolicy(const posix_spawnattr_t* __attr, int* __policy) __INTRODUCED_IN(28); ++ ++int posix_spawn_file_actions_init(posix_spawn_file_actions_t* __actions) __INTRODUCED_IN(28); ++int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t* __actions) __INTRODUCED_IN(28); ++ ++int posix_spawn_file_actions_addopen(posix_spawn_file_actions_t* __actions, int __fd, const char* __path, int __flags, mode_t __mode) __INTRODUCED_IN(28); ++int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t* __actions, int __fd) __INTRODUCED_IN(28); ++int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t* __actions, int __fd, int __new_fd) __INTRODUCED_IN(28); ++ ++__END_DECLS ++ ++#endif diff --git a/packages/ninja/src-subprocess-posix.cc.patch b/packages/ninja/src-subprocess-posix.cc.patch index 1a9b21612..820029c67 100644 --- a/packages/ninja/src-subprocess-posix.cc.patch +++ b/packages/ninja/src-subprocess-posix.cc.patch @@ -10,59 +10,18 @@ index 1de22c3..f988297 100644 extern char** environ; -+#include "posix_spawn.h" ++#include "spawn.h" #include "util.h" Subprocess::Subprocess(bool use_console) : fd_(-1), pid_(-1), -@@ -54,11 +54,11 @@ bool Subprocess::Start(SubprocessSet* set, const string& command) { - SetCloseOnExec(fd_); - - posix_spawn_file_actions_t action; -- if (posix_spawn_file_actions_init(&action) != 0) -+ /*if (posix_spawn_file_actions_init(&action) != 0) - Fatal("posix_spawn_file_actions_init: %s", strerror(errno)); - - if (posix_spawn_file_actions_addclose(&action, output_pipe[0]) != 0) -- Fatal("posix_spawn_file_actions_addclose: %s", strerror(errno)); -+ Fatal("posix_spawn_file_actions_addclose: %s", strerror(errno));*/ - - posix_spawnattr_t attr; - if (posix_spawnattr_init(&attr) != 0) -@@ -73,7 +73,7 @@ bool Subprocess::Start(SubprocessSet* set, const string& command) { - // default action in the new process image, so no explicit - // POSIX_SPAWN_SETSIGDEF parameter is needed. - -- if (!use_console_) { -+ /*if (!use_console_) { - // Put the child in its own process group, so ctrl-c won't reach it. - flags |= POSIX_SPAWN_SETPGROUP; - // No need to posix_spawnattr_setpgroup(&attr, 0), it's the default. -@@ -92,7 +92,7 @@ bool Subprocess::Start(SubprocessSet* set, const string& command) { - Fatal("posix_spawn_file_actions_addclose: %s", strerror(errno)); - // In the console case, output_pipe is still inherited by the child and - // closed when the subprocess finishes, which then notifies ninja. -- } -+ }*/ - #ifdef POSIX_SPAWN_USEVFORK - flags |= POSIX_SPAWN_USEVFORK; - #endif -@@ -100,15 +100,15 @@ bool Subprocess::Start(SubprocessSet* set, const string& command) { - if (posix_spawnattr_setflags(&attr, flags) != 0) - Fatal("posix_spawnattr_setflags: %s", strerror(errno)); +@@ -110,8 +110,8 @@ bool Subprocess::Start(SubprocessSet* set, const string& command) { + if (err != 0) + Fatal("posix_spawnattr_setflags: %s", strerror(err)); - const char* spawned_args[] = { "/bin/sh", "-c", command.c_str(), NULL }; -- if (posix_spawn(&pid_, "/bin/sh", &action, &attr, -+ const char* spawned_args[] = { "/system/bin/sh", "-c", command.c_str(), NULL }; -+ if (posix_spawn(&pid_, "/system/bin/sh", &action, &attr, - const_cast(spawned_args), environ) != 0) - Fatal("posix_spawn: %s", strerror(errno)); - -- if (posix_spawnattr_destroy(&attr) != 0) -+ /*if (posix_spawnattr_destroy(&attr) != 0) - Fatal("posix_spawnattr_destroy: %s", strerror(errno)); - if (posix_spawn_file_actions_destroy(&action) != 0) -- Fatal("posix_spawn_file_actions_destroy: %s", strerror(errno)); -+ Fatal("posix_spawn_file_actions_destroy: %s", strerror(errno));*/ - - close(output_pipe[1]); - return true; +- err = posix_spawn(&pid_, "/bin/sh", &action, &attr, ++ const char* spawned_args[] = { "@TERMUX_PREFIX@/bin/sh", "-c", command.c_str(), NULL }; ++ err = posix_spawn(&pid_, "@TERMUX_PREFIX@/bin/sh", &action, &attr, + const_cast(spawned_args), environ); + if (err != 0) + Fatal("posix_spawn: %s", strerror(err));