From patchwork Fri Oct 9 17:50:28 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella X-Patchwork-Id: 54732 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-wi0-f200.google.com (mail-wi0-f200.google.com [209.85.212.200]) by patches.linaro.org (Postfix) with ESMTPS id ECD9222DB6 for ; Fri, 9 Oct 2015 17:50:58 +0000 (UTC) Received: by wisv5 with SMTP id v5sf32880572wis.0 for ; Fri, 09 Oct 2015 10:50:58 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:mime-version:delivered-to:mailing-list :precedence:list-id:list-unsubscribe:list-subscribe:list-archive :list-post:list-help:sender:delivered-to:from:to:subject:date :message-id:x-original-sender:x-original-authentication-results; bh=Wolskn/Awrx5NphzGwayaDT3i6CLTI2nEW8LtujGtDs=; b=MAUXtxaeEUryPDT3+8uYXfZtK8+YmDh+qgI+AYLoRDl3P+/bHPYqJFKffQWoqwPCOF 0HLiMYzGQor0bjz1xC0lzH1CYu5q94XPJqltkUfoD3B2yszHiIJ9JhOBiOyuBfd+cbsG Ra2dfH+OX8WTfDJ/RFpnJzPlornXcMAOrgM85pLEIWIH96q5/fjgZwyiagv9s46xl078 P5LqW/R6v+8aSu/H+iFPwCPlud5IjgpxY8k3M471wExMfDDrMl3pm8zPbnrRQfgNLDKJ H3raw4Vg0SuL2JzPui6SWPP0K+CyqITFqPGpUNdEOASWC5Oi5a6tVMB4L/EDJ6Ttx6p+ lxXw== X-Gm-Message-State: ALoCoQnaa/Nz8acyQVCI18jcuhQ8BTvu0vh9ymSDbHrhn+gaGnpPPq88vwz1tcIkm2RrPLNjdhYd X-Received: by 10.112.140.202 with SMTP id ri10mr2211107lbb.10.1444413058199; Fri, 09 Oct 2015 10:50:58 -0700 (PDT) MIME-Version: 1.0 X-BeenThere: patchwork-forward@linaro.org Received: by 10.25.159.82 with SMTP id i79ls303001lfe.102.gmail; Fri, 09 Oct 2015 10:50:58 -0700 (PDT) X-Received: by 10.25.23.40 with SMTP id n40mr4768472lfi.52.1444413058067; Fri, 09 Oct 2015 10:50:58 -0700 (PDT) Received: from mail-lb0-x22c.google.com (mail-lb0-x22c.google.com. [2a00:1450:4010:c04::22c]) by mx.google.com with ESMTPS id c3si2004670lfc.113.2015.10.09.10.50.57 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Fri, 09 Oct 2015 10:50:57 -0700 (PDT) Received-SPF: pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 2a00:1450:4010:c04::22c as permitted sender) client-ip=2a00:1450:4010:c04::22c; Received: by lbcao8 with SMTP id ao8so89605094lbc.3 for ; Fri, 09 Oct 2015 10:50:57 -0700 (PDT) X-Received: by 10.25.86.213 with SMTP id k204mr4705569lfb.36.1444413057636; Fri, 09 Oct 2015 10:50:57 -0700 (PDT) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patch@linaro.org Received: by 10.112.59.35 with SMTP id w3csp126628lbq; Fri, 9 Oct 2015 10:50:55 -0700 (PDT) X-Received: by 10.50.114.1 with SMTP id jc1mr660984igb.56.1444413055008; Fri, 09 Oct 2015 10:50:55 -0700 (PDT) Received: from sourceware.org (server1.sourceware.org. [209.132.180.131]) by mx.google.com with ESMTPS id g141si3541033iog.91.2015.10.09.10.50.54 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Fri, 09 Oct 2015 10:50:54 -0700 (PDT) Received-SPF: pass (google.com: domain of libc-alpha-return-63879-patch=linaro.org@sourceware.org designates 209.132.180.131 as permitted sender) client-ip=209.132.180.131; Received: (qmail 78915 invoked by alias); 9 Oct 2015 17:50:42 -0000 Mailing-List: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org Precedence: list 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 78900 invoked by uid 89); 9 Oct 2015 17:50:41 -0000 X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.3 required=5.0 tests=AWL, BAYES_00, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=ham version=3.3.2 X-HELO: mail-yk0-f170.google.com X-Received: by 10.129.70.195 with SMTP id t186mr11129840ywa.4.1444413037288; Fri, 09 Oct 2015 10:50:37 -0700 (PDT) From: Adhemerval Zanella To: libc-alpha@sourceware.org Subject: [PATCH v2] nptl: Fix testcases for new pthread cancellation mechanism Date: Fri, 9 Oct 2015 14:50:28 -0300 Message-Id: <1444413028-18864-1-git-send-email-adhemerval.zanella@linaro.com> X-Original-Sender: adhemerval.zanella@linaro.org X-Original-Authentication-Results: mx.google.com; spf=pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 2a00:1450:4010:c04::22c as permitted sender) smtp.mailfrom=patch+caf_=patchwork-forward=linaro.org@linaro.org; dkim=pass header.i=@sourceware.org X-Google-Group-Id: 836684582541 Changes from v1: - Addressed comments wording. - Fix SIGCANCEL definition and use SIGINT for sigpause check instead. - Call sigpause instead of __xpg_sigpause. - Use mkfifo to check for early cancellation on open/open64 calls. With upcoming fix for BZ#12683, pthread cancellation does not act for: 1. If syscall is blocked but with some side effects already having taken place (e.g. a partial read or write) 2. After the syscall has returned. It is because program need to act on such cases (for instance, to avoid leak of allocated resources our handling partial read/write). This patches fixes the NPTL testcase that assumes the old behavior and also remove the tst-cancel-wrappers.sh test (which checks for symbols that does not exist anymore). It also add two more testcase to check both the returned and the errno value on case of a cancelled syscall. Tested on i686, x86_64, x32, powerpc64le, and aarch64. * nptl/Makefile [$(run-built-tests) = yes] (tests-special): Remove tst-cancel-wrappers.sh. * nptl/tst-cancel-wrappers.sh: Remove file. * nptl/tst-cancel2.c (tf): Add pthread_testcancel after cancellable syscall. * nptl/tst-cancel20.c (sh_body): Likewise. * nptl/tst-cancel21.c (sh_body): Likewise. (tf_body): Likewise. * nptl/tst-cancel4.c (tf_Write): Likewise. (tf_send): Likewise. (cl_fifo): New function: pipe handling for open/open64. (tf_sigpause): Use sigpause instead of __xpg_sigpausea and use SIGINT instead of SIGCANCEL. (tf_open): Use mkfifo to check for early cancel. (tf_open64): New test: check for open64 cancellable syscall. (tf_pread64): New test: check for pread64 cancellable syscall. (tf_pwrite64): New test: check for pwrite64 cancellable syscall. --- ChangeLog | 20 +++++ nptl/Makefile | 17 +--- nptl/tst-cancel-wrappers.sh | 92 ---------------------- nptl/tst-cancel2.c | 4 + nptl/tst-cancel20.c | 7 +- nptl/tst-cancel21.c | 6 ++ nptl/tst-cancel4.c | 183 ++++++++++++++++++++++++++++++++++++++++---- 7 files changed, 204 insertions(+), 125 deletions(-) delete mode 100644 nptl/tst-cancel-wrappers.sh diff --git a/nptl/Makefile b/nptl/Makefile index 311b1a7..b7ff3f1 100644 --- a/nptl/Makefile +++ b/nptl/Makefile @@ -398,8 +398,7 @@ tests-reverse += tst-cancel5 tst-cancel23 tst-vfork1x tst-vfork2x ifeq ($(run-built-tests),yes) tests-special += $(objpfx)tst-stack3-mem.out $(objpfx)tst-oddstacklimit.out ifeq ($(build-shared),yes) -tests-special += $(objpfx)tst-tls6.out $(objpfx)tst-cleanup0-cmp.out \ - $(objpfx)tst-cancel-wrappers.out +tests-special += $(objpfx)tst-tls6.out $(objpfx)tst-cleanup0-cmp.out endif endif @@ -615,7 +614,7 @@ $(objpfx)$(multidir)/crtn.o: $(objpfx)crtn.o $(objpfx)$(multidir)/ endif generated += libpthread_nonshared.a \ - multidir.mk tst-atfork2.mtrace tst-cancel-wrappers.out \ + multidir.mk tst-atfork2.mtrace \ tst-tls6.out generated += $(objpfx)tst-atfork2.mtrace \ @@ -632,18 +631,6 @@ LDFLAGS-pthread.so += -e __nptl_main $(objpfx)pt-interp.os: $(common-objpfx)runtime-linker.h endif -ifeq ($(run-built-tests),yes) -ifeq (yes,$(build-shared)) -$(objpfx)tst-cancel-wrappers.out: tst-cancel-wrappers.sh - $(SHELL) $< '$(NM)' \ - $(common-objpfx)libc_pic.a \ - $(common-objpfx)libc.a \ - $(objpfx)libpthread_pic.a \ - $(objpfx)libpthread.a > $@; \ - $(evaluate-test) -endif -endif - tst-exec4-ARGS = $(host-test-program-cmd) $(objpfx)tst-execstack: $(libdl) diff --git a/nptl/tst-cancel-wrappers.sh b/nptl/tst-cancel-wrappers.sh deleted file mode 100644 index d492a54..0000000 --- a/nptl/tst-cancel-wrappers.sh +++ /dev/null @@ -1,92 +0,0 @@ -#! /bin/sh -# Test whether all cancelable functions are cancelable. -# Copyright (C) 2002-2015 Free Software Foundation, Inc. -# This file is part of the GNU C Library. -# Contributed by Jakub Jelinek , 2002. - -# 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 -# . - -NM="$1"; shift -while [ $# -gt 0 ]; do - ( $NM -P $1; echo 'end[end]:' ) | gawk ' BEGIN { -C["accept"]=1 -C["close"]=1 -C["connect"]=1 -C["creat"]=1 -C["fcntl"]=1 -C["fdatasync"]=1 -C["fsync"]=1 -C["msgrcv"]=1 -C["msgsnd"]=1 -C["msync"]=1 -C["nanosleep"]=1 -C["open"]=1 -C["open64"]=1 -C["pause"]=1 -C["poll"]=1 -C["pread"]=1 -C["pread64"]=1 -C["pselect"]=1 -C["pwrite"]=1 -C["pwrite64"]=1 -C["read"]=1 -C["readv"]=1 -C["recv"]=1 -C["recvfrom"]=1 -C["recvmsg"]=1 -C["select"]=1 -C["send"]=1 -C["sendmsg"]=1 -C["sendto"]=1 -C["sigpause"]=1 -C["sigsuspend"]=1 -C["sigwait"]=1 -C["sigwaitinfo"]=1 -C["tcdrain"]=1 -C["wait"]=1 -C["waitid"]=1 -C["waitpid"]=1 -C["write"]=1 -C["writev"]=1 -C["__xpg_sigpause"]=1 -} -/:$/ { - if (seen) - { - if (!seen_enable || !seen_disable) - { - printf "in '$1'(%s) %s'\''s cancellation missing\n", object, seen - ret = 1 - } - } - seen="" - seen_enable="" - seen_disable="" - object=gensub(/^.*\[(.*)\]:$/, "\\1", 1, $0) - next -} -{ - if (C[$1] && $2 ~ /^[TW]$/) - seen=$1 - else if ($1 ~ /^([.]|)__(libc|pthread)_enable_asynccancel$/ && $2 == "U") - seen_enable=1 - else if ($1 ~ /^([.]|)__(libc|pthread)_disable_asynccancel$/ && $2 == "U") - seen_disable=1 -} -END { - exit ret -}' || exit - shift -done diff --git a/nptl/tst-cancel2.c b/nptl/tst-cancel2.c index 1a74992..93b8fc4 100644 --- a/nptl/tst-cancel2.c +++ b/nptl/tst-cancel2.c @@ -33,6 +33,10 @@ tf (void *arg) char buf[100000]; while (write (fd[1], buf, sizeof (buf)) > 0); + /* The write can return a value higher than 0 (meaning partial write) + due to the SIGCANCEL, but the thread may still be pending + cancellation. */ + pthread_testcancel (); return (void *) 42l; } diff --git a/nptl/tst-cancel20.c b/nptl/tst-cancel20.c index 51b558e..24f135a 100644 --- a/nptl/tst-cancel20.c +++ b/nptl/tst-cancel20.c @@ -49,6 +49,10 @@ sh_body (void) puts ("read succeeded"); exit (1); } + /* The write can return a value higher than 0 (meaning partial write) + due to the SIGCANCEL, but the thread may still be pending + cancellation. */ + pthread_testcancel (); pthread_cleanup_pop (0); } @@ -84,7 +88,8 @@ tf_body (void) puts ("read succeeded"); exit (1); } - + /* Check for partial read. */ + pthread_testcancel (); read (fd[0], &c, 1); pthread_cleanup_pop (0); diff --git a/nptl/tst-cancel21.c b/nptl/tst-cancel21.c index b54f236..da05087 100644 --- a/nptl/tst-cancel21.c +++ b/nptl/tst-cancel21.c @@ -50,6 +50,10 @@ sh_body (void) puts ("read succeeded"); exit (1); } + /* The write can return a value higher than 0 (meaning partial write) + due to the SIGCANCEL, but the thread may still be pending + cancellation. */ + pthread_testcancel (); pthread_cleanup_pop (0); } @@ -85,6 +89,8 @@ tf_body (void) puts ("read succeeded"); exit (1); } + /* Check partial read. */ + pthread_testcancel (); read (fd[0], &c, 1); diff --git a/nptl/tst-cancel4.c b/nptl/tst-cancel4.c index e50afd7..2748fcc 100644 --- a/nptl/tst-cancel4.c +++ b/nptl/tst-cancel4.c @@ -38,8 +38,6 @@ #include #include -#include "pthreadP.h" - /* Since STREAMS are not supported in the standard Linux kernel and there we don't advertise STREAMS as supported is no need to test @@ -117,7 +115,20 @@ cl (void *arg) ++cl_called; } +/* Named pipe used to check for blocking open. It should be closed + after the cancellation handling. */ +static char fifoname[] = "/tmp/tst-cancel4-fifo-XXXXXX"; +static int fifofd; +static void +cl_fifo (void *arg) +{ + ++cl_called; + + unlink (fifoname); + close (fifofd); + fifofd = -1; +} static void * tf_read (void *arg) @@ -247,6 +258,10 @@ tf_write (void *arg) char buf[WRITE_BUFFER_SIZE]; memset (buf, '\0', sizeof (buf)); s = write (fd, buf, sizeof (buf)); + /* The write can return a value higher than 0 (meaning partial write) + due to the SIGCANCEL, but the thread may still be pending + cancellation. */ + pthread_testcancel (); pthread_cleanup_pop (0); @@ -781,13 +796,7 @@ tf_sigpause (void *arg) pthread_cleanup_push (cl, NULL); -#ifdef SIGCANCEL - /* Just for fun block the cancellation signal. We need to use - __xpg_sigpause since otherwise we will get the BSD version. */ - __xpg_sigpause (SIGCANCEL); -#else - pause (); -#endif + sigpause (sigmask (SIGINT)); pthread_cleanup_pop (0); @@ -1143,6 +1152,8 @@ tf_send (void *arg) char mem[700000]; send (tempfd2, mem, arg == NULL ? sizeof (mem) : 1, 0); + /* Check for partial send. */ + pthread_testcancel (); pthread_cleanup_pop (0); @@ -1396,9 +1407,23 @@ static void * tf_open (void *arg) { if (arg == NULL) - // XXX If somebody can provide a portable test case in which open() - // blocks we can enable this test to run in both rounds. - abort (); + { + fifofd = mkfifo (fifoname, S_IWUSR | S_IRUSR); + if (fifofd == -1) + { + printf ("%s: mkfifo failed\n", __FUNCTION__); + exit (1); + } + } + else + { + int r = pthread_barrier_wait (&b2); + if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD) + { + printf ("%s: barrier_wait failed\n", __FUNCTION__); + exit (1); + } + } int r = pthread_barrier_wait (&b2); if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD) @@ -1407,16 +1432,49 @@ tf_open (void *arg) exit (1); } - r = pthread_barrier_wait (&b2); + pthread_cleanup_push (cl_fifo, NULL); + + open (arg ? "Makefile" : fifoname, O_RDONLY); + + pthread_cleanup_pop (0); + + printf ("%s: open returned\n", __FUNCTION__); + + exit (1); +} + +static void * +tf_open64 (void *arg) +{ + if (arg == NULL) + { + fifofd = mkfifo (fifoname, S_IWUSR | S_IRUSR); + if (fifofd == -1) + { + printf ("%s: mkfifo failed\n", __FUNCTION__); + exit (1); + } + } + else + { + int r = pthread_barrier_wait (&b2); + if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD) + { + printf ("%s: barrier_wait failed\n", __FUNCTION__); + exit (1); + } + } + + int r = pthread_barrier_wait (&b2); if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD) { - printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__); + printf ("%s: barrier_wait failed\n", __FUNCTION__); exit (1); } - pthread_cleanup_push (cl, NULL); + pthread_cleanup_push (cl_fifo, NULL); - open ("Makefile", O_RDONLY); + open64 (arg ? "Makefile" : fifoname, O_RDONLY); pthread_cleanup_pop (0); @@ -1510,6 +1568,46 @@ tf_pread (void *arg) exit (1); } +static void * +tf_pread64 (void *arg) +{ + if (arg == NULL) + // XXX If somebody can provide a portable test case in which pread() + // blocks we can enable this test to run in both rounds. + abort (); + + tempfd = open64 ("Makefile", O_RDONLY); + if (tempfd == -1) + { + printf ("%s: cannot open64 Makefile\n", __FUNCTION__); + exit (1); + } + + int r = pthread_barrier_wait (&b2); + if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD) + { + printf ("%s: barrier_wait failed\n", __FUNCTION__); + exit (1); + } + + r = pthread_barrier_wait (&b2); + if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD) + { + printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__); + exit (1); + } + + pthread_cleanup_push (cl, NULL); + + char mem[10]; + pread64 (tempfd, mem, sizeof (mem), 0); + + pthread_cleanup_pop (0); + + printf ("%s: pread64 returned\n", __FUNCTION__); + + exit (1); +} static void * tf_pwrite (void *arg) @@ -1554,6 +1652,48 @@ tf_pwrite (void *arg) exit (1); } +static void * +tf_pwrite64 (void *arg) +{ + if (arg == NULL) + // XXX If somebody can provide a portable test case in which pwrite() + // blocks we can enable this test to run in both rounds. + abort (); + + char fname[] = "/tmp/tst-cancel4-fd-XXXXXX"; + tempfd = mkstemp (fname); + if (tempfd == -1) + { + printf ("%s: mkstemp failed\n", __FUNCTION__); + exit (1); + } + unlink (fname); + + int r = pthread_barrier_wait (&b2); + if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD) + { + printf ("%s: barrier_wait failed\n", __FUNCTION__); + exit (1); + } + + r = pthread_barrier_wait (&b2); + if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD) + { + printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__); + exit (1); + } + + pthread_cleanup_push (cl, NULL); + + char mem[10]; + pwrite64 (tempfd, mem, sizeof (mem), 0); + + pthread_cleanup_pop (0); + + printf ("%s: pwrite64 returned\n", __FUNCTION__); + + exit (1); +} static void * tf_fsync (void *arg) @@ -2140,10 +2280,13 @@ static struct ADD_TEST (recv, 2, 0), ADD_TEST (recvfrom, 2, 0), ADD_TEST (recvmsg, 2, 0), - ADD_TEST (open, 2, 1), + ADD_TEST (open, 2, 0), + ADD_TEST (open64, 2, 0), ADD_TEST (close, 2, 1), ADD_TEST (pread, 2, 1), + ADD_TEST (pread64, 2, 1), ADD_TEST (pwrite, 2, 1), + ADD_TEST (pwrite64, 2, 1), ADD_TEST (fsync, 2, 1), ADD_TEST (fdatasync, 2, 1), ADD_TEST (msync, 2, 1), @@ -2185,6 +2328,12 @@ do_test (void) } setsockopt (fds[1], SOL_SOCKET, SO_SNDBUF, &val, sizeof(val)); + if (mktemp (fifoname) == NULL) + { + printf ("%s: cannot generate temp file name\n", __FUNCTION__); + exit (1); + } + int result = 0; size_t cnt; for (cnt = 0; cnt < ntest_tf; ++cnt)