From patchwork Wed Sep 14 18:56:09 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella Netto X-Patchwork-Id: 15640 Received: (qmail 130999 invoked by alias); 14 Sep 2016 18:56:34 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Delivered-To: mailing list libc-alpha@sourceware.org Received: (qmail 130960 invoked by uid 89); 14 Sep 2016 18:56:33 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.4 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_NONE, RCVD_IN_SORBS_SPAM, SPF_PASS autolearn=no version=3.3.2 spammy=pipes, cancelled, cancellation, act X-HELO: mail-yw0-f180.google.com X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:subject:date:message-id; bh=ZA0+94qeqgG/IYVZbkjQywAvzBsT/JUZj5nYujD2DXY=; b=XOEI2Z9v6GkThwvzkVTfwk/BFtsUvP8Y6ZGS9roUPBYg7DEZsE8Zx9z6eu/t/Pw7Ui Zx56okw1rk7wo4k5mdmoA0mShT1t2Z4afXk/C2jDms+jF8yXjzRhaKuiJRBRCUiOhi2H grVpualv0meaNhdB2su23JTRGQxHisY+F0E4VVz12xHmG5OoJp8uh/XbLhPLDchen/dP Pq/uXp9WjhxNImSRDD8KQQwKdZXBI5nzb5w6GZNNR33oUCEYYVXVVepmk4YQBiu6G0wA ugaC2IuR9eZBCJ8Q0jZ+Uvi6uk3FQZYWMCpi7B+fQQ6ybIOy8vmXEIaxFQvD3RaTo5N5 uzww== X-Gm-Message-State: AE9vXwMLcxqFOMBRZCoE+fREiACnndhMuzMfebScrH0bvFzqaHsvZW5G6avOU0dZ29LX+JNH X-Received: by 10.129.40.146 with SMTP id o140mr4261439ywo.99.1473879381665; Wed, 14 Sep 2016 11:56:21 -0700 (PDT) From: Adhemerval Zanella To: libc-alpha@sourceware.org Subject: [PATCH 1/2] posix: Correctly enable/disable cancellation on Linux posix_spawn Date: Wed, 14 Sep 2016 15:56:09 -0300 Message-Id: <1473879370-6731-1-git-send-email-adhemerval.zanella@linaro.org> This patch correctly enable and disable asynchronous cancellation on Linux posix_spawn. Current code invert the logic by enabling and disabling instead. A new test that checks if posix_spawn is not in fact a cancellation entrypoint is added. Checked on x86_64, i686, powerpc64le, and aarch64. * nptl/Makefile (tests): Add tst-exec5. * nptl/tst-exec5.c: New file. * sysdeps/unix/sysv/linux/spawni.c (__spawni): Correctly enable and disable asynchronous cancellation. --- nptl/Makefile | 2 +- nptl/tst-exec5.c | 200 +++++++++++++++++++++++++++++++++++++++ sysdeps/unix/sysv/linux/spawni.c | 6 +- 4 files changed, 212 insertions(+), 3 deletions(-) create mode 100644 nptl/tst-exec5.c diff --git a/nptl/Makefile b/nptl/Makefile index 2ddcd2b..390e1f7 100644 --- a/nptl/Makefile +++ b/nptl/Makefile @@ -268,7 +268,7 @@ tests = tst-typesizes \ tst-flock1 tst-flock2 \ tst-signal1 tst-signal2 tst-signal3 tst-signal4 tst-signal5 \ tst-signal6 tst-signal7 \ - tst-exec1 tst-exec2 tst-exec3 tst-exec4 \ + tst-exec1 tst-exec2 tst-exec3 tst-exec4 tst-exec5 \ tst-exit1 tst-exit2 tst-exit3 \ tst-stdio1 tst-stdio2 \ tst-stack1 tst-stack2 tst-stack3 tst-stack4 tst-pthread-getattr \ diff --git a/nptl/tst-exec5.c b/nptl/tst-exec5.c new file mode 100644 index 0000000..5527b23 --- /dev/null +++ b/nptl/tst-exec5.c @@ -0,0 +1,200 @@ +/* Check if posix_spawn does not act as a cancellation entrypoint. + Copyright (C) 2016 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static pthread_barrier_t b; + +static struct thread_args +{ + pid_t pid; + int fd[2]; +} targ; + +static void * +tf (void *arg) +{ + int e = pthread_barrier_wait (&b); + if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD) + { + puts ("error: pthread_barrier_wait failed"); + exit (1); + } + + posix_spawn_file_actions_t a; + if (posix_spawn_file_actions_init (&a) != 0) + { + puts ("error: spawn_file_actions_init failed"); + exit (1); + } + + if (posix_spawn_file_actions_adddup2 (&a, targ.fd[1], STDOUT_FILENO) != 0) + { + puts ("error: spawn_file_actions_adddup2 failed"); + exit (1); + } + + if (posix_spawn_file_actions_addclose (&a, targ.fd[0]) != 0) + { + puts ("error: spawn_file_actions_addclose"); + exit (1); + } + + char *argv[] = { (char *) _PATH_BSHELL, (char *) "-c", (char *) "echo $$", + NULL }; + if (posix_spawn (&targ.pid, _PATH_BSHELL, &a, NULL, argv, NULL) != 0) + { + puts ("error: spawn failed"); + exit (1); + } + + return NULL; +} + + +static int +do_test (void) +{ + /* The test basically pipes a 'echo $$' created by a thread with a + cancellation pending. It then checks if the thread is not + cancelled, the process is created, and if the output is the expected + one (the process pid). */ + + if (pipe (targ.fd) != 0) + { + puts ("error: pipe failed"); + exit (1); + } + + /* Not interested in knowing when the pipe is closed. */ + if (sigignore (SIGPIPE) != 0) + { + puts ("error: sigignore failed"); + exit (1); + } + + if (pthread_barrier_init (&b, NULL, 2) != 0) + { + puts ("error: pthread_barrier_init failed"); + exit (1); + } + + pthread_t th; + if (pthread_create (&th, NULL, tf, &targ) != 0) + { + puts ("error: pthread_create failed"); + exit (1); + } + + if (pthread_cancel (th) != 0) + { + puts ("error: pthread_cancel failed"); + return 1; + } + + int e = pthread_barrier_wait (&b); + if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD) + { + puts ("error: pthread_barrier_wait failed"); + exit (1); + } + + void *r; + if (pthread_join (th, &r) != 0) + { + puts ("error: pthread_join failed"); + exit (1); + } + + if (r == PTHREAD_CANCELED) + { + puts ("error: thread cancelled"); + exit (1); + } + + close (targ.fd[1]); + + /* The spawn_posix pid should be set by thread, check if it was executed + correctly and with expected output. */ + + char buf[64]; + ssize_t n; + bool seen_pid = false; + while (TEMP_FAILURE_RETRY ((n = read (targ.fd[0], buf, sizeof (buf)))) > 0) + { + /* We only expect to read the PID. */ + char *endp; + long int rpid = strtol (buf, &endp, 10); + + if (*endp != '\n') + { + printf ("error: didn't parse whole line: \"%s\"\n", buf); + exit (1); + } + if (endp == buf) + { + puts ("error: read empty line"); + exit (1); + } + + if (rpid != targ.pid) + { + printf ("error: found \"%s\", expected PID %ld\n", buf, + (long int) targ.pid); + exit (1); + } + + if (seen_pid) + { + puts ("error: found more than one PID line"); + exit (1); + } + + seen_pid = true; + } + + close (targ.fd[0]); + + int status; + int err = waitpid (targ.pid, &status, 0); + if (err != targ.pid) + { + puts ("errnor: waitpid failed"); + exit (1); + } + + if (!seen_pid) + { + puts ("error: didn't get PID"); + exit (1); + } + + return 0; +} + +#define TEST_FUNCTION do_test () +#include diff --git a/sysdeps/unix/sysv/linux/spawni.c b/sysdeps/unix/sysv/linux/spawni.c index 0b76657..f7cb96f 100644 --- a/sysdeps/unix/sysv/linux/spawni.c +++ b/sysdeps/unix/sysv/linux/spawni.c @@ -317,7 +317,9 @@ __spawnix (pid_t * pid, const char *file, return errno; /* Disable asynchronous cancellation. */ - int cs = LIBC_CANCEL_ASYNC (); + int state; + __libc_ptf_call (__pthread_setcancelstate, + (PTHREAD_CANCEL_DISABLE, &state), 0); args.file = file; args.exec = exec; @@ -357,7 +359,7 @@ __spawnix (pid_t * pid, const char *file, __sigprocmask (SIG_SETMASK, &args.oldmask, 0); - LIBC_CANCEL_RESET (cs); + __libc_ptf_call (__pthread_setcancelstate, (state, NULL), 0); return ec; }