From patchwork Mon Jul 18 16:46:43 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella Netto X-Patchwork-Id: 56131 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id C9C77385276B for ; Mon, 18 Jul 2022 16:47:32 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org C9C77385276B DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1658162852; bh=cUJVrNU/jCtmJFHwKvfGm/4Fumr09k9lZCQqqv8kS9k=; h=To:Subject:Date:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:Cc:From; b=F1BcXIXlVP9QMQgdS7KA6rK50kC9XK7NWT4cIa6F4SNRFOMNvbYKWfwwxzZeQSp8s GaDf3wDmZ4tGwMdBGocszmi8+ipXTx0t7YvKp8C2UUpMURS5qASYrbVH946fkDX+MU BbO5zEUI5QqAeA32ydo2P8vFv1ouSocxbV0i8594= X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from mail-oa1-x36.google.com (mail-oa1-x36.google.com [IPv6:2001:4860:4864:20::36]) by sourceware.org (Postfix) with ESMTPS id 8BC6F3858438 for ; Mon, 18 Jul 2022 16:47:09 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 8BC6F3858438 Received: by mail-oa1-x36.google.com with SMTP id 586e51a60fabf-10cf9f5b500so24085956fac.2 for ; Mon, 18 Jul 2022 09:47:09 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=cUJVrNU/jCtmJFHwKvfGm/4Fumr09k9lZCQqqv8kS9k=; b=icElR0qCoALq6Hhf+hS6Kf0pVDQXUI2k7Lme2kAaq7rSrwizHoPzc23ElXoZIXd0lb 9Hq6t/1j+IlxMA0Y1XOjEVkc793f4e/JJFBUQqjMCIBUvIry+1tcwU/c8odWzw23SAX3 G0QEWzYQMq3dEbuTtFdHo3jXywLBTIdVpSRWkiCUx+bEcwb1Lwx3SMJAZc7jO9Idzxft Zwr6wDFdsH+0nrRcqt8cX8yRSsGw70/wLMn1C7ScRM+yNFPKwjVKnhB4dnogn8Baaone 8qrSr1fjVPxbV7pqVNbsvj4cloodQ5moz0kZoJZ0M6QGOpWF7oaiIpsh5kTMCC/tHOWA 8pMg== X-Gm-Message-State: AJIora/1krgFqAPeE65HBp2xj+iZr8TWUB59WeBKUvUOnpamr2YsiA4e ZqzOQbpG35MQuoU9fmkBAbqoMdRZ1oTuCt8g X-Google-Smtp-Source: AGRyM1ufe+AGKjmElMS+IuoN2Lcjeo1ILNLzgdVT3OemM8W8XQm+q81PWpjpjikMkZUrzeAlfbEsGA== X-Received: by 2002:a05:6808:1992:b0:33a:7196:986a with SMTP id bj18-20020a056808199200b0033a7196986amr3390127oib.297.1658162828631; Mon, 18 Jul 2022 09:47:08 -0700 (PDT) Received: from mandiga.. ([2804:431:c7ca:19c3:efaf:4c86:eb49:9c00]) by smtp.gmail.com with ESMTPSA id w7-20020a056870a2c700b000f342d078fasm6446394oak.52.2022.07.18.09.46.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 Jul 2022 09:47:08 -0700 (PDT) To: libc-alpha@sourceware.org, Carlos O'Donell Subject: [PATCH v3] debug: test for more required cacellation points (BZ# 29274) Date: Mon, 18 Jul 2022 13:46:43 -0300 Message-Id: <20220718164643.101781-1-adhemerval.zanella@linaro.org> X-Mailer: git-send-email 2.34.1 MIME-Version: 1.0 X-Spam-Status: No, score=-12.9 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Adhemerval Zanella via Libc-alpha From: Adhemerval Zanella Netto Reply-To: Adhemerval Zanella Cc: Andreas Schwab Errors-To: libc-alpha-bounces+patchwork=sourceware.org@sourceware.org Sender: "Libc-alpha" Generalize the test for cancellation point in __read_chk to also test the other fortified functions with required cancellation points. Since there is not easy way to force some syscalls to block (for instance pread) the test tests two modes: cancellation on blocked syscalls and early cancellation on pending request. Checked on aarch64-linux-gnu. Co-authored-by: Andreas Schwab --- debug/Makefile | 6 +- debug/tst-chk-cancel.c | 269 ++++++++++++++++++++++++++++++++++++ debug/tst-read-chk-cancel.c | 50 ------- 3 files changed, 272 insertions(+), 53 deletions(-) create mode 100644 debug/tst-chk-cancel.c delete mode 100644 debug/tst-read-chk-cancel.c diff --git a/debug/Makefile b/debug/Makefile index 456b349c4d..99cdf3221b 100644 --- a/debug/Makefile +++ b/debug/Makefile @@ -110,7 +110,7 @@ CPPFLAGS-tst-longjmp_chk2.c += -D_FORTIFY_SOURCE=1 CFLAGS-tst-longjmp_chk3.c += -fexceptions -fasynchronous-unwind-tables CPPFLAGS-tst-longjmp_chk3.c += -D_FORTIFY_SOURCE=1 CPPFLAGS-tst-realpath-chk.c += -D_FORTIFY_SOURCE=2 -CPPFLAGS-tst-read-chk-cancel.c += -D_FORTIFY_SOURCE=2 +CPPFLAGS-tst-chk-cancel.c += -D_FORTIFY_SOURCE=2 # _FORTIFY_SOURCE tests. # Auto-generate tests for _FORTIFY_SOURCE for different levels, compilers and @@ -206,7 +206,7 @@ tests += tst-ssp-1 endif ifeq ($(have-thread-library), yes) -tests += tst-read-chk-cancel +tests += tst-chk-cancel endif ifeq (,$(CXX)) @@ -248,4 +248,4 @@ $(objpfx)xtrace: xtrace.sh -e 's|@REPORT_BUGS_TO@|$(REPORT_BUGS_TO)|' $^ > $@.new \ && rm -f $@ && mv $@.new $@ && chmod +x $@ -$(objpfx)tst-read-chk-cancel: $(shared-thread-library) +$(objpfx)tst-chk-cancel: $(shared-thread-library) diff --git a/debug/tst-chk-cancel.c b/debug/tst-chk-cancel.c new file mode 100644 index 0000000000..f9ebc4a3f4 --- /dev/null +++ b/debug/tst-chk-cancel.c @@ -0,0 +1,269 @@ +/* Test for required cancellation points in fortified functions (BZ #29274) + Copyright (C) 2022 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 + +/* Cleanup handling test. */ +static int cl_called; + +static void +cl (void *arg) +{ + ++cl_called; +} + +static int fds[2]; +static pthread_barrier_t barrier; + +static void * +tf_read (void *n) +{ + pthread_cleanup_push (cl, NULL); + + xpthread_barrier_wait (&barrier); + + /* This call should be forwarded to __read_chk because the buffer size + is known, but the read length is non-constant. */ + char c; + if (read (fds[0], &c, (uintptr_t) n) != 1) + return (void *) -1L; + + pthread_cleanup_pop (0); + return 0; +} + +static void * +tf_pread (void *n) +{ + pthread_cleanup_push (cl, NULL); + + xpthread_barrier_wait (&barrier); + + /* This call should be forwarded to __pread_chk because the buffer size + is known, but the read length is non-constant. */ + char c; + if (pread (fds[0], &c, (uintptr_t) n, 0) != 1) + return (void *) -1L; + + pthread_cleanup_pop (0); + return 0; +} + +static void * +tf_pread64 (void *n) +{ + pthread_cleanup_push (cl, NULL); + + xpthread_barrier_wait (&barrier); + + /* This call should be forwarded to __pread64_chk because the buffer size + is known, but the read length is non-constant. */ + char c; + if (pread64 (fds[0], &c, (uintptr_t) n, 0) != 1) + return (void *) -1L; + + pthread_cleanup_pop (0); + return 0; +} + +static void * +tf_poll (void *n) +{ + pthread_cleanup_push (cl, NULL); + + xpthread_barrier_wait (&barrier); + + /* This call should be forwarded to __poll_chk because the pollfd size + is known, but the number of entries is non-constant. */ + struct pollfd pfd = { fds[0], POLLIN, 0 }; + if (poll (&pfd, (uintptr_t) n, -1) != 1) + return (void *) -1L; + + pthread_cleanup_pop (0); + return 0; +} + +static void * +tf_ppoll (void *n) +{ + pthread_cleanup_push (cl, NULL); + + xpthread_barrier_wait (&barrier); + + /* This call should be forwarded to __ppoll_chk because the pollfd size + is known, but the number of entries is non-constant. */ + struct pollfd pfd = { fds[0], POLLIN, 0 }; + if (ppoll (&pfd, (uintptr_t) n, 0, 0) != 1) + return (void *) -1L; + + pthread_cleanup_pop (0); + return 0; +} + +static void * +tf_recv (void *n) +{ + pthread_cleanup_push (cl, NULL); + + xpthread_barrier_wait (&barrier); + + /* This call should be forwarded to __ppoll_chk because the pollfd size + is known, but the number of entries is non-constant. */ + char c; + if (recv (fds[0], &c, (uintptr_t) n, 0) != 1) + return (void *) -1L; + + pthread_cleanup_pop (0); + return 0; +} + +static void * +tf_recvfrom (void *n) +{ + pthread_cleanup_push (cl, NULL); + + xpthread_barrier_wait (&barrier); + + /* This call should be forwarded to __ppoll_chk because the pollfd size + is known, but the number of entries is non-constant. */ + char c; + if (recvfrom (fds[0], &c, (uintptr_t) n, 0, NULL, NULL) != 1) + return (void *) -1L; + + pthread_cleanup_pop (0); + return 0; +} + +static struct cancel_tests +{ + const char *name; + void *(*tf) (void *); + bool only_early; +#define ADD_TEST(name, early) { #name, tf_##name, early } +} tests[] = +{ + ADD_TEST (poll, false), + ADD_TEST (ppoll, false), + ADD_TEST (pread, true), + ADD_TEST (pread64, true), + ADD_TEST (read, false), + ADD_TEST (recv, false), + ADD_TEST (recvfrom, false), +}; + +/* Set the send buffer of socket S to 1 byte so any send operation + done with WRITE_BUFFER_SIZE bytes will force syscall blocking. */ +static void +set_socket_buffer (int s) +{ + int val = 1; + socklen_t len = sizeof (val); + + TEST_VERIFY_EXIT (setsockopt (s, SOL_SOCKET, SO_SNDBUF, &val, + sizeof (val)) == 0); + TEST_VERIFY_EXIT (getsockopt (s, SOL_SOCKET, SO_SNDBUF, &val, &len) == 0); + printf ("%s: got size %d\n", __func__, val); +} + +static int +do_test (void) +{ + xpthread_barrier_init (&barrier, 0, 2); + + if (socketpair (AF_UNIX, SOCK_STREAM, 0, fds) != 0) + FAIL_EXIT1 ("socketpair: %m"); + set_socket_buffer (fds[1]); + + /* This is the !only_early test. It is a late cancel test that has a sleep + in the main thread in an attempt to allow the child thread to reach and + block on the syscall. The cancellation should happen with high + probability when the child thread blocked on the syscall, and that is + the intent of the test (syscall cancellation registration complete). */ + for (int i = 0; i < array_length (tests); i++) + { + if (tests[i].only_early) + continue; + + xpthread_barrier_init (&barrier, NULL, 2); + /* Reset the counter for the cleanup handler. */ + cl_called = 0; + + pthread_t thr = xpthread_create (0, tests[i].tf, (void *) 1L); + /* After this wait the threads cancellation handler is installed. */ + xpthread_barrier_wait (&barrier); + + struct timespec ts = { .tv_sec = 0, .tv_nsec = 100000000 }; + TEMP_FAILURE_RETRY (clock_nanosleep (CLOCK_REALTIME, 0, &ts, &ts)); + + xpthread_cancel (thr); + + void *status = xpthread_join (thr); + TEST_VERIFY (status == PTHREAD_CANCELED); + TEST_COMPARE (cl_called, 1); + + printf ("in-time cancel test of '%s' successful\n", tests[i].name); + } + + /* This test is the early cancel version of the first test, and the intent + is to have the cancellation happen at one of two regions: + + 1. Before the cancellable syscall registers cancellation. + 2. After the cancellable syscall registers cancellation. + + This test will exercise if syscall cancellation registration is an atomic + operation or not since the transition from the regions is designed to be + atomic. + + We can not control when the cancellation happens, but it will happen in + one of the two regions. The first test (the !only_early version) + attempts to test the second region, while this test attempts to test the + first regiont and the transition with some probability. */ + for (int i = 0; i < array_length (tests); i++) + { + xpthread_barrier_init (&barrier, NULL, 2); + /* Reset the counter for the cleanup handler. */ + cl_called = 0; + + /* After this wait the cancellation handler is in place. */ + pthread_t thr = xpthread_create (0, tests[i].tf, NULL); + + xpthread_cancel (thr); + xpthread_barrier_wait (&barrier); + + void *status = xpthread_join (thr); + TEST_VERIFY (status == PTHREAD_CANCELED); + TEST_COMPARE (cl_called, 1); + + printf ("early cancel test of '%s' successful\n", tests[i].name); + } + + xpthread_barrier_destroy (&barrier); + + return 0; +} + +#include diff --git a/debug/tst-read-chk-cancel.c b/debug/tst-read-chk-cancel.c deleted file mode 100644 index 7e06afb596..0000000000 --- a/debug/tst-read-chk-cancel.c +++ /dev/null @@ -1,50 +0,0 @@ -/* Test that __read_chk is a cancellation point (BZ #29274) - Copyright (C) 2022 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 - -static int pipe_fds[2]; -static pthread_barrier_t barrier; - -static void * -read_thread (void *n) -{ - xpthread_barrier_wait (&barrier); - char c; - /* This call should be forwarded to __read_chk because the buffer size - is known, but the read length is non-constant. */ - if (read (pipe_fds[0], &c, (uintptr_t) n) != 1) - return (void *) -1L; - return 0; -} - -static int -do_test (void) -{ - xpthread_barrier_init (&barrier, 0, 2); - xpipe (pipe_fds); - pthread_t thr = xpthread_create (0, read_thread, (void *) 1L); - xpthread_barrier_wait (&barrier); - xpthread_cancel (thr); - xpthread_join (thr); - return 0; -} - -#include