From 14e3ff9f09fdd52db43628ccd6f39a6d3fb41740 Mon Sep 17 00:00:00 2001 From: Elliott Hughes Date: Fri, 6 Oct 2017 16:58:36 -0700 Subject: [PATCH] Implement . As described here: http://pubs.opengroup.org/onlinepubs/9699919799/functions/posix_spawn.html And here: http://man7.org/linux/man-pages/man3/posix_spawn.3.html Bug: N/A (but mentioned in my inbox since 2013) Test: ran tests Change-Id: I0b27b2919b660779e3bd8a25fb429527c16dc621 --- docs/status.md | 32 +-- libc/Android.bp | 1 + libc/bionic/spawn.cpp | 316 +++++++++++++++++++++++ libc/bionic/tmpfile.cpp | 17 +- libc/include/bits/posix_limits.h | 2 +- libc/include/spawn.h | 86 +++++++ libc/libc.arm.map | 21 ++ libc/libc.arm64.map | 21 ++ libc/libc.map.txt | 21 ++ libc/libc.mips.map | 21 ++ libc/libc.mips64.map | 21 ++ libc/libc.x86.map | 21 ++ libc/libc.x86_64.map | 21 ++ libc/private/ScopedSignalBlocker.h | 46 ++++ tests/Android.bp | 1 + tests/spawn_test.cpp | 388 +++++++++++++++++++++++++++++ tests/unistd_test.cpp | 10 +- tests/utils.h | 9 + 18 files changed, 1003 insertions(+), 52 deletions(-) create mode 100644 libc/bionic/spawn.cpp create mode 100644 libc/include/spawn.h create mode 100644 libc/private/ScopedSignalBlocker.h create mode 100644 tests/spawn_test.cpp diff --git a/docs/status.md b/docs/status.md index 25f566362..a32a4c776 100644 --- a/docs/status.md +++ b/docs/status.md @@ -8,8 +8,12 @@ Current libc symbols: https://android.googlesource.com/platform/bionic/+/master/ New libc functions in P: * `__freading`/`__fwriting` (completing ) + * `getentropy`/`getrandom` (adding ) * `getlogin_r` + * `glob`/`globfree` (adding ) + * `hcreate`/hcreate_r`/`hdestroy`/`hdestroy_r`/`hsearch`/`hsearch_r` (completing ) * `iconv`/`iconv_close`/`iconv_open` (adding ) + * * `syncfs` New libc functions in O: @@ -56,7 +60,7 @@ ndk-r17$ for i in `ls -1v platforms/android-*/arch-arm/usr/lib/libc.so` ; do ech Run `./libc/tools/check-symbols-glibc.py` in bionic/ for the current list of POSIX functions implemented by glibc but not by bionic. Currently -(2017-09): +(2017-10): ``` aio_cancel aio_error @@ -75,33 +79,7 @@ getdate getdate_err getnetent getprotoent -glob -globfree -hcreate -hdestroy -hsearch lio_listio -posix_spawn -posix_spawn_file_actions_addclose -posix_spawn_file_actions_adddup2 -posix_spawn_file_actions_addopen -posix_spawn_file_actions_destroy -posix_spawn_file_actions_init -posix_spawnattr_destroy -posix_spawnattr_getflags -posix_spawnattr_getpgroup -posix_spawnattr_getschedparam -posix_spawnattr_getschedpolicy -posix_spawnattr_getsigdefault -posix_spawnattr_getsigmask -posix_spawnattr_init -posix_spawnattr_setflags -posix_spawnattr_setpgroup -posix_spawnattr_setschedparam -posix_spawnattr_setschedpolicy -posix_spawnattr_setsigdefault -posix_spawnattr_setsigmask -posix_spawnp pthread_attr_getinheritsched pthread_attr_setinheritsched pthread_cancel diff --git a/libc/Android.bp b/libc/Android.bp index cd01efd5d..a142f4e33 100644 --- a/libc/Android.bp +++ b/libc/Android.bp @@ -1530,6 +1530,7 @@ cc_library_static { "bionic/sigwait.cpp", "bionic/sigwaitinfo.cpp", "bionic/socket.cpp", + "bionic/spawn.cpp", "bionic/stat.cpp", "bionic/statvfs.cpp", "bionic/stdlib_l.cpp", diff --git a/libc/bionic/spawn.cpp b/libc/bionic/spawn.cpp new file mode 100644 index 000000000..7015ad923 --- /dev/null +++ b/libc/bionic/spawn.cpp @@ -0,0 +1,316 @@ +/* + * 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 "private/ScopedSignalBlocker.h" + +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; + sigset_t sigmask; + sigset_t sigdefault; + + void Do() { + bool use_sigdefault = ((flags & POSIX_SPAWN_SETSIGDEF) != 0); + + for (int s = 1; s < _NSIG; ++s) { + struct sigaction sa; + if (sigaction(s, nullptr, &sa) == -1) _exit(127); + if (sa.sa_handler == SIG_DFL) continue; + // POSIX: "Signals set to be caught by the calling process shall be set to the default + // action in the child process." + // POSIX: "If POSIX_SPAWN_SETSIGDEF is set ... signals in sigdefault ... shall be set to + // their default actions in the child process." + if (sa.sa_handler != SIG_IGN || (use_sigdefault && sigismember(&sigdefault, s))) { + sa.sa_handler = SIG_DFL; + if (sigaction(s, &sa, nullptr) == -1) _exit(127); + } + } + + if ((flags & POSIX_SPAWN_SETPGROUP) != 0 && setpgid(0, 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, schedpolicy, &schedparam) == -1) _exit(127); + } else if ((flags & POSIX_SPAWN_SETSCHEDPARAM) != 0) { + if (sched_setparam(0, &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, &sigmask, 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. + if (attr) (*attr)->Do(); + 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 = *mask; + return 0; +} + +int posix_spawnattr_getsigmask(const posix_spawnattr_t* attr, sigset_t* mask) { + *mask = (*attr)->sigmask; + return 0; +} + +int posix_spawnattr_setsigdefault(posix_spawnattr_t* attr, const sigset_t* mask) { + (*attr)->sigdefault = *mask; + return 0; +} + +int posix_spawnattr_getsigdefault(const posix_spawnattr_t* attr, sigset_t* mask) { + *mask = (*attr)->sigdefault; + 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/libc/bionic/tmpfile.cpp b/libc/bionic/tmpfile.cpp index dc142a94e..bda356612 100644 --- a/libc/bionic/tmpfile.cpp +++ b/libc/bionic/tmpfile.cpp @@ -39,22 +39,7 @@ #include #include "private/ErrnoRestorer.h" - -class ScopedSignalBlocker { - public: - ScopedSignalBlocker() { - sigset_t set; - sigfillset(&set); - sigprocmask(SIG_BLOCK, &set, &old_set_); - } - - ~ScopedSignalBlocker() { - sigprocmask(SIG_SETMASK, &old_set_, NULL); - } - - private: - sigset_t old_set_; -}; +#include "private/ScopedSignalBlocker.h" static FILE* __tmpfile_dir(const char* tmp_dir) { char* path = NULL; diff --git a/libc/include/bits/posix_limits.h b/libc/include/bits/posix_limits.h index 4038c3a61..e5846d6ed 100644 --- a/libc/include/bits/posix_limits.h +++ b/libc/include/bits/posix_limits.h @@ -68,7 +68,7 @@ #define _POSIX_SEMAPHORES _POSIX_VERSION /* sem_*. */ #define _POSIX_SHARED_MEMORY_OBJECTS __BIONIC_POSIX_FEATURE_MISSING /* mmap/munmap are implemented, but shm_open/shm_unlink are not. */ #define _POSIX_SHELL 1 /* system. */ -#define _POSIX_SPAWN __BIONIC_POSIX_FEATURE_MISSING /* */ +#define _POSIX_SPAWN __BIONIC_POSIX_FEATURE_SINCE(28) /* */ #define _POSIX_SPIN_LOCKS __BIONIC_POSIX_FEATURE_SINCE(24) /* pthread_spin_*. */ #define _POSIX_SPORADIC_SERVER _POSIX_VERSION /* sched_setparam/sched_setscheduler. */ #define _POSIX_SYNCHRONIZED_IO _POSIX_VERSION diff --git a/libc/include/spawn.h b/libc/include/spawn.h new file mode 100644 index 000000000..ea4bb194d --- /dev/null +++ b/libc/include/spawn.h @@ -0,0 +1,86 @@ +/* + * 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_FUTURE; +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_FUTURE; + +int posix_spawnattr_init(posix_spawnattr_t* __attr) __INTRODUCED_IN_FUTURE; +int posix_spawnattr_destroy(posix_spawnattr_t* __attr) __INTRODUCED_IN_FUTURE; + +int posix_spawnattr_setflags(posix_spawnattr_t* __attr, short __flags) __INTRODUCED_IN_FUTURE; +int posix_spawnattr_getflags(const posix_spawnattr_t* __attr, short* __flags) __INTRODUCED_IN_FUTURE; + +int posix_spawnattr_setpgroup(posix_spawnattr_t* __attr, pid_t __pgroup) __INTRODUCED_IN_FUTURE; +int posix_spawnattr_getpgroup(const posix_spawnattr_t* __attr, pid_t* __pgroup) __INTRODUCED_IN_FUTURE; + +int posix_spawnattr_setsigmask(posix_spawnattr_t* __attr, const sigset_t* __mask) __INTRODUCED_IN_FUTURE; +int posix_spawnattr_getsigmask(const posix_spawnattr_t* __attr, sigset_t* __mask) __INTRODUCED_IN_FUTURE; + +int posix_spawnattr_setsigdefault(posix_spawnattr_t* __attr, const sigset_t* __mask) __INTRODUCED_IN_FUTURE; +int posix_spawnattr_getsigdefault(const posix_spawnattr_t* __attr, sigset_t* __mask) __INTRODUCED_IN_FUTURE; + +int posix_spawnattr_setschedparam(posix_spawnattr_t* __attr, const struct sched_param* __param) __INTRODUCED_IN_FUTURE; +int posix_spawnattr_getschedparam(const posix_spawnattr_t* __attr, struct sched_param* __param) __INTRODUCED_IN_FUTURE; + +int posix_spawnattr_setschedpolicy(posix_spawnattr_t* __attr, int __policy) __INTRODUCED_IN_FUTURE; +int posix_spawnattr_getschedpolicy(const posix_spawnattr_t* __attr, int* __policy) __INTRODUCED_IN_FUTURE; + +int posix_spawn_file_actions_init(posix_spawn_file_actions_t* __actions) __INTRODUCED_IN_FUTURE; +int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t* __actions) __INTRODUCED_IN_FUTURE; + +int posix_spawn_file_actions_addopen(posix_spawn_file_actions_t* __actions, int __fd, const char* __path, int __flags, mode_t __mode) __INTRODUCED_IN_FUTURE; +int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t* __actions, int __fd) __INTRODUCED_IN_FUTURE; +int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t* __actions, int __fd, int __new_fd) __INTRODUCED_IN_FUTURE; + +__END_DECLS + +#endif diff --git a/libc/libc.arm.map b/libc/libc.arm.map index 13c267a86..08ba59fdd 100644 --- a/libc/libc.arm.map +++ b/libc/libc.arm.map @@ -1336,6 +1336,27 @@ LIBC_P { # introduced=P iconv; iconv_close; iconv_open; + posix_spawn; + posix_spawnattr_destroy; + posix_spawnattr_getflags; + posix_spawnattr_getpgroup; + posix_spawnattr_getschedparam; + posix_spawnattr_getschedpolicy; + posix_spawnattr_getsigdefault; + posix_spawnattr_getsigmask; + posix_spawnattr_init; + posix_spawnattr_setflags; + posix_spawnattr_setpgroup; + posix_spawnattr_setschedparam; + posix_spawnattr_setschedpolicy; + posix_spawnattr_setsigdefault; + posix_spawnattr_setsigmask; + posix_spawn_file_actions_addclose; + posix_spawn_file_actions_adddup2; + posix_spawn_file_actions_addopen; + posix_spawn_file_actions_destroy; + posix_spawn_file_actions_init; + posix_spawnp; syncfs; } LIBC_O; diff --git a/libc/libc.arm64.map b/libc/libc.arm64.map index 9d8c1b7d6..400c95f74 100644 --- a/libc/libc.arm64.map +++ b/libc/libc.arm64.map @@ -1256,6 +1256,27 @@ LIBC_P { # introduced=P iconv; iconv_close; iconv_open; + posix_spawn; + posix_spawnattr_destroy; + posix_spawnattr_getflags; + posix_spawnattr_getpgroup; + posix_spawnattr_getschedparam; + posix_spawnattr_getschedpolicy; + posix_spawnattr_getsigdefault; + posix_spawnattr_getsigmask; + posix_spawnattr_init; + posix_spawnattr_setflags; + posix_spawnattr_setpgroup; + posix_spawnattr_setschedparam; + posix_spawnattr_setschedpolicy; + posix_spawnattr_setsigdefault; + posix_spawnattr_setsigmask; + posix_spawn_file_actions_addclose; + posix_spawn_file_actions_adddup2; + posix_spawn_file_actions_addopen; + posix_spawn_file_actions_destroy; + posix_spawn_file_actions_init; + posix_spawnp; syncfs; } LIBC_O; diff --git a/libc/libc.map.txt b/libc/libc.map.txt index da462d385..eb5c1e459 100644 --- a/libc/libc.map.txt +++ b/libc/libc.map.txt @@ -1361,6 +1361,27 @@ LIBC_P { # introduced=P iconv; iconv_close; iconv_open; + posix_spawn; + posix_spawnattr_destroy; + posix_spawnattr_getflags; + posix_spawnattr_getpgroup; + posix_spawnattr_getschedparam; + posix_spawnattr_getschedpolicy; + posix_spawnattr_getsigdefault; + posix_spawnattr_getsigmask; + posix_spawnattr_init; + posix_spawnattr_setflags; + posix_spawnattr_setpgroup; + posix_spawnattr_setschedparam; + posix_spawnattr_setschedpolicy; + posix_spawnattr_setsigdefault; + posix_spawnattr_setsigmask; + posix_spawn_file_actions_addclose; + posix_spawn_file_actions_adddup2; + posix_spawn_file_actions_addopen; + posix_spawn_file_actions_destroy; + posix_spawn_file_actions_init; + posix_spawnp; syncfs; } LIBC_O; diff --git a/libc/libc.mips.map b/libc/libc.mips.map index 3e41f9521..16f120988 100644 --- a/libc/libc.mips.map +++ b/libc/libc.mips.map @@ -1320,6 +1320,27 @@ LIBC_P { # introduced=P iconv; iconv_close; iconv_open; + posix_spawn; + posix_spawnattr_destroy; + posix_spawnattr_getflags; + posix_spawnattr_getpgroup; + posix_spawnattr_getschedparam; + posix_spawnattr_getschedpolicy; + posix_spawnattr_getsigdefault; + posix_spawnattr_getsigmask; + posix_spawnattr_init; + posix_spawnattr_setflags; + posix_spawnattr_setpgroup; + posix_spawnattr_setschedparam; + posix_spawnattr_setschedpolicy; + posix_spawnattr_setsigdefault; + posix_spawnattr_setsigmask; + posix_spawn_file_actions_addclose; + posix_spawn_file_actions_adddup2; + posix_spawn_file_actions_addopen; + posix_spawn_file_actions_destroy; + posix_spawn_file_actions_init; + posix_spawnp; syncfs; } LIBC_O; diff --git a/libc/libc.mips64.map b/libc/libc.mips64.map index 9d8c1b7d6..400c95f74 100644 --- a/libc/libc.mips64.map +++ b/libc/libc.mips64.map @@ -1256,6 +1256,27 @@ LIBC_P { # introduced=P iconv; iconv_close; iconv_open; + posix_spawn; + posix_spawnattr_destroy; + posix_spawnattr_getflags; + posix_spawnattr_getpgroup; + posix_spawnattr_getschedparam; + posix_spawnattr_getschedpolicy; + posix_spawnattr_getsigdefault; + posix_spawnattr_getsigmask; + posix_spawnattr_init; + posix_spawnattr_setflags; + posix_spawnattr_setpgroup; + posix_spawnattr_setschedparam; + posix_spawnattr_setschedpolicy; + posix_spawnattr_setsigdefault; + posix_spawnattr_setsigmask; + posix_spawn_file_actions_addclose; + posix_spawn_file_actions_adddup2; + posix_spawn_file_actions_addopen; + posix_spawn_file_actions_destroy; + posix_spawn_file_actions_init; + posix_spawnp; syncfs; } LIBC_O; diff --git a/libc/libc.x86.map b/libc/libc.x86.map index c3d678c34..94ee319bb 100644 --- a/libc/libc.x86.map +++ b/libc/libc.x86.map @@ -1318,6 +1318,27 @@ LIBC_P { # introduced=P iconv; iconv_close; iconv_open; + posix_spawn; + posix_spawnattr_destroy; + posix_spawnattr_getflags; + posix_spawnattr_getpgroup; + posix_spawnattr_getschedparam; + posix_spawnattr_getschedpolicy; + posix_spawnattr_getsigdefault; + posix_spawnattr_getsigmask; + posix_spawnattr_init; + posix_spawnattr_setflags; + posix_spawnattr_setpgroup; + posix_spawnattr_setschedparam; + posix_spawnattr_setschedpolicy; + posix_spawnattr_setsigdefault; + posix_spawnattr_setsigmask; + posix_spawn_file_actions_addclose; + posix_spawn_file_actions_adddup2; + posix_spawn_file_actions_addopen; + posix_spawn_file_actions_destroy; + posix_spawn_file_actions_init; + posix_spawnp; syncfs; } LIBC_O; diff --git a/libc/libc.x86_64.map b/libc/libc.x86_64.map index 9d8c1b7d6..400c95f74 100644 --- a/libc/libc.x86_64.map +++ b/libc/libc.x86_64.map @@ -1256,6 +1256,27 @@ LIBC_P { # introduced=P iconv; iconv_close; iconv_open; + posix_spawn; + posix_spawnattr_destroy; + posix_spawnattr_getflags; + posix_spawnattr_getpgroup; + posix_spawnattr_getschedparam; + posix_spawnattr_getschedpolicy; + posix_spawnattr_getsigdefault; + posix_spawnattr_getsigmask; + posix_spawnattr_init; + posix_spawnattr_setflags; + posix_spawnattr_setpgroup; + posix_spawnattr_setschedparam; + posix_spawnattr_setschedpolicy; + posix_spawnattr_setsigdefault; + posix_spawnattr_setsigmask; + posix_spawn_file_actions_addclose; + posix_spawn_file_actions_adddup2; + posix_spawn_file_actions_addopen; + posix_spawn_file_actions_destroy; + posix_spawn_file_actions_init; + posix_spawnp; syncfs; } LIBC_O; diff --git a/libc/private/ScopedSignalBlocker.h b/libc/private/ScopedSignalBlocker.h new file mode 100644 index 000000000..35d1c5830 --- /dev/null +++ b/libc/private/ScopedSignalBlocker.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SCOPED_SIGNAL_BLOCKER_H +#define SCOPED_SIGNAL_BLOCKER_H + +#include + +#include "bionic_macros.h" + +class ScopedSignalBlocker { + public: + explicit ScopedSignalBlocker() { + sigset_t set; + sigfillset(&set); + sigprocmask(SIG_BLOCK, &set, &old_set_); + } + + ~ScopedSignalBlocker() { + reset(); + } + + void reset() { + sigprocmask(SIG_SETMASK, &old_set_, nullptr); + } + + private: + sigset_t old_set_; + + DISALLOW_COPY_AND_ASSIGN(ScopedSignalBlocker); +}; + +#endif diff --git a/tests/Android.bp b/tests/Android.bp index fb8b886fa..7094d778c 100644 --- a/tests/Android.bp +++ b/tests/Android.bp @@ -105,6 +105,7 @@ cc_test_library { "semaphore_test.cpp", "setjmp_test.cpp", "signal_test.cpp", + "spawn_test.cpp", "stack_protector_test.cpp", "stack_protector_test_helper.cpp", "stack_unwinding_test.cpp", diff --git a/tests/spawn_test.cpp b/tests/spawn_test.cpp new file mode 100644 index 000000000..6a3920e39 --- /dev/null +++ b/tests/spawn_test.cpp @@ -0,0 +1,388 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include +#include +#include + +#include "utils.h" + +#include +#include + +// Old versions of glibc didn't have POSIX_SPAWN_SETSID. +#if __GLIBC__ +# if !defined(POSIX_SPAWN_SETSID) +# define POSIX_SPAWN_SETSID 0 +# endif +#endif + +TEST(spawn, posix_spawnattr_init_posix_spawnattr_destroy) { + posix_spawnattr_t sa; + ASSERT_EQ(0, posix_spawnattr_init(&sa)); + ASSERT_EQ(0, posix_spawnattr_destroy(&sa)); +} + +TEST(spawn, posix_spawnattr_setflags_EINVAL) { + posix_spawnattr_t sa; + ASSERT_EQ(0, posix_spawnattr_init(&sa)); + ASSERT_EQ(EINVAL, posix_spawnattr_setflags(&sa, ~0)); + ASSERT_EQ(0, posix_spawnattr_destroy(&sa)); +} + +TEST(spawn, posix_spawnattr_setflags_posix_spawnattr_getflags) { + posix_spawnattr_t sa; + ASSERT_EQ(0, posix_spawnattr_init(&sa)); + + ASSERT_EQ(0, posix_spawnattr_setflags(&sa, POSIX_SPAWN_RESETIDS)); + short flags; + ASSERT_EQ(0, posix_spawnattr_getflags(&sa, &flags)); + ASSERT_EQ(POSIX_SPAWN_RESETIDS, flags); + + constexpr short all_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; + ASSERT_EQ(0, posix_spawnattr_setflags(&sa, all_flags)); + ASSERT_EQ(0, posix_spawnattr_getflags(&sa, &flags)); + ASSERT_EQ(all_flags, flags); + + ASSERT_EQ(0, posix_spawnattr_destroy(&sa)); +} + +TEST(spawn, posix_spawnattr_setpgroup_posix_spawnattr_getpgroup) { + posix_spawnattr_t sa; + ASSERT_EQ(0, posix_spawnattr_init(&sa)); + + ASSERT_EQ(0, posix_spawnattr_setpgroup(&sa, 123)); + pid_t g; + ASSERT_EQ(0, posix_spawnattr_getpgroup(&sa, &g)); + ASSERT_EQ(123, g); + + ASSERT_EQ(0, posix_spawnattr_destroy(&sa)); +} + +TEST(spawn, posix_spawnattr_setsigmask_posix_spawnattr_getsigmask) { + posix_spawnattr_t sa; + ASSERT_EQ(0, posix_spawnattr_init(&sa)); + + sigset_t sigs; + ASSERT_EQ(0, posix_spawnattr_getsigmask(&sa, &sigs)); + ASSERT_FALSE(sigismember(&sigs, SIGALRM)); + + sigset_t just_SIGALRM; + sigemptyset(&just_SIGALRM); + sigaddset(&just_SIGALRM, SIGALRM); + ASSERT_EQ(0, posix_spawnattr_setsigmask(&sa, &just_SIGALRM)); + + ASSERT_EQ(0, posix_spawnattr_getsigmask(&sa, &sigs)); + ASSERT_TRUE(sigismember(&sigs, SIGALRM)); + + ASSERT_EQ(0, posix_spawnattr_destroy(&sa)); +} + +TEST(spawn, posix_spawnattr_setsigdefault_posix_spawnattr_getsigdefault) { + posix_spawnattr_t sa; + ASSERT_EQ(0, posix_spawnattr_init(&sa)); + + sigset_t sigs; + ASSERT_EQ(0, posix_spawnattr_getsigdefault(&sa, &sigs)); + ASSERT_FALSE(sigismember(&sigs, SIGALRM)); + + sigset_t just_SIGALRM; + sigemptyset(&just_SIGALRM); + sigaddset(&just_SIGALRM, SIGALRM); + ASSERT_EQ(0, posix_spawnattr_setsigdefault(&sa, &just_SIGALRM)); + + ASSERT_EQ(0, posix_spawnattr_getsigdefault(&sa, &sigs)); + ASSERT_TRUE(sigismember(&sigs, SIGALRM)); + + ASSERT_EQ(0, posix_spawnattr_destroy(&sa)); +} + +TEST(spawn, posix_spawnattr_setsschedparam_posix_spawnattr_getsschedparam) { + posix_spawnattr_t sa; + ASSERT_EQ(0, posix_spawnattr_init(&sa)); + + sched_param sp; + ASSERT_EQ(0, posix_spawnattr_getschedparam(&sa, &sp)); + ASSERT_EQ(0, sp.sched_priority); + + sched_param sp123 = { .sched_priority = 123 }; + ASSERT_EQ(0, posix_spawnattr_setschedparam(&sa, &sp123)); + + ASSERT_EQ(0, posix_spawnattr_getschedparam(&sa, &sp)); + ASSERT_EQ(123, sp.sched_priority); + + ASSERT_EQ(0, posix_spawnattr_destroy(&sa)); +} + +TEST(spawn, posix_spawnattr_setschedpolicy_posix_spawnattr_getschedpolicy) { + posix_spawnattr_t sa; + ASSERT_EQ(0, posix_spawnattr_init(&sa)); + + int p; + ASSERT_EQ(0, posix_spawnattr_getschedpolicy(&sa, &p)); + ASSERT_EQ(0, p); + + ASSERT_EQ(0, posix_spawnattr_setschedpolicy(&sa, SCHED_FIFO)); + + ASSERT_EQ(0, posix_spawnattr_getschedpolicy(&sa, &p)); + ASSERT_EQ(SCHED_FIFO, p); + + ASSERT_EQ(0, posix_spawnattr_destroy(&sa)); +} + +TEST(spawn, posix_spawn) { + ExecTestHelper eth; + eth.SetArgs({BIN_DIR "true", nullptr}); + pid_t pid; + ASSERT_EQ(0, posix_spawn(&pid, eth.GetArg0(), nullptr, nullptr, eth.GetArgs(), nullptr)); + AssertChildExited(pid, 0); +} + +TEST(spawn, posix_spawn_not_found) { + ExecTestHelper eth; + eth.SetArgs({"true", nullptr}); + pid_t pid; + ASSERT_EQ(0, posix_spawn(&pid, eth.GetArg0(), nullptr, nullptr, eth.GetArgs(), nullptr)); + AssertChildExited(pid, 127); +} + +TEST(spawn, posix_spawnp) { + ExecTestHelper eth; + eth.SetArgs({"true", nullptr}); + pid_t pid; + ASSERT_EQ(0, posix_spawnp(&pid, eth.GetArg0(), nullptr, nullptr, eth.GetArgs(), nullptr)); + AssertChildExited(pid, 0); +} + +TEST(spawn, posix_spawnp_not_found) { + ExecTestHelper eth; + eth.SetArgs({"does-not-exist", nullptr}); + pid_t pid; + ASSERT_EQ(0, posix_spawnp(&pid, eth.GetArg0(), nullptr, nullptr, eth.GetArgs(), nullptr)); + AssertChildExited(pid, 127); +} + +TEST(spawn, posix_spawn_environment) { + ExecTestHelper eth; + eth.SetArgs({"sh", "-c", "exit $posix_spawn_environment_test", nullptr}); + eth.SetEnv({"posix_spawn_environment_test=66", nullptr}); + pid_t pid; + ASSERT_EQ(0, posix_spawnp(&pid, eth.GetArg0(), nullptr, nullptr, eth.GetArgs(), eth.GetEnv())); + AssertChildExited(pid, 66); +} + +TEST(spawn, posix_spawn_file_actions) { + int fds[2]; + ASSERT_NE(-1, pipe(fds)); + + posix_spawn_file_actions_t fa; + ASSERT_EQ(0, posix_spawn_file_actions_init(&fa)); + + ASSERT_EQ(0, posix_spawn_file_actions_addclose(&fa, fds[0])); + ASSERT_EQ(0, posix_spawn_file_actions_adddup2(&fa, fds[1], 1)); + ASSERT_EQ(0, posix_spawn_file_actions_addclose(&fa, fds[1])); + // Check that close(2) failures are ignored by closing the same fd again. + ASSERT_EQ(0, posix_spawn_file_actions_addclose(&fa, fds[1])); + ASSERT_EQ(0, posix_spawn_file_actions_addopen(&fa, 56, "/proc/version", O_RDONLY, 0)); + + ExecTestHelper eth; + eth.SetArgs({"ls", "-l", "/proc/self/fd", nullptr}); + pid_t pid; + ASSERT_EQ(0, posix_spawnp(&pid, eth.GetArg0(), &fa, nullptr, eth.GetArgs(), eth.GetEnv())); + ASSERT_EQ(0, posix_spawn_file_actions_destroy(&fa)); + + ASSERT_EQ(0, close(fds[1])); + std::string content; + ASSERT_TRUE(android::base::ReadFdToString(fds[0], &content)); + ASSERT_EQ(0, close(fds[0])); + + AssertChildExited(pid, 0); + + // We'll know the dup2 worked if we see any ls(1) output in our pipe. + // The open we can check manually... + bool open_to_fd_56_worked = false; + for (const auto& line : android::base::Split(content, "\n")) { + if (line.find(" 56 -> /proc/version") != std::string::npos) open_to_fd_56_worked = true; + } + ASSERT_TRUE(open_to_fd_56_worked); +} + +static void CatFileToString(posix_spawnattr_t* sa, const char* path, std::string* content) { + int fds[2]; + ASSERT_NE(-1, pipe(fds)); + + posix_spawn_file_actions_t fa; + ASSERT_EQ(0, posix_spawn_file_actions_init(&fa)); + ASSERT_EQ(0, posix_spawn_file_actions_addclose(&fa, fds[0])); + ASSERT_EQ(0, posix_spawn_file_actions_adddup2(&fa, fds[1], 1)); + ASSERT_EQ(0, posix_spawn_file_actions_addclose(&fa, fds[1])); + + ExecTestHelper eth; + eth.SetArgs({"cat", path, nullptr}); + pid_t pid; + ASSERT_EQ(0, posix_spawnp(&pid, eth.GetArg0(), &fa, sa, eth.GetArgs(), nullptr)); + ASSERT_EQ(0, posix_spawn_file_actions_destroy(&fa)); + + ASSERT_EQ(0, close(fds[1])); + ASSERT_TRUE(android::base::ReadFdToString(fds[0], content)); + ASSERT_EQ(0, close(fds[0])); + AssertChildExited(pid, 0); +} + +struct ProcStat { + pid_t pid; + pid_t ppid; + pid_t pgrp; + pid_t sid; +}; + +static void GetChildStat(posix_spawnattr_t* sa, ProcStat* ps) { + std::string content; + CatFileToString(sa, "/proc/self/stat", &content); + + ASSERT_EQ(4, sscanf(content.c_str(), "%d (cat) %*c %d %d %d", &ps->pid, &ps->ppid, &ps->pgrp, + &ps->sid)); + + ASSERT_EQ(getpid(), ps->ppid); +} + +struct ProcStatus { + uint64_t sigblk; + uint64_t sigign; +}; + +static void GetChildStatus(posix_spawnattr_t* sa, ProcStatus* ps) { + std::string content; + CatFileToString(sa, "/proc/self/status", &content); + + bool saw_blk = false; + bool saw_ign = false; + for (const auto& line : android::base::Split(content, "\n")) { + if (sscanf(line.c_str(), "SigBlk: %" SCNx64, &ps->sigblk) == 1) saw_blk = true; + if (sscanf(line.c_str(), "SigIgn: %" SCNx64, &ps->sigign) == 1) saw_ign = true; + } + ASSERT_TRUE(saw_blk); + ASSERT_TRUE(saw_ign); +} + +TEST(spawn, posix_spawn_POSIX_SPAWN_SETSID_clear) { + pid_t parent_sid = getsid(0); + + posix_spawnattr_t sa; + ASSERT_EQ(0, posix_spawnattr_init(&sa)); + ASSERT_EQ(0, posix_spawnattr_setflags(&sa, 0)); + + ProcStat ps = {}; + GetChildStat(&sa, &ps); + ASSERT_EQ(parent_sid, ps.sid); + ASSERT_EQ(0, posix_spawnattr_destroy(&sa)); +} + +TEST(spawn, posix_spawn_POSIX_SPAWN_SETSID_set) { + pid_t parent_sid = getsid(0); + + posix_spawnattr_t sa; + ASSERT_EQ(0, posix_spawnattr_init(&sa)); + ASSERT_EQ(0, posix_spawnattr_setflags(&sa, POSIX_SPAWN_SETSID)); + + ProcStat ps = {}; + GetChildStat(&sa, &ps); + ASSERT_NE(parent_sid, ps.sid); + ASSERT_EQ(0, posix_spawnattr_destroy(&sa)); +} + +TEST(spawn, posix_spawn_POSIX_SPAWN_SETPGROUP_clear) { + pid_t parent_pgrp = getpgrp(); + + posix_spawnattr_t sa; + ASSERT_EQ(0, posix_spawnattr_init(&sa)); + ASSERT_EQ(0, posix_spawnattr_setflags(&sa, 0)); + + ProcStat ps = {}; + GetChildStat(&sa, &ps); + ASSERT_EQ(parent_pgrp, ps.pgrp); + ASSERT_EQ(0, posix_spawnattr_destroy(&sa)); +} + +TEST(spawn, posix_spawn_POSIX_SPAWN_SETPGROUP_set) { + pid_t parent_pgrp = getpgrp(); + + posix_spawnattr_t sa; + ASSERT_EQ(0, posix_spawnattr_init(&sa)); + ASSERT_EQ(0, posix_spawnattr_setpgroup(&sa, 0)); + ASSERT_EQ(0, posix_spawnattr_setflags(&sa, POSIX_SPAWN_SETPGROUP)); + + ProcStat ps = {}; + GetChildStat(&sa, &ps); + ASSERT_NE(parent_pgrp, ps.pgrp); + // Setting pgid 0 means "the same as the caller's pid". + ASSERT_EQ(ps.pid, ps.pgrp); + ASSERT_EQ(0, posix_spawnattr_destroy(&sa)); +} + +TEST(spawn, posix_spawn_POSIX_SPAWN_SETSIGMASK) { + // Block SIGBUS in the parent... + sigset_t just_SIGBUS; + sigemptyset(&just_SIGBUS); + sigaddset(&just_SIGBUS, SIGBUS); + ASSERT_EQ(0, sigprocmask(SIG_BLOCK, &just_SIGBUS, nullptr)); + + posix_spawnattr_t sa; + ASSERT_EQ(0, posix_spawnattr_init(&sa)); + + // Ask for only SIGALRM to be blocked in the child... + sigset_t just_SIGALRM; + sigemptyset(&just_SIGALRM); + sigaddset(&just_SIGALRM, SIGALRM); + ASSERT_EQ(0, posix_spawnattr_setsigmask(&sa, &just_SIGALRM)); + ASSERT_EQ(0, posix_spawnattr_setflags(&sa, POSIX_SPAWN_SETSIGMASK)); + + // Check that's what happens... + ProcStatus ps = {}; + GetChildStatus(&sa, &ps); + EXPECT_EQ(static_cast(1 << (SIGALRM - 1)), ps.sigblk); + EXPECT_EQ(static_cast(0), ps.sigign); + + ASSERT_EQ(0, posix_spawnattr_destroy(&sa)); +} + +TEST(spawn, posix_spawn_POSIX_SPAWN_SETSIGDEF) { + // Ignore SIGALRM and SIGCONT in the parent... + ASSERT_NE(SIG_ERR, signal(SIGALRM, SIG_IGN)); + ASSERT_NE(SIG_ERR, signal(SIGCONT, SIG_IGN)); + + posix_spawnattr_t sa; + ASSERT_EQ(0, posix_spawnattr_init(&sa)); + + // Ask for SIGALRM to be defaulted in the child... + sigset_t just_SIGALRM; + sigemptyset(&just_SIGALRM); + sigaddset(&just_SIGALRM, SIGALRM); + ASSERT_EQ(0, posix_spawnattr_setsigdefault(&sa, &just_SIGALRM)); + ASSERT_EQ(0, posix_spawnattr_setflags(&sa, POSIX_SPAWN_SETSIGDEF)); + + // Check that's what happens... + ProcStatus ps = {}; + GetChildStatus(&sa, &ps); + EXPECT_EQ(static_cast(0), ps.sigblk); + EXPECT_EQ(static_cast(1 << (SIGCONT - 1)), ps.sigign); + + ASSERT_EQ(0, posix_spawnattr_destroy(&sa)); +} diff --git a/tests/unistd_test.cpp b/tests/unistd_test.cpp index 92032154f..ced0315ab 100644 --- a/tests/unistd_test.cpp +++ b/tests/unistd_test.cpp @@ -736,6 +736,7 @@ TEST(UNISTD_TEST, _POSIX_macros_smoke) { EXPECT_GT(_POSIX_SEM_VALUE_MAX, 0); EXPECT_GT(_POSIX_SHELL, 0); EXPECT_GT(_POSIX_SIGQUEUE_MAX, 0); + EXPECT_EQ(_POSIX_VERSION, _POSIX_SPAWN); EXPECT_EQ(_POSIX_VERSION, _POSIX_SPORADIC_SERVER); EXPECT_GT(_POSIX_SSIZE_MAX, 0); EXPECT_GT(_POSIX_STREAM_MAX, 0); @@ -791,7 +792,6 @@ TEST(UNISTD_TEST, _POSIX_macros_smoke) { EXPECT_EQ(-1, _POSIX_MESSAGE_PASSING); EXPECT_EQ(-1, _POSIX_PRIORITIZED_IO); EXPECT_EQ(-1, _POSIX_SHARED_MEMORY_OBJECTS); - EXPECT_EQ(-1, _POSIX_SPAWN); EXPECT_EQ(-1, _POSIX_THREAD_ROBUST_PRIO_INHERIT); EXPECT_EQ(-1, _POSIX2_CHAR_TERM); @@ -915,6 +915,7 @@ TEST(UNISTD_TEST, sysconf) { VERIFY_SYSCONF_POSIX_VERSION(_SC_READER_WRITER_LOCKS); VERIFY_SYSCONF_POSITIVE(_SC_REGEXP); VERIFY_SYSCONF_POSITIVE(_SC_SHELL); + VERIFY_SYSCONF_POSIX_VERSION(_SC_SPAWN); VERIFY_SYSCONF_POSIX_VERSION(_SC_SPORADIC_SERVER); VERIFY_SYSCONF_POSITIVE(_SC_SYMLOOP_MAX); VERIFY_SYSCONF_POSIX_VERSION(_SC_THREAD_CPUTIME); @@ -954,7 +955,6 @@ TEST(UNISTD_TEST, sysconf) { VERIFY_SYSCONF_UNSUPPORTED(_SC_MESSAGE_PASSING); VERIFY_SYSCONF_UNSUPPORTED(_SC_PRIORITIZED_IO); VERIFY_SYSCONF_UNSUPPORTED(_SC_SHARED_MEMORY_OBJECTS); - VERIFY_SYSCONF_UNSUPPORTED(_SC_SPAWN); VERIFY_SYSCONF_UNSUPPORTED(_SC_THREAD_ROBUST_PRIO_INHERIT); VERIFY_SYSCONF_UNSUPPORTED(_SC_THREAD_ROBUST_PRIO_PROTECT); @@ -1212,12 +1212,6 @@ TEST(UNISTD_TEST, setdomainname) { } } -#if defined(__GLIBC__) -#define BIN_DIR "/bin/" -#else -#define BIN_DIR "/system/bin/" -#endif - TEST(UNISTD_TEST, execve_failure) { ExecTestHelper eth; errno = 0; diff --git a/tests/utils.h b/tests/utils.h index daf382e3e..ba006f12b 100644 --- a/tests/utils.h +++ b/tests/utils.h @@ -38,6 +38,12 @@ #define PATH_TO_SYSTEM_LIB "/system/lib/" #endif +#if defined(__GLIBC__) +#define BIN_DIR "/bin/" +#else +#define BIN_DIR "/system/bin/" +#endif + #if defined(__BIONIC__) #define KNOWN_FAILURE_ON_BIONIC(x) xfail_ ## x #else @@ -159,6 +165,9 @@ class ExecTestHelper { char** GetArgs() { return const_cast(args_.data()); } + const char* GetArg0() { + return args_[0]; + } char** GetEnv() { return const_cast(env_.data()); }