From patchwork Mon Nov 13 16:56:33 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Florian Weimer X-Patchwork-Id: 837481 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=sourceware.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=libc-alpha-return-87030-incoming=patchwork.ozlabs.org@sourceware.org; receiver=) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; secure) header.d=sourceware.org header.i=@sourceware.org header.b="CDCtH02B"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 3ybGy422xnz9s0g for ; Tue, 14 Nov 2017 03:56:43 +1100 (AEDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:date:to:subject:mime-version:content-type :content-transfer-encoding:message-id:from; q=dns; s=default; b= cIvLtQCzSWWhz/7AElqgjJNPlk5nS3oE7dszWR0+Br1qzvDLDdKuyaqXUGlUt1ki 2SK8LcNqlqNocOOYHSEiVJM6/FEJ2YovSp01foIXGF3xVoXctENtP5MiSZWJAUhN 33CzM2Mg2kawy9PLshVAzDtFtnpJtgbQ6RoAHuW1xpA= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:date:to:subject:mime-version:content-type :content-transfer-encoding:message-id:from; s=default; bh=+Q9zS4 JMycz0AuiOM5VEwtQWLao=; b=CDCtH02BpqAe41D5VozxUp4XEpXmN1dO3XUUkp EjZyU6m9K4yH84A9gMlE14clnlIKMwVLhH/riT0zeiAkSp9lVU22RbzbSeuBJP0D oKYC89ntpbo5r7bk612xc776mtTGERYvkFGIAM3asumezoZqI/r+kKIMO9aRZxFJ AU6wM= Received: (qmail 120085 invoked by alias); 13 Nov 2017 16:56:38 -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 120074 invoked by uid 89); 13 Nov 2017 16:56:38 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-25.9 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_LAZY_DOMAIN_SECURITY, RP_MATCHES_RCVD, SPF_HELO_PASS autolearn=ham version=3.3.2 spammy=enhanced, 9213 X-HELO: mx1.redhat.com Date: Mon, 13 Nov 2017 17:56:33 +0100 To: libc-alpha@sourceware.org Subject: [PATCH] support: Add User-Agent: Heirloom mailx 12.5 7/5/10 MIME-Version: 1.0 Message-Id: <20171113165633.A0625406FF981@oldenburg.str.redhat.com> From: fweimer@redhat.com (Florian Weimer) Based on the implementation in resolv/tst-inet_pton.c. 2017-11-13 Florian Weimer * support/next_to_fault.h, support/next_to_fault.c: New files. * support/Makefile (libsupport-routines): Add next_to_fault. * resolv/tst-inet_pton.c (struct next_to_fault) (next_to_fault_allocate, next_to_fault_free): Remove. (run_one_test): Switch to interfaces. diff --git a/resolv/tst-inet_pton.c b/resolv/tst-inet_pton.c index 4bb9f81193..5a06a802b3 100644 --- a/resolv/tst-inet_pton.c +++ b/resolv/tst-inet_pton.c @@ -22,57 +22,10 @@ #include #include #include +#include #include -#include -#include #include -/* Memory region created by next_to_fault_allocate. */ -struct next_to_fault -{ - /* The user data. */ - char *buffer; - size_t length; - - /* The entire allocated region. */ - void *region_start; - size_t region_size; -}; - -/* Allocate a buffer of SIZE bytes just before a page which is mapped - with PROT_NONE (so that overrunning the buffer will cause a - fault). */ -static struct next_to_fault -next_to_fault_allocate (size_t size) -{ - long page_size = sysconf (_SC_PAGE_SIZE); - TEST_VERIFY_EXIT (page_size > 0); - struct next_to_fault result; - result.region_size = roundup (size, page_size) + page_size; - TEST_VERIFY_EXIT (size + page_size > size); - TEST_VERIFY_EXIT (result.region_size > size); - result.region_start - = xmmap (NULL, result.region_size, PROT_READ | PROT_WRITE, - MAP_PRIVATE | MAP_ANONYMOUS, -1); - /* Unmap the page after the allocation. */ - xmprotect (result.region_start + (result.region_size - page_size), - page_size, PROT_NONE); - /* Align the allocation within the region so that it ends just - before the PROT_NONE page. */ - result.buffer = result.region_start + result.region_size - page_size - size; - result.length = size; - return result; -} - -/* Deallocate the memory region allocated by - next_to_fault_allocate. */ -static void -next_to_fault_free (struct next_to_fault *ntf) -{ - xmunmap (ntf->region_start, ntf->region_size); - *ntf = (struct next_to_fault) { NULL, }; -} - struct test_case { /* The input data. */ @@ -139,12 +92,13 @@ run_one_test (const struct test_case *t) { size_t test_len = strlen (t->input); - struct next_to_fault ntf_out4 = next_to_fault_allocate (4); - struct next_to_fault ntf_out6 = next_to_fault_allocate (16); + struct support_next_to_fault ntf_out4 = support_next_to_fault_allocate (4); + struct support_next_to_fault ntf_out6 = support_next_to_fault_allocate (16); /* inet_pton requires NUL termination. */ { - struct next_to_fault ntf_in = next_to_fault_allocate (test_len + 1); + struct support_next_to_fault ntf_in + = support_next_to_fault_allocate (test_len + 1); memcpy (ntf_in.buffer, t->input, test_len + 1); memset (ntf_out4.buffer, 0, 4); check_result ("inet_pton", t, AF_INET, ntf_out4.buffer, @@ -152,12 +106,13 @@ run_one_test (const struct test_case *t) memset (ntf_out6.buffer, 0, 16); check_result ("inet_pton", t, AF_INET6, ntf_out6.buffer, inet_pton (AF_INET6, ntf_in.buffer, ntf_out6.buffer)); - next_to_fault_free (&ntf_in); + support_next_to_fault_free (&ntf_in); } /* __inet_pton_length does not require NUL termination. */ { - struct next_to_fault ntf_in = next_to_fault_allocate (test_len); + struct support_next_to_fault ntf_in + = support_next_to_fault_allocate (test_len); memcpy (ntf_in.buffer, t->input, test_len); memset (ntf_out4.buffer, 0, 4); check_result ("__inet_pton_length", t, AF_INET, ntf_out4.buffer, @@ -167,11 +122,11 @@ run_one_test (const struct test_case *t) check_result ("__inet_pton_length", t, AF_INET6, ntf_out6.buffer, __inet_pton_length (AF_INET6, ntf_in.buffer, ntf_in.length, ntf_out6.buffer)); - next_to_fault_free (&ntf_in); + support_next_to_fault_free (&ntf_in); } - next_to_fault_free (&ntf_out4); - next_to_fault_free (&ntf_out6); + support_next_to_fault_free (&ntf_out4); + support_next_to_fault_free (&ntf_out6); } /* The test cases were manually crafted and the set enhanced with diff --git a/support/Makefile b/support/Makefile index dafb1737a4..f7a878b950 100644 --- a/support/Makefile +++ b/support/Makefile @@ -32,6 +32,7 @@ libsupport-routines = \ check_netent \ delayed_exit \ ignore_stderr \ + next_to_fault \ oom_error \ resolv_test \ set_fortify_handler \ diff --git a/support/next_to_fault.c b/support/next_to_fault.c new file mode 100644 index 0000000000..7c6b077898 --- /dev/null +++ b/support/next_to_fault.c @@ -0,0 +1,52 @@ +/* Memory allocation next to an unmapped page. + Copyright (C) 2017 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 + +struct support_next_to_fault +support_next_to_fault_allocate (size_t size) +{ + long page_size = sysconf (_SC_PAGE_SIZE); + TEST_VERIFY_EXIT (page_size > 0); + struct support_next_to_fault result; + result.region_size = roundup (size, page_size) + page_size; + if (size + page_size <= size || result.region_size <= size) + FAIL_EXIT1 ("support_next_to_fault_allocate (%zu): overflow", size); + result.region_start + = xmmap (NULL, result.region_size, PROT_READ | PROT_WRITE, + MAP_PRIVATE | MAP_ANONYMOUS, -1); + /* Unmap the page after the allocation. */ + xmprotect (result.region_start + (result.region_size - page_size), + page_size, PROT_NONE); + /* Align the allocation within the region so that it ends just + before the PROT_NONE page. */ + result.buffer = result.region_start + result.region_size - page_size - size; + result.length = size; + return result; +} + +void +support_next_to_fault_free (struct support_next_to_fault *ntf) +{ + xmunmap (ntf->region_start, ntf->region_size); + *ntf = (struct support_next_to_fault) { NULL, }; +} diff --git a/support/next_to_fault.h b/support/next_to_fault.h new file mode 100644 index 0000000000..dd71c28ac0 --- /dev/null +++ b/support/next_to_fault.h @@ -0,0 +1,48 @@ +/* Memory allocation next to an unmapped page. + Copyright (C) 2017 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 + . */ + +#ifndef SUPPORT_NEXT_TO_FAULT_H +#define SUPPORT_NEXT_TO_FAULT_H + +#include +#include + +__BEGIN_DECLS + +/* The memory region created by next_to_fault_allocate. */ +struct support_next_to_fault +{ + /* The user data. */ + char *buffer; + size_t length; + + /* The entire allocated region. */ + void *region_start; + size_t region_size; +}; + +/* Allocate a buffer of SIZE bytes just before a page which is mapped + with PROT_NONE (so that overrunning the buffer will cause a + fault). */ +struct support_next_to_fault support_next_to_fault_allocate (size_t size); + +/* Deallocate the memory region allocated by + next_to_fault_allocate. */ +void support_next_to_fault_free (struct support_next_to_fault *); + +#endif /* SUPPORT_NEXT_TO_FAULT_H */