Implement <spawn.h>.
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
This commit is contained in:
Elliott Hughes
parent
e387c2f088
commit
14e3ff9f09
18 changed files with 1003 additions and 52 deletions
|
|
@ -8,8 +8,12 @@ Current libc symbols: https://android.googlesource.com/platform/bionic/+/master/
|
|||
|
||||
New libc functions in P:
|
||||
* `__freading`/`__fwriting` (completing <stdio_ext.h>)
|
||||
* `getentropy`/`getrandom` (adding <sys/random.h>)
|
||||
* `getlogin_r`
|
||||
* `glob`/`globfree` (adding <glob.h>)
|
||||
* `hcreate`/hcreate_r`/`hdestroy`/`hdestroy_r`/`hsearch`/`hsearch_r` (completing <search.h>)
|
||||
* `iconv`/`iconv_close`/`iconv_open` (adding <iconv.h>)
|
||||
* <spawn.h>
|
||||
* `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
|
||||
|
|
|
|||
|
|
@ -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",
|
||||
|
|
|
|||
316
libc/bionic/spawn.cpp
Normal file
316
libc/bionic/spawn.cpp
Normal file
|
|
@ -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 <spawn.h>
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <signal.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#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);
|
||||
}
|
||||
|
|
@ -39,22 +39,7 @@
|
|||
#include <unistd.h>
|
||||
|
||||
#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;
|
||||
|
|
|
|||
|
|
@ -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 /* <spawn.h> */
|
||||
#define _POSIX_SPAWN __BIONIC_POSIX_FEATURE_SINCE(28) /* <spawn.h> */
|
||||
#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
|
||||
|
|
|
|||
86
libc/include/spawn.h
Normal file
86
libc/include/spawn.h
Normal file
|
|
@ -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 <sys/cdefs.h>
|
||||
#include <sys/types.h>
|
||||
#include <sched.h>
|
||||
#include <signal.h>
|
||||
|
||||
__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
|
||||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
46
libc/private/ScopedSignalBlocker.h
Normal file
46
libc/private/ScopedSignalBlocker.h
Normal file
|
|
@ -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 <signal.h>
|
||||
|
||||
#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
|
||||
|
|
@ -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",
|
||||
|
|
|
|||
388
tests/spawn_test.cpp
Normal file
388
tests/spawn_test.cpp
Normal file
|
|
@ -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 <spawn.h>
|
||||
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "utils.h"
|
||||
|
||||
#include <android-base/file.h>
|
||||
#include <android-base/strings.h>
|
||||
|
||||
// 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<uint64_t>(1 << (SIGALRM - 1)), ps.sigblk);
|
||||
EXPECT_EQ(static_cast<uint64_t>(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<uint64_t>(0), ps.sigblk);
|
||||
EXPECT_EQ(static_cast<uint64_t>(1 << (SIGCONT - 1)), ps.sigign);
|
||||
|
||||
ASSERT_EQ(0, posix_spawnattr_destroy(&sa));
|
||||
}
|
||||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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<char**>(args_.data());
|
||||
}
|
||||
const char* GetArg0() {
|
||||
return args_[0];
|
||||
}
|
||||
char** GetEnv() {
|
||||
return const_cast<char**>(env_.data());
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue