From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-10.2 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3B78BC282C0 for ; Wed, 23 Jan 2019 11:04:26 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id E9EAC21019 for ; Wed, 23 Jan 2019 11:04:25 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="DkyomhsD" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727623AbfAWLES (ORCPT ); Wed, 23 Jan 2019 06:04:18 -0500 Received: from mail-pf1-f195.google.com ([209.85.210.195]:34780 "EHLO mail-pf1-f195.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727538AbfAWLEP (ORCPT ); Wed, 23 Jan 2019 06:04:15 -0500 Received: by mail-pf1-f195.google.com with SMTP id h3so1033635pfg.1 for ; Wed, 23 Jan 2019 03:04:15 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=WWbvkyDFrEwD8Gl8RHFeeU54ZHjYlP1PsRcb35sltHw=; b=DkyomhsDwUdIfnaDB/NeiZUczL0kVk8bi1CWvJwOo+O8Y3gwR8sdwlvtjgUZMWvt7A Q4e8Rnt7B3G04qrG0W5Z37/0zhU/H5BC3W/9B9kMPvBf0G47QvaIoCZgUn3sUBs6FFYX lBdX04C6nh3Qfmf12yYQiGNupJGr/usqexPmw= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=WWbvkyDFrEwD8Gl8RHFeeU54ZHjYlP1PsRcb35sltHw=; b=gHIZPzh2zrP8Vd8Ge1Oe88Fm+Epv9rsjThu7+FTRsBYVEc60XO3fBAegM7Gm5SL/rJ SF5hnSM7yyC68GPyiwvTCUaPkAJKUwUfFUGfGgs/GrQsxSI1HsdNJSBVRoC/IQ7AjORH kfVG2P7kHR6QmN4TAwmH4HnEQCqE8Al8WnL+67PROcoAiN9oOjPPziyYUh3zNYE4kO5x /AjbD/Taxb5fvKjOInTnVkh9BfxBPyzAZXo/GQ0I0WD50K8t3Nown1ewnar9lpuUcRMm EB65nX/oJlRDHUQ9kCMvspDOt4m1Nl07v1FkAm+yIlEGv88y5KgFid4x34cr70S4hl7z /ufA== X-Gm-Message-State: AJcUukck9l9H5r7PAc/gOuL+zbKSiWvF7v6Fd6j6A9zOWR3ZrDs2+bIU QTXoZfNV1ekmsZuLKi2JCO90xA== X-Google-Smtp-Source: ALg8bN6pJQ3eCmEXxAgRqj/tyajOwVnmQ4WNYNAOVXjqhOShRLFHBh9ESM5QcYvZHttlSHXjQfRQag== X-Received: by 2002:a65:50c1:: with SMTP id s1mr1531952pgp.350.1548241454431; Wed, 23 Jan 2019 03:04:14 -0800 (PST) Received: from www.outflux.net (173-164-112-133-Oregon.hfc.comcastbusiness.net. [173.164.112.133]) by smtp.gmail.com with ESMTPSA id a4sm20257473pgv.70.2019.01.23.03.04.12 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Wed, 23 Jan 2019 03:04:12 -0800 (PST) From: Kees Cook To: linux-kernel@vger.kernel.org Cc: Kees Cook , Ard Biesheuvel , Laura Abbott , Alexander Popov , xen-devel@lists.xenproject.org, dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, intel-wired-lan@lists.osuosl.org, netdev@vger.kernel.org, linux-usb@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-mm@kvack.org, dev@openvswitch.org, linux-kbuild@vger.kernel.org, linux-security-module@vger.kernel.org, kernel-hardening@lists.openwall.com Subject: [PATCH 3/3] lib: Introduce test_stackinit module Date: Wed, 23 Jan 2019 03:03:49 -0800 Message-Id: <20190123110349.35882-4-keescook@chromium.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190123110349.35882-1-keescook@chromium.org> References: <20190123110349.35882-1-keescook@chromium.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Adds test for stack initialization coverage. We have several build options that control the level of stack variable initialization. This test lets us visualize which options cover which cases, and provide tests for options that are currently not available (padding initialization). All options pass the explicit initialization cases and the partial initializers (even with padding): test_stackinit: u8_zero ok test_stackinit: u16_zero ok test_stackinit: u32_zero ok test_stackinit: u64_zero ok test_stackinit: char_array_zero ok test_stackinit: small_hole_zero ok test_stackinit: big_hole_zero ok test_stackinit: packed_zero ok test_stackinit: small_hole_dynamic_partial ok test_stackinit: big_hole_dynamic_partial ok test_stackinit: packed_static_partial ok test_stackinit: small_hole_static_partial ok test_stackinit: big_hole_static_partial ok The results of the other tests (which contain no explicit initialization), change based on the build's configured compiler instrumentation. No options: test_stackinit: small_hole_static_all FAIL (uninit bytes: 3) test_stackinit: big_hole_static_all FAIL (uninit bytes: 61) test_stackinit: small_hole_dynamic_all FAIL (uninit bytes: 3) test_stackinit: big_hole_dynamic_all FAIL (uninit bytes: 61) test_stackinit: small_hole_runtime_partial FAIL (uninit bytes: 23) test_stackinit: big_hole_runtime_partial FAIL (uninit bytes: 127) test_stackinit: small_hole_runtime_all FAIL (uninit bytes: 3) test_stackinit: big_hole_runtime_all FAIL (uninit bytes: 61) test_stackinit: u8 FAIL (uninit bytes: 1) test_stackinit: u16 FAIL (uninit bytes: 2) test_stackinit: u32 FAIL (uninit bytes: 4) test_stackinit: u64 FAIL (uninit bytes: 8) test_stackinit: char_array FAIL (uninit bytes: 16) test_stackinit: small_hole FAIL (uninit bytes: 24) test_stackinit: big_hole FAIL (uninit bytes: 128) test_stackinit: user FAIL (uninit bytes: 32) test_stackinit: failures: 16 CONFIG_GCC_PLUGIN_STRUCTLEAK=y This only tries to initialize structs with __user markings: test_stackinit: small_hole_static_all FAIL (uninit bytes: 3) test_stackinit: big_hole_static_all FAIL (uninit bytes: 61) test_stackinit: small_hole_dynamic_all FAIL (uninit bytes: 3) test_stackinit: big_hole_dynamic_all FAIL (uninit bytes: 61) test_stackinit: small_hole_runtime_partial FAIL (uninit bytes: 23) test_stackinit: big_hole_runtime_partial FAIL (uninit bytes: 127) test_stackinit: small_hole_runtime_all FAIL (uninit bytes: 3) test_stackinit: big_hole_runtime_all FAIL (uninit bytes: 61) test_stackinit: u8 FAIL (uninit bytes: 1) test_stackinit: u16 FAIL (uninit bytes: 2) test_stackinit: u32 FAIL (uninit bytes: 4) test_stackinit: u64 FAIL (uninit bytes: 8) test_stackinit: char_array FAIL (uninit bytes: 16) test_stackinit: small_hole FAIL (uninit bytes: 24) test_stackinit: big_hole FAIL (uninit bytes: 128) test_stackinit: user ok test_stackinit: failures: 15 CONFIG_GCC_PLUGIN_STRUCTLEAK=y CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF_ALL=y This initializes all structures passed by reference (scalars and strings remain uninitialized, but padding is wiped): test_stackinit: small_hole_static_all ok test_stackinit: big_hole_static_all ok test_stackinit: small_hole_dynamic_all ok test_stackinit: big_hole_dynamic_all ok test_stackinit: small_hole_runtime_partial ok test_stackinit: big_hole_runtime_partial ok test_stackinit: small_hole_runtime_all ok test_stackinit: big_hole_runtime_all ok test_stackinit: u8 FAIL (uninit bytes: 1) test_stackinit: u16 FAIL (uninit bytes: 2) test_stackinit: u32 FAIL (uninit bytes: 4) test_stackinit: u64 FAIL (uninit bytes: 8) test_stackinit: char_array FAIL (uninit bytes: 16) test_stackinit: small_hole ok test_stackinit: big_hole ok test_stackinit: user ok test_stackinit: failures: 5 CONFIG_GCC_PLUGIN_STACKINIT=y This initializes all variables, but has no special padding handling: test_stackinit: small_hole_static_all FAIL (uninit bytes: 3) test_stackinit: big_hole_static_all FAIL (uninit bytes: 61) test_stackinit: small_hole_dynamic_all FAIL (uninit bytes: 3) test_stackinit: big_hole_dynamic_all FAIL (uninit bytes: 61) test_stackinit: small_hole_runtime_partial ok test_stackinit: big_hole_runtime_partial ok test_stackinit: small_hole_runtime_all ok test_stackinit: big_hole_runtime_all ok test_stackinit: u8 ok test_stackinit: u16 ok test_stackinit: u32 ok test_stackinit: u64 ok test_stackinit: char_array ok test_stackinit: small_hole ok test_stackinit: big_hole ok test_stackinit: user ok test_stackinit: failures: 4 Signed-off-by: Kees Cook --- lib/Kconfig.debug | 9 ++ lib/Makefile | 1 + lib/test_stackinit.c | 327 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 337 insertions(+) create mode 100644 lib/test_stackinit.c diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index d4df5b24d75e..09788afcccc9 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -2001,6 +2001,15 @@ config TEST_OBJAGG If unsure, say N. +config TEST_STACKINIT + tristate "Test level of stack variable initialization" + help + Test if the kernel is zero-initializing stack variables + from CONFIG_GCC_PLUGIN_STACKINIT, CONFIG_GCC_PLUGIN_STRUCTLEAK, + and/or GCC_PLUGIN_STRUCTLEAK_BYREF_ALL. + + If unsure, say N. + endif # RUNTIME_TESTING_MENU config MEMTEST diff --git a/lib/Makefile b/lib/Makefile index e1b59da71418..c81a66d4d00d 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -76,6 +76,7 @@ obj-$(CONFIG_TEST_KMOD) += test_kmod.o obj-$(CONFIG_TEST_DEBUG_VIRTUAL) += test_debug_virtual.o obj-$(CONFIG_TEST_MEMCAT_P) += test_memcat_p.o obj-$(CONFIG_TEST_OBJAGG) += test_objagg.o +obj-$(CONFIG_TEST_STACKINIT) += test_stackinit.o ifeq ($(CONFIG_DEBUG_KOBJECT),y) CFLAGS_kobject.o += -DDEBUG diff --git a/lib/test_stackinit.c b/lib/test_stackinit.c new file mode 100644 index 000000000000..e2ff56a1002a --- /dev/null +++ b/lib/test_stackinit.c @@ -0,0 +1,327 @@ +// SPDX-Licenses: GPLv2 +/* + * Test cases for -finit-local-vars and CONFIG_GCC_PLUGIN_STACKINIT. + */ +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include +#include +#include + +/* Exfiltration buffer. */ +#define MAX_VAR_SIZE 128 +static char check_buf[MAX_VAR_SIZE]; + +/* Character array to trigger stack protector in all functions. */ +#define VAR_BUFFER 32 + +/* Volatile mask to convince compiler to copy memory with 0xff. */ +static volatile u8 forced_mask = 0xff; + +/* Location and size tracking to validate fill and test are colocated. */ +static void *fill_start, *target_start; +static size_t fill_size, target_size; + +static bool range_contains(char *haystack_start, size_t haystack_size, + char *needle_start, size_t needle_size) +{ + if (needle_start >= haystack_start && + needle_start + needle_size <= haystack_start + haystack_size) + return true; + return false; +} + +#define DO_NOTHING_TYPE_SCALAR(var_type) var_type +#define DO_NOTHING_TYPE_STRING(var_type) void +#define DO_NOTHING_TYPE_STRUCT(var_type) void + +#define DO_NOTHING_RETURN_SCALAR(ptr) *(ptr) +#define DO_NOTHING_RETURN_STRING(ptr) /**/ +#define DO_NOTHING_RETURN_STRUCT(ptr) /**/ + +#define DO_NOTHING_CALL_SCALAR(var, name) \ + (var) = do_nothing_ ## name(&(var)) +#define DO_NOTHING_CALL_STRING(var, name) \ + do_nothing_ ## name(var) +#define DO_NOTHING_CALL_STRUCT(var, name) \ + do_nothing_ ## name(&(var)) + +#define FETCH_ARG_SCALAR(var) &var +#define FETCH_ARG_STRING(var) var +#define FETCH_ARG_STRUCT(var) &var + +#define FILL_SIZE_SCALAR 1 +#define FILL_SIZE_STRING 16 +#define FILL_SIZE_STRUCT 1 + +#define INIT_CLONE_SCALAR /**/ +#define INIT_CLONE_STRING [FILL_SIZE_STRING] +#define INIT_CLONE_STRUCT /**/ + +#define INIT_SCALAR_NONE /**/ +#define INIT_SCALAR_ZERO = 0 + +#define INIT_STRING_NONE [FILL_SIZE_STRING] /**/ +#define INIT_STRING_ZERO [FILL_SIZE_STRING] = { } + +#define INIT_STRUCT_NONE /**/ +#define INIT_STRUCT_ZERO = { } +#define INIT_STRUCT_STATIC_PARTIAL = { .two = 0, } +#define INIT_STRUCT_STATIC_ALL = { .one = arg->one, \ + .two = arg->two, \ + .three = arg->three, \ + .four = arg->four, \ + } +#define INIT_STRUCT_DYNAMIC_PARTIAL = { .two = arg->two, } +#define INIT_STRUCT_DYNAMIC_ALL = { .one = arg->one, \ + .two = arg->two, \ + .three = arg->three, \ + .four = arg->four, \ + } +#define INIT_STRUCT_RUNTIME_PARTIAL ; \ + var.two = 0 +#define INIT_STRUCT_RUNTIME_ALL ; \ + var.one = 0; \ + var.two = 0; \ + var.three = 0; \ + memset(&var.four, 0, \ + sizeof(var.four)) + +/* + * @name: unique string name for the test + * @var_type: type to be tested for zeroing initialization + * @which: is this a SCALAR or a STRUCT type? + * @init_level: what kind of initialization is performed + */ +#define DEFINE_TEST(name, var_type, which, init_level) \ +static noinline int fill_ ## name(unsigned long sp) \ +{ \ + char buf[VAR_BUFFER + \ + sizeof(var_type) * FILL_SIZE_ ## which * 4]; \ + \ + fill_start = buf; \ + fill_size = sizeof(buf); \ + /* Fill variable with 0xFF. */ \ + memset(fill_start, (char)((sp && 0xff) | forced_mask), \ + fill_size); \ + \ + return (int)buf[0] | (int)buf[sizeof(buf)-1]; \ +} \ +/* no-op to force compiler into ignoring "uninitialized" vars */\ +static noinline DO_NOTHING_TYPE_ ## which(var_type) \ +do_nothing_ ## name(var_type *ptr) \ +{ \ + /* Will always be true, but compiler doesn't know. */ \ + if ((unsigned long)ptr > 0x2) \ + return DO_NOTHING_RETURN_ ## which(ptr); \ + else \ + return DO_NOTHING_RETURN_ ## which(ptr + 1); \ +} \ +static noinline int fetch_ ## name(unsigned long sp, \ + var_type *arg) \ +{ \ + char buf[VAR_BUFFER]; \ + var_type var INIT_ ## which ## _ ## init_level; \ + \ + target_start = &var; \ + target_size = sizeof(var); \ + /* \ + * Keep this buffer around to make sure we've got a \ + * stack frame of SOME kind... \ + */ \ + memset(buf, (char)(sp && 0xff), sizeof(buf)); \ + \ + /* Silence "never initialized" warnings. */ \ + DO_NOTHING_CALL_ ## which(var, name); \ + \ + /* Exfiltrate "var" or field of "var". */ \ + memcpy(check_buf, target_start, target_size); \ + \ + return (int)buf[0] | (int)buf[sizeof(buf) - 1]; \ +} \ +/* Returns 0 on success, 1 on failure. */ \ +static noinline int test_ ## name (void) \ +{ \ + var_type zero INIT_CLONE_ ## which; \ + int ignored; \ + u8 sum = 0, i; \ + \ + /* Notice when a new test is larger than expected. */ \ + BUILD_BUG_ON(sizeof(zero) > MAX_VAR_SIZE); \ + /* Clear entire check buffer for later bit tests. */ \ + memset(check_buf, 0x00, sizeof(check_buf)); \ + \ + /* Fill clone type with zero for per-field init. */ \ + memset(&zero, 0x00, sizeof(zero)); \ + /* Fill stack with 0xFF. */ \ + ignored = fill_ ##name((unsigned long)&ignored); \ + /* Extract stack-defined variable contents. */ \ + ignored = fetch_ ##name((unsigned long)&ignored, \ + FETCH_ARG_ ## which(zero)); \ + \ + /* Validate that compiler lined up fill and target. */ \ + if (!range_contains(fill_start, fill_size, \ + target_start, target_size)) { \ + pr_err(#name ": stack fill missed target!?\n"); \ + pr_err(#name ": fill %zu wide\n", fill_size); \ + pr_err(#name ": target offset by %ld\n", \ + (ssize_t)(uintptr_t)fill_start - \ + (ssize_t)(uintptr_t)target_start); \ + return 1; \ + } \ + \ + /* Look for any set bits in the check region. */ \ + for (i = 0; i < sizeof(check_buf); i++) \ + sum += (check_buf[i] != 0); \ + \ + if (sum == 0) \ + pr_info(#name " ok\n"); \ + else \ + pr_warn(#name " FAIL (uninit bytes: %d)\n", \ + sum); \ + \ + return (sum != 0); \ +} + +/* Structure with no padding. */ +struct test_packed { + unsigned long one; + unsigned long two; + unsigned long three; + unsigned long four; +}; + +/* Simple structure with padding likely to be covered by compiler. */ +struct test_small_hole { + size_t one; + char two; + /* 3 byte padding hole here. */ + int three; + unsigned long four; +}; + +/* Try to trigger unhandled padding in a structure. */ +struct test_aligned { + u32 internal1; + u64 internal2; +} __aligned(64); + +struct test_big_hole { + u8 one; + u8 two; + u8 three; + /* 61 byte padding hole here. */ + struct test_aligned four; +} __aligned(64); + +/* Test if STRUCTLEAK is clearing structs with __user fields. */ +struct test_user { + u8 one; + char __user *two; + unsigned long three; + unsigned long four; +}; + +/* These should be fully initialized all the time! */ +DEFINE_TEST(u8_zero, u8, SCALAR, ZERO); +DEFINE_TEST(u16_zero, u16, SCALAR, ZERO); +DEFINE_TEST(u32_zero, u32, SCALAR, ZERO); +DEFINE_TEST(u64_zero, u64, SCALAR, ZERO); +DEFINE_TEST(char_array_zero, unsigned char, STRING, ZERO); + +DEFINE_TEST(packed_zero, struct test_packed, STRUCT, ZERO); +DEFINE_TEST(small_hole_zero, struct test_small_hole, STRUCT, ZERO); +DEFINE_TEST(big_hole_zero, struct test_big_hole, STRUCT, ZERO); + +/* Static initialization: padding may be left uninitialized. */ +DEFINE_TEST(packed_static_partial, struct test_packed, STRUCT, STATIC_PARTIAL); +DEFINE_TEST(small_hole_static_partial, struct test_small_hole, STRUCT, STATIC_PARTIAL); +DEFINE_TEST(big_hole_static_partial, struct test_big_hole, STRUCT, STATIC_PARTIAL); + +DEFINE_TEST(small_hole_static_all, struct test_small_hole, STRUCT, STATIC_ALL); +DEFINE_TEST(big_hole_static_all, struct test_big_hole, STRUCT, STATIC_ALL); + +/* Dynamic initialization: padding may be left uninitialized. */ +DEFINE_TEST(small_hole_dynamic_partial, struct test_small_hole, STRUCT, DYNAMIC_PARTIAL); +DEFINE_TEST(big_hole_dynamic_partial, struct test_big_hole, STRUCT, DYNAMIC_PARTIAL); + +DEFINE_TEST(small_hole_dynamic_all, struct test_small_hole, STRUCT, DYNAMIC_ALL); +DEFINE_TEST(big_hole_dynamic_all, struct test_big_hole, STRUCT, DYNAMIC_ALL); + +/* Runtime initialization: padding may be left uninitialized. */ +DEFINE_TEST(small_hole_runtime_partial, struct test_small_hole, STRUCT, RUNTIME_PARTIAL); +DEFINE_TEST(big_hole_runtime_partial, struct test_big_hole, STRUCT, RUNTIME_PARTIAL); + +DEFINE_TEST(small_hole_runtime_all, struct test_small_hole, STRUCT, RUNTIME_ALL); +DEFINE_TEST(big_hole_runtime_all, struct test_big_hole, STRUCT, RUNTIME_ALL); + +/* No initialization without compiler instrumentation. */ +DEFINE_TEST(u8, u8, SCALAR, NONE); +DEFINE_TEST(u16, u16, SCALAR, NONE); +DEFINE_TEST(u32, u32, SCALAR, NONE); +DEFINE_TEST(u64, u64, SCALAR, NONE); +DEFINE_TEST(char_array, unsigned char, STRING, NONE); +DEFINE_TEST(small_hole, struct test_small_hole, STRUCT, NONE); +DEFINE_TEST(big_hole, struct test_big_hole, STRUCT, NONE); +DEFINE_TEST(user, struct test_user, STRUCT, NONE); + +static int __init test_stackinit_init(void) +{ + unsigned int failures = 0; + + /* These are explicitly initialized and should always pass. */ + failures += test_u8_zero(); + failures += test_u16_zero(); + failures += test_u32_zero(); + failures += test_u64_zero(); + failures += test_char_array_zero(); + failures += test_small_hole_zero(); + failures += test_big_hole_zero(); + failures += test_packed_zero(); + + /* Padding here appears to be accidentally always initialized. */ + failures += test_small_hole_dynamic_partial(); + failures += test_big_hole_dynamic_partial(); + failures += test_packed_static_partial(); + + /* Padding initialization depends on compiler behaviors. */ + failures += test_small_hole_static_partial(); + failures += test_big_hole_static_partial(); + failures += test_small_hole_static_all(); + failures += test_big_hole_static_all(); + failures += test_small_hole_dynamic_all(); + failures += test_big_hole_dynamic_all(); + failures += test_small_hole_runtime_partial(); + failures += test_big_hole_runtime_partial(); + failures += test_small_hole_runtime_all(); + failures += test_big_hole_runtime_all(); + + /* STACKINIT should cover everything from here down. */ + failures += test_u8(); + failures += test_u16(); + failures += test_u32(); + failures += test_u64(); + failures += test_char_array(); + + /* STRUCTLEAK_BYREF_ALL should cover from here down. */ + failures += test_small_hole(); + failures += test_big_hole(); + + /* STRUCTLEAK should cover this. */ + failures += test_user(); + + if (failures == 0) + pr_info("all tests passed!\n"); + else + pr_err("failures: %u\n", failures); + + return failures ? -EINVAL : 0; +} +module_init(test_stackinit_init); + +static void __exit test_stackinit_exit(void) +{ } +module_exit(test_stackinit_exit); + +MODULE_LICENSE("GPL"); -- 2.17.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [3/3] lib: Introduce test_stackinit module From: Kees Cook Message-Id: <20190123110349.35882-4-keescook@chromium.org> Date: Wed, 23 Jan 2019 03:03:49 -0800 To: linux-kernel@vger.kernel.org Cc: Kees Cook , Ard Biesheuvel , Laura Abbott , Alexander Popov , xen-devel@lists.xenproject.org, dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, intel-wired-lan@lists.osuosl.org, netdev@vger.kernel.org, linux-usb@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-mm@kvack.org, dev@openvswitch.org, linux-kbuild@vger.kernel.org, linux-security-module@vger.kernel.org, kernel-hardening@lists.openwall.com List-ID: QWRkcyB0ZXN0IGZvciBzdGFjayBpbml0aWFsaXphdGlvbiBjb3ZlcmFnZS4gV2UgaGF2ZSBzZXZl cmFsIGJ1aWxkIG9wdGlvbnMKdGhhdCBjb250cm9sIHRoZSBsZXZlbCBvZiBzdGFjayB2YXJpYWJs ZSBpbml0aWFsaXphdGlvbi4gVGhpcyB0ZXN0IGxldHMgdXMKdmlzdWFsaXplIHdoaWNoIG9wdGlv bnMgY292ZXIgd2hpY2ggY2FzZXMsIGFuZCBwcm92aWRlIHRlc3RzIGZvciBvcHRpb25zCnRoYXQg YXJlIGN1cnJlbnRseSBub3QgYXZhaWxhYmxlIChwYWRkaW5nIGluaXRpYWxpemF0aW9uKS4KCkFs bCBvcHRpb25zIHBhc3MgdGhlIGV4cGxpY2l0IGluaXRpYWxpemF0aW9uIGNhc2VzIGFuZCB0aGUg cGFydGlhbAppbml0aWFsaXplcnMgKGV2ZW4gd2l0aCBwYWRkaW5nKToKCnRlc3Rfc3RhY2tpbml0 OiB1OF96ZXJvIG9rCnRlc3Rfc3RhY2tpbml0OiB1MTZfemVybyBvawp0ZXN0X3N0YWNraW5pdDog dTMyX3plcm8gb2sKdGVzdF9zdGFja2luaXQ6IHU2NF96ZXJvIG9rCnRlc3Rfc3RhY2tpbml0OiBj aGFyX2FycmF5X3plcm8gb2sKdGVzdF9zdGFja2luaXQ6IHNtYWxsX2hvbGVfemVybyBvawp0ZXN0 X3N0YWNraW5pdDogYmlnX2hvbGVfemVybyBvawp0ZXN0X3N0YWNraW5pdDogcGFja2VkX3plcm8g b2sKdGVzdF9zdGFja2luaXQ6IHNtYWxsX2hvbGVfZHluYW1pY19wYXJ0aWFsIG9rCnRlc3Rfc3Rh Y2tpbml0OiBiaWdfaG9sZV9keW5hbWljX3BhcnRpYWwgb2sKdGVzdF9zdGFja2luaXQ6IHBhY2tl ZF9zdGF0aWNfcGFydGlhbCBvawp0ZXN0X3N0YWNraW5pdDogc21hbGxfaG9sZV9zdGF0aWNfcGFy dGlhbCBvawp0ZXN0X3N0YWNraW5pdDogYmlnX2hvbGVfc3RhdGljX3BhcnRpYWwgb2sKClRoZSBy ZXN1bHRzIG9mIHRoZSBvdGhlciB0ZXN0cyAod2hpY2ggY29udGFpbiBubyBleHBsaWNpdCBpbml0 aWFsaXphdGlvbiksCmNoYW5nZSBiYXNlZCBvbiB0aGUgYnVpbGQncyBjb25maWd1cmVkIGNvbXBp bGVyIGluc3RydW1lbnRhdGlvbi4KCk5vIG9wdGlvbnM6Cgp0ZXN0X3N0YWNraW5pdDogc21hbGxf aG9sZV9zdGF0aWNfYWxsIEZBSUwgKHVuaW5pdCBieXRlczogMykKdGVzdF9zdGFja2luaXQ6IGJp Z19ob2xlX3N0YXRpY19hbGwgRkFJTCAodW5pbml0IGJ5dGVzOiA2MSkKdGVzdF9zdGFja2luaXQ6 IHNtYWxsX2hvbGVfZHluYW1pY19hbGwgRkFJTCAodW5pbml0IGJ5dGVzOiAzKQp0ZXN0X3N0YWNr aW5pdDogYmlnX2hvbGVfZHluYW1pY19hbGwgRkFJTCAodW5pbml0IGJ5dGVzOiA2MSkKdGVzdF9z dGFja2luaXQ6IHNtYWxsX2hvbGVfcnVudGltZV9wYXJ0aWFsIEZBSUwgKHVuaW5pdCBieXRlczog MjMpCnRlc3Rfc3RhY2tpbml0OiBiaWdfaG9sZV9ydW50aW1lX3BhcnRpYWwgRkFJTCAodW5pbml0 IGJ5dGVzOiAxMjcpCnRlc3Rfc3RhY2tpbml0OiBzbWFsbF9ob2xlX3J1bnRpbWVfYWxsIEZBSUwg KHVuaW5pdCBieXRlczogMykKdGVzdF9zdGFja2luaXQ6IGJpZ19ob2xlX3J1bnRpbWVfYWxsIEZB SUwgKHVuaW5pdCBieXRlczogNjEpCnRlc3Rfc3RhY2tpbml0OiB1OCBGQUlMICh1bmluaXQgYnl0 ZXM6IDEpCnRlc3Rfc3RhY2tpbml0OiB1MTYgRkFJTCAodW5pbml0IGJ5dGVzOiAyKQp0ZXN0X3N0 YWNraW5pdDogdTMyIEZBSUwgKHVuaW5pdCBieXRlczogNCkKdGVzdF9zdGFja2luaXQ6IHU2NCBG QUlMICh1bmluaXQgYnl0ZXM6IDgpCnRlc3Rfc3RhY2tpbml0OiBjaGFyX2FycmF5IEZBSUwgKHVu aW5pdCBieXRlczogMTYpCnRlc3Rfc3RhY2tpbml0OiBzbWFsbF9ob2xlIEZBSUwgKHVuaW5pdCBi eXRlczogMjQpCnRlc3Rfc3RhY2tpbml0OiBiaWdfaG9sZSBGQUlMICh1bmluaXQgYnl0ZXM6IDEy OCkKdGVzdF9zdGFja2luaXQ6IHVzZXIgRkFJTCAodW5pbml0IGJ5dGVzOiAzMikKdGVzdF9zdGFj a2luaXQ6IGZhaWx1cmVzOiAxNgoKQ09ORklHX0dDQ19QTFVHSU5fU1RSVUNUTEVBSz15ClRoaXMg b25seSB0cmllcyB0byBpbml0aWFsaXplIHN0cnVjdHMgd2l0aCBfX3VzZXIgbWFya2luZ3M6Cgp0 ZXN0X3N0YWNraW5pdDogc21hbGxfaG9sZV9zdGF0aWNfYWxsIEZBSUwgKHVuaW5pdCBieXRlczog MykKdGVzdF9zdGFja2luaXQ6IGJpZ19ob2xlX3N0YXRpY19hbGwgRkFJTCAodW5pbml0IGJ5dGVz OiA2MSkKdGVzdF9zdGFja2luaXQ6IHNtYWxsX2hvbGVfZHluYW1pY19hbGwgRkFJTCAodW5pbml0 IGJ5dGVzOiAzKQp0ZXN0X3N0YWNraW5pdDogYmlnX2hvbGVfZHluYW1pY19hbGwgRkFJTCAodW5p bml0IGJ5dGVzOiA2MSkKdGVzdF9zdGFja2luaXQ6IHNtYWxsX2hvbGVfcnVudGltZV9wYXJ0aWFs IEZBSUwgKHVuaW5pdCBieXRlczogMjMpCnRlc3Rfc3RhY2tpbml0OiBiaWdfaG9sZV9ydW50aW1l X3BhcnRpYWwgRkFJTCAodW5pbml0IGJ5dGVzOiAxMjcpCnRlc3Rfc3RhY2tpbml0OiBzbWFsbF9o b2xlX3J1bnRpbWVfYWxsIEZBSUwgKHVuaW5pdCBieXRlczogMykKdGVzdF9zdGFja2luaXQ6IGJp Z19ob2xlX3J1bnRpbWVfYWxsIEZBSUwgKHVuaW5pdCBieXRlczogNjEpCnRlc3Rfc3RhY2tpbml0 OiB1OCBGQUlMICh1bmluaXQgYnl0ZXM6IDEpCnRlc3Rfc3RhY2tpbml0OiB1MTYgRkFJTCAodW5p bml0IGJ5dGVzOiAyKQp0ZXN0X3N0YWNraW5pdDogdTMyIEZBSUwgKHVuaW5pdCBieXRlczogNCkK dGVzdF9zdGFja2luaXQ6IHU2NCBGQUlMICh1bmluaXQgYnl0ZXM6IDgpCnRlc3Rfc3RhY2tpbml0 OiBjaGFyX2FycmF5IEZBSUwgKHVuaW5pdCBieXRlczogMTYpCnRlc3Rfc3RhY2tpbml0OiBzbWFs bF9ob2xlIEZBSUwgKHVuaW5pdCBieXRlczogMjQpCnRlc3Rfc3RhY2tpbml0OiBiaWdfaG9sZSBG QUlMICh1bmluaXQgYnl0ZXM6IDEyOCkKdGVzdF9zdGFja2luaXQ6IHVzZXIgb2sKdGVzdF9zdGFj a2luaXQ6IGZhaWx1cmVzOiAxNQoKQ09ORklHX0dDQ19QTFVHSU5fU1RSVUNUTEVBSz15CkNPTkZJ R19HQ0NfUExVR0lOX1NUUlVDVExFQUtfQllSRUZfQUxMPXkKVGhpcyBpbml0aWFsaXplcyBhbGwg c3RydWN0dXJlcyBwYXNzZWQgYnkgcmVmZXJlbmNlIChzY2FsYXJzIGFuZCBzdHJpbmdzCnJlbWFp biB1bmluaXRpYWxpemVkLCBidXQgcGFkZGluZyBpcyB3aXBlZCk6Cgp0ZXN0X3N0YWNraW5pdDog c21hbGxfaG9sZV9zdGF0aWNfYWxsIG9rCnRlc3Rfc3RhY2tpbml0OiBiaWdfaG9sZV9zdGF0aWNf YWxsIG9rCnRlc3Rfc3RhY2tpbml0OiBzbWFsbF9ob2xlX2R5bmFtaWNfYWxsIG9rCnRlc3Rfc3Rh Y2tpbml0OiBiaWdfaG9sZV9keW5hbWljX2FsbCBvawp0ZXN0X3N0YWNraW5pdDogc21hbGxfaG9s ZV9ydW50aW1lX3BhcnRpYWwgb2sKdGVzdF9zdGFja2luaXQ6IGJpZ19ob2xlX3J1bnRpbWVfcGFy dGlhbCBvawp0ZXN0X3N0YWNraW5pdDogc21hbGxfaG9sZV9ydW50aW1lX2FsbCBvawp0ZXN0X3N0 YWNraW5pdDogYmlnX2hvbGVfcnVudGltZV9hbGwgb2sKdGVzdF9zdGFja2luaXQ6IHU4IEZBSUwg KHVuaW5pdCBieXRlczogMSkKdGVzdF9zdGFja2luaXQ6IHUxNiBGQUlMICh1bmluaXQgYnl0ZXM6 IDIpCnRlc3Rfc3RhY2tpbml0OiB1MzIgRkFJTCAodW5pbml0IGJ5dGVzOiA0KQp0ZXN0X3N0YWNr aW5pdDogdTY0IEZBSUwgKHVuaW5pdCBieXRlczogOCkKdGVzdF9zdGFja2luaXQ6IGNoYXJfYXJy YXkgRkFJTCAodW5pbml0IGJ5dGVzOiAxNikKdGVzdF9zdGFja2luaXQ6IHNtYWxsX2hvbGUgb2sK dGVzdF9zdGFja2luaXQ6IGJpZ19ob2xlIG9rCnRlc3Rfc3RhY2tpbml0OiB1c2VyIG9rCnRlc3Rf c3RhY2tpbml0OiBmYWlsdXJlczogNQoKQ09ORklHX0dDQ19QTFVHSU5fU1RBQ0tJTklUPXkKVGhp cyBpbml0aWFsaXplcyBhbGwgdmFyaWFibGVzLCBidXQgaGFzIG5vIHNwZWNpYWwgcGFkZGluZyBo YW5kbGluZzoKCnRlc3Rfc3RhY2tpbml0OiBzbWFsbF9ob2xlX3N0YXRpY19hbGwgRkFJTCAodW5p bml0IGJ5dGVzOiAzKQp0ZXN0X3N0YWNraW5pdDogYmlnX2hvbGVfc3RhdGljX2FsbCBGQUlMICh1 bmluaXQgYnl0ZXM6IDYxKQp0ZXN0X3N0YWNraW5pdDogc21hbGxfaG9sZV9keW5hbWljX2FsbCBG QUlMICh1bmluaXQgYnl0ZXM6IDMpCnRlc3Rfc3RhY2tpbml0OiBiaWdfaG9sZV9keW5hbWljX2Fs bCBGQUlMICh1bmluaXQgYnl0ZXM6IDYxKQp0ZXN0X3N0YWNraW5pdDogc21hbGxfaG9sZV9ydW50 aW1lX3BhcnRpYWwgb2sKdGVzdF9zdGFja2luaXQ6IGJpZ19ob2xlX3J1bnRpbWVfcGFydGlhbCBv awp0ZXN0X3N0YWNraW5pdDogc21hbGxfaG9sZV9ydW50aW1lX2FsbCBvawp0ZXN0X3N0YWNraW5p dDogYmlnX2hvbGVfcnVudGltZV9hbGwgb2sKdGVzdF9zdGFja2luaXQ6IHU4IG9rCnRlc3Rfc3Rh Y2tpbml0OiB1MTYgb2sKdGVzdF9zdGFja2luaXQ6IHUzMiBvawp0ZXN0X3N0YWNraW5pdDogdTY0 IG9rCnRlc3Rfc3RhY2tpbml0OiBjaGFyX2FycmF5IG9rCnRlc3Rfc3RhY2tpbml0OiBzbWFsbF9o b2xlIG9rCnRlc3Rfc3RhY2tpbml0OiBiaWdfaG9sZSBvawp0ZXN0X3N0YWNraW5pdDogdXNlciBv awp0ZXN0X3N0YWNraW5pdDogZmFpbHVyZXM6IDQKClNpZ25lZC1vZmYtYnk6IEtlZXMgQ29vayA8 a2Vlc2Nvb2tAY2hyb21pdW0ub3JnPgotLS0KIGxpYi9LY29uZmlnLmRlYnVnICAgIHwgICA5ICsr CiBsaWIvTWFrZWZpbGUgICAgICAgICB8ICAgMSArCiBsaWIvdGVzdF9zdGFja2luaXQuYyB8IDMy NyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAzIGZpbGVzIGNo YW5nZWQsIDMzNyBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgbGliL3Rlc3Rfc3Rh Y2tpbml0LmMKCmRpZmYgLS1naXQgYS9saWIvS2NvbmZpZy5kZWJ1ZyBiL2xpYi9LY29uZmlnLmRl YnVnCmluZGV4IGQ0ZGY1YjI0ZDc1ZS4uMDk3ODhhZmNjY2M5IDEwMDY0NAotLS0gYS9saWIvS2Nv bmZpZy5kZWJ1ZworKysgYi9saWIvS2NvbmZpZy5kZWJ1ZwpAQCAtMjAwMSw2ICsyMDAxLDE1IEBA IGNvbmZpZyBURVNUX09CSkFHRwogCiAJICBJZiB1bnN1cmUsIHNheSBOLgogCitjb25maWcgVEVT VF9TVEFDS0lOSVQKKwl0cmlzdGF0ZSAiVGVzdCBsZXZlbCBvZiBzdGFjayB2YXJpYWJsZSBpbml0 aWFsaXphdGlvbiIKKwloZWxwCisJICBUZXN0IGlmIHRoZSBrZXJuZWwgaXMgemVyby1pbml0aWFs aXppbmcgc3RhY2sgdmFyaWFibGVzCisJICBmcm9tIENPTkZJR19HQ0NfUExVR0lOX1NUQUNLSU5J VCwgQ09ORklHX0dDQ19QTFVHSU5fU1RSVUNUTEVBSywKKwkgIGFuZC9vciBHQ0NfUExVR0lOX1NU UlVDVExFQUtfQllSRUZfQUxMLgorCisJICBJZiB1bnN1cmUsIHNheSBOLgorCiBlbmRpZiAjIFJV TlRJTUVfVEVTVElOR19NRU5VCiAKIGNvbmZpZyBNRU1URVNUCmRpZmYgLS1naXQgYS9saWIvTWFr ZWZpbGUgYi9saWIvTWFrZWZpbGUKaW5kZXggZTFiNTlkYTcxNDE4Li5jODFhNjZkNGQwMGQgMTAw NjQ0Ci0tLSBhL2xpYi9NYWtlZmlsZQorKysgYi9saWIvTWFrZWZpbGUKQEAgLTc2LDYgKzc2LDcg QEAgb2JqLSQoQ09ORklHX1RFU1RfS01PRCkgKz0gdGVzdF9rbW9kLm8KIG9iai0kKENPTkZJR19U RVNUX0RFQlVHX1ZJUlRVQUwpICs9IHRlc3RfZGVidWdfdmlydHVhbC5vCiBvYmotJChDT05GSUdf VEVTVF9NRU1DQVRfUCkgKz0gdGVzdF9tZW1jYXRfcC5vCiBvYmotJChDT05GSUdfVEVTVF9PQkpB R0cpICs9IHRlc3Rfb2JqYWdnLm8KK29iai0kKENPTkZJR19URVNUX1NUQUNLSU5JVCkgKz0gdGVz dF9zdGFja2luaXQubwogCiBpZmVxICgkKENPTkZJR19ERUJVR19LT0JKRUNUKSx5KQogQ0ZMQUdT X2tvYmplY3QubyArPSAtRERFQlVHCmRpZmYgLS1naXQgYS9saWIvdGVzdF9zdGFja2luaXQuYyBi L2xpYi90ZXN0X3N0YWNraW5pdC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMC4uZTJmZjU2YTEwMDJhCi0tLSAvZGV2L251bGwKKysrIGIvbGliL3Rlc3Rfc3RhY2tpbml0 LmMKQEAgLTAsMCArMSwzMjcgQEAKKy8vIFNQRFgtTGljZW5zZXM6IEdQTHYyCisvKgorICogVGVz dCBjYXNlcyBmb3IgLWZpbml0LWxvY2FsLXZhcnMgYW5kIENPTkZJR19HQ0NfUExVR0lOX1NUQUNL SU5JVC4KKyAqLworI2RlZmluZSBwcl9mbXQoZm10KSBLQlVJTERfTU9ETkFNRSAiOiAiIGZtdAor CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2lu Y2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgorCisvKiBF eGZpbHRyYXRpb24gYnVmZmVyLiAqLworI2RlZmluZSBNQVhfVkFSX1NJWkUJMTI4CitzdGF0aWMg Y2hhciBjaGVja19idWZbTUFYX1ZBUl9TSVpFXTsKKworLyogQ2hhcmFjdGVyIGFycmF5IHRvIHRy aWdnZXIgc3RhY2sgcHJvdGVjdG9yIGluIGFsbCBmdW5jdGlvbnMuICovCisjZGVmaW5lIFZBUl9C VUZGRVIJIDMyCisKKy8qIFZvbGF0aWxlIG1hc2sgdG8gY29udmluY2UgY29tcGlsZXIgdG8gY29w eSBtZW1vcnkgd2l0aCAweGZmLiAqLworc3RhdGljIHZvbGF0aWxlIHU4IGZvcmNlZF9tYXNrID0g MHhmZjsKKworLyogTG9jYXRpb24gYW5kIHNpemUgdHJhY2tpbmcgdG8gdmFsaWRhdGUgZmlsbCBh bmQgdGVzdCBhcmUgY29sb2NhdGVkLiAqLworc3RhdGljIHZvaWQgKmZpbGxfc3RhcnQsICp0YXJn ZXRfc3RhcnQ7CitzdGF0aWMgc2l6ZV90IGZpbGxfc2l6ZSwgdGFyZ2V0X3NpemU7CisKK3N0YXRp YyBib29sIHJhbmdlX2NvbnRhaW5zKGNoYXIgKmhheXN0YWNrX3N0YXJ0LCBzaXplX3QgaGF5c3Rh Y2tfc2l6ZSwKKwkJCSAgIGNoYXIgKm5lZWRsZV9zdGFydCwgc2l6ZV90IG5lZWRsZV9zaXplKQor eworCWlmIChuZWVkbGVfc3RhcnQgPj0gaGF5c3RhY2tfc3RhcnQgJiYKKwkgICAgbmVlZGxlX3N0 YXJ0ICsgbmVlZGxlX3NpemUgPD0gaGF5c3RhY2tfc3RhcnQgKyBoYXlzdGFja19zaXplKQorCQly ZXR1cm4gdHJ1ZTsKKwlyZXR1cm4gZmFsc2U7Cit9CisKKyNkZWZpbmUgRE9fTk9USElOR19UWVBF X1NDQUxBUih2YXJfdHlwZSkJdmFyX3R5cGUKKyNkZWZpbmUgRE9fTk9USElOR19UWVBFX1NUUklO Ryh2YXJfdHlwZSkJdm9pZAorI2RlZmluZSBET19OT1RISU5HX1RZUEVfU1RSVUNUKHZhcl90eXBl KQl2b2lkCisKKyNkZWZpbmUgRE9fTk9USElOR19SRVRVUk5fU0NBTEFSKHB0cikJCSoocHRyKQor I2RlZmluZSBET19OT1RISU5HX1JFVFVSTl9TVFJJTkcocHRyKQkJLyoqLworI2RlZmluZSBET19O T1RISU5HX1JFVFVSTl9TVFJVQ1QocHRyKQkJLyoqLworCisjZGVmaW5lIERPX05PVEhJTkdfQ0FM TF9TQ0FMQVIodmFyLCBuYW1lKQkJCVwKKwkJKHZhcikgPSBkb19ub3RoaW5nXyAjIyBuYW1lKCYo dmFyKSkKKyNkZWZpbmUgRE9fTk9USElOR19DQUxMX1NUUklORyh2YXIsIG5hbWUpCQkJXAorCQlk b19ub3RoaW5nXyAjIyBuYW1lKHZhcikKKyNkZWZpbmUgRE9fTk9USElOR19DQUxMX1NUUlVDVCh2 YXIsIG5hbWUpCQkJXAorCQlkb19ub3RoaW5nXyAjIyBuYW1lKCYodmFyKSkKKworI2RlZmluZSBG RVRDSF9BUkdfU0NBTEFSKHZhcikJCSZ2YXIKKyNkZWZpbmUgRkVUQ0hfQVJHX1NUUklORyh2YXIp CQl2YXIKKyNkZWZpbmUgRkVUQ0hfQVJHX1NUUlVDVCh2YXIpCQkmdmFyCisKKyNkZWZpbmUgRklM TF9TSVpFX1NDQUxBUgkJMQorI2RlZmluZSBGSUxMX1NJWkVfU1RSSU5HCQkxNgorI2RlZmluZSBG SUxMX1NJWkVfU1RSVUNUCQkxCisKKyNkZWZpbmUgSU5JVF9DTE9ORV9TQ0FMQVIJCS8qKi8KKyNk ZWZpbmUgSU5JVF9DTE9ORV9TVFJJTkcJCVtGSUxMX1NJWkVfU1RSSU5HXQorI2RlZmluZSBJTklU X0NMT05FX1NUUlVDVAkJLyoqLworCisjZGVmaW5lIElOSVRfU0NBTEFSX05PTkUJCS8qKi8KKyNk ZWZpbmUgSU5JVF9TQ0FMQVJfWkVSTwkJPSAwCisKKyNkZWZpbmUgSU5JVF9TVFJJTkdfTk9ORQkJ W0ZJTExfU0laRV9TVFJJTkddIC8qKi8KKyNkZWZpbmUgSU5JVF9TVFJJTkdfWkVSTwkJW0ZJTExf U0laRV9TVFJJTkddID0geyB9CisKKyNkZWZpbmUgSU5JVF9TVFJVQ1RfTk9ORQkJLyoqLworI2Rl ZmluZSBJTklUX1NUUlVDVF9aRVJPCQk9IHsgfQorI2RlZmluZSBJTklUX1NUUlVDVF9TVEFUSUNf UEFSVElBTAk9IHsgLnR3byA9IDAsIH0KKyNkZWZpbmUgSU5JVF9TVFJVQ1RfU1RBVElDX0FMTAkJ PSB7IC5vbmUgPSBhcmctPm9uZSwJCVwKKwkJCQkJICAgIC50d28gPSBhcmctPnR3bywJCVwKKwkJ CQkJICAgIC50aHJlZSA9IGFyZy0+dGhyZWUsCVwKKwkJCQkJICAgIC5mb3VyID0gYXJnLT5mb3Vy LAkJXAorCQkJCQl9CisjZGVmaW5lIElOSVRfU1RSVUNUX0RZTkFNSUNfUEFSVElBTAk9IHsgLnR3 byA9IGFyZy0+dHdvLCB9CisjZGVmaW5lIElOSVRfU1RSVUNUX0RZTkFNSUNfQUxMCQk9IHsgLm9u ZSA9IGFyZy0+b25lLAkJXAorCQkJCQkgICAgLnR3byA9IGFyZy0+dHdvLAkJXAorCQkJCQkgICAg LnRocmVlID0gYXJnLT50aHJlZSwJXAorCQkJCQkgICAgLmZvdXIgPSBhcmctPmZvdXIsCQlcCisJ CQkJCX0KKyNkZWZpbmUgSU5JVF9TVFJVQ1RfUlVOVElNRV9QQVJUSUFMCTsJCQkJXAorCQkJCQl2 YXIudHdvID0gMAorI2RlZmluZSBJTklUX1NUUlVDVF9SVU5USU1FX0FMTAkJOwkJCQlcCisJCQkJ CXZhci5vbmUgPSAwOwkJCVwKKwkJCQkJdmFyLnR3byA9IDA7CQkJXAorCQkJCQl2YXIudGhyZWUg PSAwOwkJCVwKKwkJCQkJbWVtc2V0KCZ2YXIuZm91ciwgMCwJCVwKKwkJCQkJICAgICAgIHNpemVv Zih2YXIuZm91cikpCisKKy8qCisgKiBAbmFtZTogdW5pcXVlIHN0cmluZyBuYW1lIGZvciB0aGUg dGVzdAorICogQHZhcl90eXBlOiB0eXBlIHRvIGJlIHRlc3RlZCBmb3IgemVyb2luZyBpbml0aWFs aXphdGlvbgorICogQHdoaWNoOiBpcyB0aGlzIGEgU0NBTEFSIG9yIGEgU1RSVUNUIHR5cGU/Cisg KiBAaW5pdF9sZXZlbDogd2hhdCBraW5kIG9mIGluaXRpYWxpemF0aW9uIGlzIHBlcmZvcm1lZAor ICovCisjZGVmaW5lIERFRklORV9URVNUKG5hbWUsIHZhcl90eXBlLCB3aGljaCwgaW5pdF9sZXZl bCkJCVwKK3N0YXRpYyBub2lubGluZSBpbnQgZmlsbF8gIyMgbmFtZSh1bnNpZ25lZCBsb25nIHNw KQkJXAorewkJCQkJCQkJXAorCWNoYXIgYnVmW1ZBUl9CVUZGRVIgKwkJCQkJXAorCQkgc2l6ZW9m KHZhcl90eXBlKSAqIEZJTExfU0laRV8gIyMgd2hpY2ggKiA0XTsJXAorCQkJCQkJCQlcCisJZmls bF9zdGFydCA9IGJ1ZjsJCQkJCVwKKwlmaWxsX3NpemUgPSBzaXplb2YoYnVmKTsJCQkJXAorCS8q IEZpbGwgdmFyaWFibGUgd2l0aCAweEZGLiAqLwkJCQlcCisJbWVtc2V0KGZpbGxfc3RhcnQsIChj aGFyKSgoc3AgJiYgMHhmZikgfCBmb3JjZWRfbWFzayksCVwKKwkgICAgICAgZmlsbF9zaXplKTsJ CQkJCVwKKwkJCQkJCQkJXAorCXJldHVybiAoaW50KWJ1ZlswXSB8IChpbnQpYnVmW3NpemVvZihi dWYpLTFdOwkJXAorfQkJCQkJCQkJXAorLyogbm8tb3AgdG8gZm9yY2UgY29tcGlsZXIgaW50byBp Z25vcmluZyAidW5pbml0aWFsaXplZCIgdmFycyAqL1wKK3N0YXRpYyBub2lubGluZSBET19OT1RI SU5HX1RZUEVfICMjIHdoaWNoKHZhcl90eXBlKQkJXAorZG9fbm90aGluZ18gIyMgbmFtZSh2YXJf dHlwZSAqcHRyKQkJCQlcCit7CQkJCQkJCQlcCisJLyogV2lsbCBhbHdheXMgYmUgdHJ1ZSwgYnV0 IGNvbXBpbGVyIGRvZXNuJ3Qga25vdy4gKi8JXAorCWlmICgodW5zaWduZWQgbG9uZylwdHIgPiAw eDIpCQkJCVwKKwkJcmV0dXJuIERPX05PVEhJTkdfUkVUVVJOXyAjIyB3aGljaChwdHIpOwlcCisJ ZWxzZQkJCQkJCQlcCisJCXJldHVybiBET19OT1RISU5HX1JFVFVSTl8gIyMgd2hpY2gocHRyICsg MSk7CVwKK30JCQkJCQkJCVwKK3N0YXRpYyBub2lubGluZSBpbnQgZmV0Y2hfICMjIG5hbWUodW5z aWduZWQgbG9uZyBzcCwJCVwKKwkJCQkgICB2YXJfdHlwZSAqYXJnKQkJXAorewkJCQkJCQkJXAor CWNoYXIgYnVmW1ZBUl9CVUZGRVJdOwkJCQkJXAorCXZhcl90eXBlIHZhciBJTklUXyAjIyB3aGlj aCAjIyBfICMjIGluaXRfbGV2ZWw7CQlcCisJCQkJCQkJCVwKKwl0YXJnZXRfc3RhcnQgPSAmdmFy OwkJCQkJXAorCXRhcmdldF9zaXplID0gc2l6ZW9mKHZhcik7CQkJCVwKKwkvKgkJCQkJCQlcCisJ ICogS2VlcCB0aGlzIGJ1ZmZlciBhcm91bmQgdG8gbWFrZSBzdXJlIHdlJ3ZlIGdvdCBhCVwKKwkg KiBzdGFjayBmcmFtZSBvZiBTT01FIGtpbmQuLi4JCQkJXAorCSAqLwkJCQkJCQlcCisJbWVtc2V0 KGJ1ZiwgKGNoYXIpKHNwICYmIDB4ZmYpLCBzaXplb2YoYnVmKSk7CQlcCisJCQkJCQkJCVwKKwkv KiBTaWxlbmNlICJuZXZlciBpbml0aWFsaXplZCIgd2FybmluZ3MuICovCQlcCisJRE9fTk9USElO R19DQUxMXyAjIyB3aGljaCh2YXIsIG5hbWUpOwkJCVwKKwkJCQkJCQkJXAorCS8qIEV4ZmlsdHJh dGUgInZhciIgb3IgZmllbGQgb2YgInZhciIuICovCQlcCisJbWVtY3B5KGNoZWNrX2J1ZiwgdGFy Z2V0X3N0YXJ0LCB0YXJnZXRfc2l6ZSk7CQlcCisJCQkJCQkJCVwKKwlyZXR1cm4gKGludClidWZb MF0gfCAoaW50KWJ1ZltzaXplb2YoYnVmKSAtIDFdOwkJXAorfQkJCQkJCQkJXAorLyogUmV0dXJu cyAwIG9uIHN1Y2Nlc3MsIDEgb24gZmFpbHVyZS4gKi8JCQlcCitzdGF0aWMgbm9pbmxpbmUgaW50 IHRlc3RfICMjIG5hbWUgKHZvaWQpCQkJXAorewkJCQkJCQkJXAorCXZhcl90eXBlIHplcm8gSU5J VF9DTE9ORV8gIyMgd2hpY2g7CQkJXAorCWludCBpZ25vcmVkOwkJCQkJCVwKKwl1OCBzdW0gPSAw LCBpOwkJCQkJCVwKKwkJCQkJCQkJXAorCS8qIE5vdGljZSB3aGVuIGEgbmV3IHRlc3QgaXMgbGFy Z2VyIHRoYW4gZXhwZWN0ZWQuICovCVwKKwlCVUlMRF9CVUdfT04oc2l6ZW9mKHplcm8pID4gTUFY X1ZBUl9TSVpFKTsJCVwKKwkvKiBDbGVhciBlbnRpcmUgY2hlY2sgYnVmZmVyIGZvciBsYXRlciBi aXQgdGVzdHMuICovCVwKKwltZW1zZXQoY2hlY2tfYnVmLCAweDAwLCBzaXplb2YoY2hlY2tfYnVm KSk7CQlcCisJCQkJCQkJCVwKKwkvKiBGaWxsIGNsb25lIHR5cGUgd2l0aCB6ZXJvIGZvciBwZXIt ZmllbGQgaW5pdC4gKi8JXAorCW1lbXNldCgmemVybywgMHgwMCwgc2l6ZW9mKHplcm8pKTsJCQlc CisJLyogRmlsbCBzdGFjayB3aXRoIDB4RkYuICovCQkJCVwKKwlpZ25vcmVkID0gZmlsbF8gIyNu YW1lKCh1bnNpZ25lZCBsb25nKSZpZ25vcmVkKTsJXAorCS8qIEV4dHJhY3Qgc3RhY2stZGVmaW5l ZCB2YXJpYWJsZSBjb250ZW50cy4gKi8JCVwKKwlpZ25vcmVkID0gZmV0Y2hfICMjbmFtZSgodW5z aWduZWQgbG9uZykmaWdub3JlZCwJXAorCQkJCUZFVENIX0FSR18gIyMgd2hpY2goemVybykpOwlc CisJCQkJCQkJCVwKKwkvKiBWYWxpZGF0ZSB0aGF0IGNvbXBpbGVyIGxpbmVkIHVwIGZpbGwgYW5k IHRhcmdldC4gKi8JXAorCWlmICghcmFuZ2VfY29udGFpbnMoZmlsbF9zdGFydCwgZmlsbF9zaXpl LAkJXAorCQkJICAgIHRhcmdldF9zdGFydCwgdGFyZ2V0X3NpemUpKSB7CVwKKwkJcHJfZXJyKCNu YW1lICI6IHN0YWNrIGZpbGwgbWlzc2VkIHRhcmdldCE/XG4iKTsJXAorCQlwcl9lcnIoI25hbWUg IjogZmlsbCAlenUgd2lkZVxuIiwgZmlsbF9zaXplKTsJXAorCQlwcl9lcnIoI25hbWUgIjogdGFy Z2V0IG9mZnNldCBieSAlbGRcbiIsCVwKKwkJCShzc2l6ZV90KSh1aW50cHRyX3QpZmlsbF9zdGFy dCAtCVwKKwkJCShzc2l6ZV90KSh1aW50cHRyX3QpdGFyZ2V0X3N0YXJ0KTsJXAorCQlyZXR1cm4g MTsJCQkJCVwKKwl9CQkJCQkJCVwKKwkJCQkJCQkJXAorCS8qIExvb2sgZm9yIGFueSBzZXQgYml0 cyBpbiB0aGUgY2hlY2sgcmVnaW9uLiAqLwlcCisJZm9yIChpID0gMDsgaSA8IHNpemVvZihjaGVj a19idWYpOyBpKyspCQkJXAorCQlzdW0gKz0gKGNoZWNrX2J1ZltpXSAhPSAwKTsJCQlcCisJCQkJ CQkJCVwKKwlpZiAoc3VtID09IDApCQkJCQkJXAorCQlwcl9pbmZvKCNuYW1lICIgb2tcbiIpOwkJ CQlcCisJZWxzZQkJCQkJCQlcCisJCXByX3dhcm4oI25hbWUgIiBGQUlMICh1bmluaXQgYnl0ZXM6 ICVkKVxuIiwJXAorCQkJc3VtKTsJCQkJCVwKKwkJCQkJCQkJXAorCXJldHVybiAoc3VtICE9IDAp OwkJCQkJXAorfQorCisvKiBTdHJ1Y3R1cmUgd2l0aCBubyBwYWRkaW5nLiAqLworc3RydWN0IHRl c3RfcGFja2VkIHsKKwl1bnNpZ25lZCBsb25nIG9uZTsKKwl1bnNpZ25lZCBsb25nIHR3bzsKKwl1 bnNpZ25lZCBsb25nIHRocmVlOworCXVuc2lnbmVkIGxvbmcgZm91cjsKK307CisKKy8qIFNpbXBs ZSBzdHJ1Y3R1cmUgd2l0aCBwYWRkaW5nIGxpa2VseSB0byBiZSBjb3ZlcmVkIGJ5IGNvbXBpbGVy LiAqLworc3RydWN0IHRlc3Rfc21hbGxfaG9sZSB7CisJc2l6ZV90IG9uZTsKKwljaGFyIHR3bzsK KwkvKiAzIGJ5dGUgcGFkZGluZyBob2xlIGhlcmUuICovCisJaW50IHRocmVlOworCXVuc2lnbmVk IGxvbmcgZm91cjsKK307CisKKy8qIFRyeSB0byB0cmlnZ2VyIHVuaGFuZGxlZCBwYWRkaW5nIGlu IGEgc3RydWN0dXJlLiAqLworc3RydWN0IHRlc3RfYWxpZ25lZCB7CisJdTMyIGludGVybmFsMTsK Kwl1NjQgaW50ZXJuYWwyOworfSBfX2FsaWduZWQoNjQpOworCitzdHJ1Y3QgdGVzdF9iaWdfaG9s ZSB7CisJdTggb25lOworCXU4IHR3bzsKKwl1OCB0aHJlZTsKKwkvKiA2MSBieXRlIHBhZGRpbmcg aG9sZSBoZXJlLiAqLworCXN0cnVjdCB0ZXN0X2FsaWduZWQgZm91cjsKK30gX19hbGlnbmVkKDY0 KTsKKworLyogVGVzdCBpZiBTVFJVQ1RMRUFLIGlzIGNsZWFyaW5nIHN0cnVjdHMgd2l0aCBfX3Vz ZXIgZmllbGRzLiAqLworc3RydWN0IHRlc3RfdXNlciB7CisJdTggb25lOworCWNoYXIgX191c2Vy ICp0d287CisJdW5zaWduZWQgbG9uZyB0aHJlZTsKKwl1bnNpZ25lZCBsb25nIGZvdXI7Cit9Owor CisvKiBUaGVzZSBzaG91bGQgYmUgZnVsbHkgaW5pdGlhbGl6ZWQgYWxsIHRoZSB0aW1lISAqLwor REVGSU5FX1RFU1QodThfemVybywgdTgsIFNDQUxBUiwgWkVSTyk7CitERUZJTkVfVEVTVCh1MTZf emVybywgdTE2LCBTQ0FMQVIsIFpFUk8pOworREVGSU5FX1RFU1QodTMyX3plcm8sIHUzMiwgU0NB TEFSLCBaRVJPKTsKK0RFRklORV9URVNUKHU2NF96ZXJvLCB1NjQsIFNDQUxBUiwgWkVSTyk7CitE RUZJTkVfVEVTVChjaGFyX2FycmF5X3plcm8sIHVuc2lnbmVkIGNoYXIsIFNUUklORywgWkVSTyk7 CisKK0RFRklORV9URVNUKHBhY2tlZF96ZXJvLCBzdHJ1Y3QgdGVzdF9wYWNrZWQsIFNUUlVDVCwg WkVSTyk7CitERUZJTkVfVEVTVChzbWFsbF9ob2xlX3plcm8sIHN0cnVjdCB0ZXN0X3NtYWxsX2hv bGUsIFNUUlVDVCwgWkVSTyk7CitERUZJTkVfVEVTVChiaWdfaG9sZV96ZXJvLCBzdHJ1Y3QgdGVz dF9iaWdfaG9sZSwgU1RSVUNULCBaRVJPKTsKKworLyogU3RhdGljIGluaXRpYWxpemF0aW9uOiBw YWRkaW5nIG1heSBiZSBsZWZ0IHVuaW5pdGlhbGl6ZWQuICovCitERUZJTkVfVEVTVChwYWNrZWRf c3RhdGljX3BhcnRpYWwsIHN0cnVjdCB0ZXN0X3BhY2tlZCwgU1RSVUNULCBTVEFUSUNfUEFSVElB TCk7CitERUZJTkVfVEVTVChzbWFsbF9ob2xlX3N0YXRpY19wYXJ0aWFsLCBzdHJ1Y3QgdGVzdF9z bWFsbF9ob2xlLCBTVFJVQ1QsIFNUQVRJQ19QQVJUSUFMKTsKK0RFRklORV9URVNUKGJpZ19ob2xl X3N0YXRpY19wYXJ0aWFsLCBzdHJ1Y3QgdGVzdF9iaWdfaG9sZSwgU1RSVUNULCBTVEFUSUNfUEFS VElBTCk7CisKK0RFRklORV9URVNUKHNtYWxsX2hvbGVfc3RhdGljX2FsbCwgc3RydWN0IHRlc3Rf c21hbGxfaG9sZSwgU1RSVUNULCBTVEFUSUNfQUxMKTsKK0RFRklORV9URVNUKGJpZ19ob2xlX3N0 YXRpY19hbGwsIHN0cnVjdCB0ZXN0X2JpZ19ob2xlLCBTVFJVQ1QsIFNUQVRJQ19BTEwpOworCisv KiBEeW5hbWljIGluaXRpYWxpemF0aW9uOiBwYWRkaW5nIG1heSBiZSBsZWZ0IHVuaW5pdGlhbGl6 ZWQuICovCitERUZJTkVfVEVTVChzbWFsbF9ob2xlX2R5bmFtaWNfcGFydGlhbCwgc3RydWN0IHRl c3Rfc21hbGxfaG9sZSwgU1RSVUNULCBEWU5BTUlDX1BBUlRJQUwpOworREVGSU5FX1RFU1QoYmln X2hvbGVfZHluYW1pY19wYXJ0aWFsLCBzdHJ1Y3QgdGVzdF9iaWdfaG9sZSwgU1RSVUNULCBEWU5B TUlDX1BBUlRJQUwpOworCitERUZJTkVfVEVTVChzbWFsbF9ob2xlX2R5bmFtaWNfYWxsLCBzdHJ1 Y3QgdGVzdF9zbWFsbF9ob2xlLCBTVFJVQ1QsIERZTkFNSUNfQUxMKTsKK0RFRklORV9URVNUKGJp Z19ob2xlX2R5bmFtaWNfYWxsLCBzdHJ1Y3QgdGVzdF9iaWdfaG9sZSwgU1RSVUNULCBEWU5BTUlD X0FMTCk7CisKKy8qIFJ1bnRpbWUgaW5pdGlhbGl6YXRpb246IHBhZGRpbmcgbWF5IGJlIGxlZnQg dW5pbml0aWFsaXplZC4gKi8KK0RFRklORV9URVNUKHNtYWxsX2hvbGVfcnVudGltZV9wYXJ0aWFs LCBzdHJ1Y3QgdGVzdF9zbWFsbF9ob2xlLCBTVFJVQ1QsIFJVTlRJTUVfUEFSVElBTCk7CitERUZJ TkVfVEVTVChiaWdfaG9sZV9ydW50aW1lX3BhcnRpYWwsIHN0cnVjdCB0ZXN0X2JpZ19ob2xlLCBT VFJVQ1QsIFJVTlRJTUVfUEFSVElBTCk7CisKK0RFRklORV9URVNUKHNtYWxsX2hvbGVfcnVudGlt ZV9hbGwsIHN0cnVjdCB0ZXN0X3NtYWxsX2hvbGUsIFNUUlVDVCwgUlVOVElNRV9BTEwpOworREVG SU5FX1RFU1QoYmlnX2hvbGVfcnVudGltZV9hbGwsIHN0cnVjdCB0ZXN0X2JpZ19ob2xlLCBTVFJV Q1QsIFJVTlRJTUVfQUxMKTsKKworLyogTm8gaW5pdGlhbGl6YXRpb24gd2l0aG91dCBjb21waWxl ciBpbnN0cnVtZW50YXRpb24uICovCitERUZJTkVfVEVTVCh1OCwgdTgsIFNDQUxBUiwgTk9ORSk7 CitERUZJTkVfVEVTVCh1MTYsIHUxNiwgU0NBTEFSLCBOT05FKTsKK0RFRklORV9URVNUKHUzMiwg dTMyLCBTQ0FMQVIsIE5PTkUpOworREVGSU5FX1RFU1QodTY0LCB1NjQsIFNDQUxBUiwgTk9ORSk7 CitERUZJTkVfVEVTVChjaGFyX2FycmF5LCB1bnNpZ25lZCBjaGFyLCBTVFJJTkcsIE5PTkUpOwor REVGSU5FX1RFU1Qoc21hbGxfaG9sZSwgc3RydWN0IHRlc3Rfc21hbGxfaG9sZSwgU1RSVUNULCBO T05FKTsKK0RFRklORV9URVNUKGJpZ19ob2xlLCBzdHJ1Y3QgdGVzdF9iaWdfaG9sZSwgU1RSVUNU LCBOT05FKTsKK0RFRklORV9URVNUKHVzZXIsIHN0cnVjdCB0ZXN0X3VzZXIsIFNUUlVDVCwgTk9O RSk7CisKK3N0YXRpYyBpbnQgX19pbml0IHRlc3Rfc3RhY2tpbml0X2luaXQodm9pZCkKK3sKKwl1 bnNpZ25lZCBpbnQgZmFpbHVyZXMgPSAwOworCisJLyogVGhlc2UgYXJlIGV4cGxpY2l0bHkgaW5p dGlhbGl6ZWQgYW5kIHNob3VsZCBhbHdheXMgcGFzcy4gKi8KKwlmYWlsdXJlcyArPSB0ZXN0X3U4 X3plcm8oKTsKKwlmYWlsdXJlcyArPSB0ZXN0X3UxNl96ZXJvKCk7CisJZmFpbHVyZXMgKz0gdGVz dF91MzJfemVybygpOworCWZhaWx1cmVzICs9IHRlc3RfdTY0X3plcm8oKTsKKwlmYWlsdXJlcyAr PSB0ZXN0X2NoYXJfYXJyYXlfemVybygpOworCWZhaWx1cmVzICs9IHRlc3Rfc21hbGxfaG9sZV96 ZXJvKCk7CisJZmFpbHVyZXMgKz0gdGVzdF9iaWdfaG9sZV96ZXJvKCk7CisJZmFpbHVyZXMgKz0g dGVzdF9wYWNrZWRfemVybygpOworCisJLyogUGFkZGluZyBoZXJlIGFwcGVhcnMgdG8gYmUgYWNj aWRlbnRhbGx5IGFsd2F5cyBpbml0aWFsaXplZC4gKi8KKwlmYWlsdXJlcyArPSB0ZXN0X3NtYWxs X2hvbGVfZHluYW1pY19wYXJ0aWFsKCk7CisJZmFpbHVyZXMgKz0gdGVzdF9iaWdfaG9sZV9keW5h bWljX3BhcnRpYWwoKTsKKwlmYWlsdXJlcyArPSB0ZXN0X3BhY2tlZF9zdGF0aWNfcGFydGlhbCgp OworCisJLyogUGFkZGluZyBpbml0aWFsaXphdGlvbiBkZXBlbmRzIG9uIGNvbXBpbGVyIGJlaGF2 aW9ycy4gKi8KKwlmYWlsdXJlcyArPSB0ZXN0X3NtYWxsX2hvbGVfc3RhdGljX3BhcnRpYWwoKTsK KwlmYWlsdXJlcyArPSB0ZXN0X2JpZ19ob2xlX3N0YXRpY19wYXJ0aWFsKCk7CisJZmFpbHVyZXMg Kz0gdGVzdF9zbWFsbF9ob2xlX3N0YXRpY19hbGwoKTsKKwlmYWlsdXJlcyArPSB0ZXN0X2JpZ19o b2xlX3N0YXRpY19hbGwoKTsKKwlmYWlsdXJlcyArPSB0ZXN0X3NtYWxsX2hvbGVfZHluYW1pY19h bGwoKTsKKwlmYWlsdXJlcyArPSB0ZXN0X2JpZ19ob2xlX2R5bmFtaWNfYWxsKCk7CisJZmFpbHVy ZXMgKz0gdGVzdF9zbWFsbF9ob2xlX3J1bnRpbWVfcGFydGlhbCgpOworCWZhaWx1cmVzICs9IHRl c3RfYmlnX2hvbGVfcnVudGltZV9wYXJ0aWFsKCk7CisJZmFpbHVyZXMgKz0gdGVzdF9zbWFsbF9o b2xlX3J1bnRpbWVfYWxsKCk7CisJZmFpbHVyZXMgKz0gdGVzdF9iaWdfaG9sZV9ydW50aW1lX2Fs bCgpOworCisJLyogU1RBQ0tJTklUIHNob3VsZCBjb3ZlciBldmVyeXRoaW5nIGZyb20gaGVyZSBk b3duLiAqLworCWZhaWx1cmVzICs9IHRlc3RfdTgoKTsKKwlmYWlsdXJlcyArPSB0ZXN0X3UxNigp OworCWZhaWx1cmVzICs9IHRlc3RfdTMyKCk7CisJZmFpbHVyZXMgKz0gdGVzdF91NjQoKTsKKwlm YWlsdXJlcyArPSB0ZXN0X2NoYXJfYXJyYXkoKTsKKworCS8qIFNUUlVDVExFQUtfQllSRUZfQUxM IHNob3VsZCBjb3ZlciBmcm9tIGhlcmUgZG93bi4gKi8KKwlmYWlsdXJlcyArPSB0ZXN0X3NtYWxs X2hvbGUoKTsKKwlmYWlsdXJlcyArPSB0ZXN0X2JpZ19ob2xlKCk7CisKKwkvKiBTVFJVQ1RMRUFL IHNob3VsZCBjb3ZlciB0aGlzLiAqLworCWZhaWx1cmVzICs9IHRlc3RfdXNlcigpOworCisJaWYg KGZhaWx1cmVzID09IDApCisJCXByX2luZm8oImFsbCB0ZXN0cyBwYXNzZWQhXG4iKTsKKwllbHNl CisJCXByX2VycigiZmFpbHVyZXM6ICV1XG4iLCBmYWlsdXJlcyk7CisKKwlyZXR1cm4gZmFpbHVy ZXMgPyAtRUlOVkFMIDogMDsKK30KK21vZHVsZV9pbml0KHRlc3Rfc3RhY2tpbml0X2luaXQpOwor CitzdGF0aWMgdm9pZCBfX2V4aXQgdGVzdF9zdGFja2luaXRfZXhpdCh2b2lkKQoreyB9Cittb2R1 bGVfZXhpdCh0ZXN0X3N0YWNraW5pdF9leGl0KTsKKworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: Kees Cook Subject: [PATCH 3/3] lib: Introduce test_stackinit module Date: Wed, 23 Jan 2019 03:03:49 -0800 Message-ID: <20190123110349.35882-4-keescook@chromium.org> References: <20190123110349.35882-1-keescook@chromium.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190123110349.35882-1-keescook@chromium.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: linux-kernel@vger.kernel.org Cc: dev@openvswitch.org, Kees Cook , Ard Biesheuvel , netdev@vger.kernel.org, intel-gfx@lists.freedesktop.org, linux-usb@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-mm@kvack.org, linux-security-module@vger.kernel.org, kernel-hardening@lists.openwall.com, intel-wired-lan@lists.osuosl.org, linux-fsdevel@vger.kernel.org, xen-devel@lists.xenproject.org, Laura Abbott , linux-kbuild@vger.kernel.org, Alexander Popov List-Id: dri-devel@lists.freedesktop.org QWRkcyB0ZXN0IGZvciBzdGFjayBpbml0aWFsaXphdGlvbiBjb3ZlcmFnZS4gV2UgaGF2ZSBzZXZl cmFsIGJ1aWxkIG9wdGlvbnMKdGhhdCBjb250cm9sIHRoZSBsZXZlbCBvZiBzdGFjayB2YXJpYWJs ZSBpbml0aWFsaXphdGlvbi4gVGhpcyB0ZXN0IGxldHMgdXMKdmlzdWFsaXplIHdoaWNoIG9wdGlv bnMgY292ZXIgd2hpY2ggY2FzZXMsIGFuZCBwcm92aWRlIHRlc3RzIGZvciBvcHRpb25zCnRoYXQg YXJlIGN1cnJlbnRseSBub3QgYXZhaWxhYmxlIChwYWRkaW5nIGluaXRpYWxpemF0aW9uKS4KCkFs bCBvcHRpb25zIHBhc3MgdGhlIGV4cGxpY2l0IGluaXRpYWxpemF0aW9uIGNhc2VzIGFuZCB0aGUg cGFydGlhbAppbml0aWFsaXplcnMgKGV2ZW4gd2l0aCBwYWRkaW5nKToKCnRlc3Rfc3RhY2tpbml0 OiB1OF96ZXJvIG9rCnRlc3Rfc3RhY2tpbml0OiB1MTZfemVybyBvawp0ZXN0X3N0YWNraW5pdDog dTMyX3plcm8gb2sKdGVzdF9zdGFja2luaXQ6IHU2NF96ZXJvIG9rCnRlc3Rfc3RhY2tpbml0OiBj aGFyX2FycmF5X3plcm8gb2sKdGVzdF9zdGFja2luaXQ6IHNtYWxsX2hvbGVfemVybyBvawp0ZXN0 X3N0YWNraW5pdDogYmlnX2hvbGVfemVybyBvawp0ZXN0X3N0YWNraW5pdDogcGFja2VkX3plcm8g b2sKdGVzdF9zdGFja2luaXQ6IHNtYWxsX2hvbGVfZHluYW1pY19wYXJ0aWFsIG9rCnRlc3Rfc3Rh Y2tpbml0OiBiaWdfaG9sZV9keW5hbWljX3BhcnRpYWwgb2sKdGVzdF9zdGFja2luaXQ6IHBhY2tl ZF9zdGF0aWNfcGFydGlhbCBvawp0ZXN0X3N0YWNraW5pdDogc21hbGxfaG9sZV9zdGF0aWNfcGFy dGlhbCBvawp0ZXN0X3N0YWNraW5pdDogYmlnX2hvbGVfc3RhdGljX3BhcnRpYWwgb2sKClRoZSBy ZXN1bHRzIG9mIHRoZSBvdGhlciB0ZXN0cyAod2hpY2ggY29udGFpbiBubyBleHBsaWNpdCBpbml0 aWFsaXphdGlvbiksCmNoYW5nZSBiYXNlZCBvbiB0aGUgYnVpbGQncyBjb25maWd1cmVkIGNvbXBp bGVyIGluc3RydW1lbnRhdGlvbi4KCk5vIG9wdGlvbnM6Cgp0ZXN0X3N0YWNraW5pdDogc21hbGxf aG9sZV9zdGF0aWNfYWxsIEZBSUwgKHVuaW5pdCBieXRlczogMykKdGVzdF9zdGFja2luaXQ6IGJp Z19ob2xlX3N0YXRpY19hbGwgRkFJTCAodW5pbml0IGJ5dGVzOiA2MSkKdGVzdF9zdGFja2luaXQ6 IHNtYWxsX2hvbGVfZHluYW1pY19hbGwgRkFJTCAodW5pbml0IGJ5dGVzOiAzKQp0ZXN0X3N0YWNr aW5pdDogYmlnX2hvbGVfZHluYW1pY19hbGwgRkFJTCAodW5pbml0IGJ5dGVzOiA2MSkKdGVzdF9z dGFja2luaXQ6IHNtYWxsX2hvbGVfcnVudGltZV9wYXJ0aWFsIEZBSUwgKHVuaW5pdCBieXRlczog MjMpCnRlc3Rfc3RhY2tpbml0OiBiaWdfaG9sZV9ydW50aW1lX3BhcnRpYWwgRkFJTCAodW5pbml0 IGJ5dGVzOiAxMjcpCnRlc3Rfc3RhY2tpbml0OiBzbWFsbF9ob2xlX3J1bnRpbWVfYWxsIEZBSUwg KHVuaW5pdCBieXRlczogMykKdGVzdF9zdGFja2luaXQ6IGJpZ19ob2xlX3J1bnRpbWVfYWxsIEZB SUwgKHVuaW5pdCBieXRlczogNjEpCnRlc3Rfc3RhY2tpbml0OiB1OCBGQUlMICh1bmluaXQgYnl0 ZXM6IDEpCnRlc3Rfc3RhY2tpbml0OiB1MTYgRkFJTCAodW5pbml0IGJ5dGVzOiAyKQp0ZXN0X3N0 YWNraW5pdDogdTMyIEZBSUwgKHVuaW5pdCBieXRlczogNCkKdGVzdF9zdGFja2luaXQ6IHU2NCBG QUlMICh1bmluaXQgYnl0ZXM6IDgpCnRlc3Rfc3RhY2tpbml0OiBjaGFyX2FycmF5IEZBSUwgKHVu aW5pdCBieXRlczogMTYpCnRlc3Rfc3RhY2tpbml0OiBzbWFsbF9ob2xlIEZBSUwgKHVuaW5pdCBi eXRlczogMjQpCnRlc3Rfc3RhY2tpbml0OiBiaWdfaG9sZSBGQUlMICh1bmluaXQgYnl0ZXM6IDEy OCkKdGVzdF9zdGFja2luaXQ6IHVzZXIgRkFJTCAodW5pbml0IGJ5dGVzOiAzMikKdGVzdF9zdGFj a2luaXQ6IGZhaWx1cmVzOiAxNgoKQ09ORklHX0dDQ19QTFVHSU5fU1RSVUNUTEVBSz15ClRoaXMg b25seSB0cmllcyB0byBpbml0aWFsaXplIHN0cnVjdHMgd2l0aCBfX3VzZXIgbWFya2luZ3M6Cgp0 ZXN0X3N0YWNraW5pdDogc21hbGxfaG9sZV9zdGF0aWNfYWxsIEZBSUwgKHVuaW5pdCBieXRlczog MykKdGVzdF9zdGFja2luaXQ6IGJpZ19ob2xlX3N0YXRpY19hbGwgRkFJTCAodW5pbml0IGJ5dGVz OiA2MSkKdGVzdF9zdGFja2luaXQ6IHNtYWxsX2hvbGVfZHluYW1pY19hbGwgRkFJTCAodW5pbml0 IGJ5dGVzOiAzKQp0ZXN0X3N0YWNraW5pdDogYmlnX2hvbGVfZHluYW1pY19hbGwgRkFJTCAodW5p bml0IGJ5dGVzOiA2MSkKdGVzdF9zdGFja2luaXQ6IHNtYWxsX2hvbGVfcnVudGltZV9wYXJ0aWFs IEZBSUwgKHVuaW5pdCBieXRlczogMjMpCnRlc3Rfc3RhY2tpbml0OiBiaWdfaG9sZV9ydW50aW1l X3BhcnRpYWwgRkFJTCAodW5pbml0IGJ5dGVzOiAxMjcpCnRlc3Rfc3RhY2tpbml0OiBzbWFsbF9o b2xlX3J1bnRpbWVfYWxsIEZBSUwgKHVuaW5pdCBieXRlczogMykKdGVzdF9zdGFja2luaXQ6IGJp Z19ob2xlX3J1bnRpbWVfYWxsIEZBSUwgKHVuaW5pdCBieXRlczogNjEpCnRlc3Rfc3RhY2tpbml0 OiB1OCBGQUlMICh1bmluaXQgYnl0ZXM6IDEpCnRlc3Rfc3RhY2tpbml0OiB1MTYgRkFJTCAodW5p bml0IGJ5dGVzOiAyKQp0ZXN0X3N0YWNraW5pdDogdTMyIEZBSUwgKHVuaW5pdCBieXRlczogNCkK dGVzdF9zdGFja2luaXQ6IHU2NCBGQUlMICh1bmluaXQgYnl0ZXM6IDgpCnRlc3Rfc3RhY2tpbml0 OiBjaGFyX2FycmF5IEZBSUwgKHVuaW5pdCBieXRlczogMTYpCnRlc3Rfc3RhY2tpbml0OiBzbWFs bF9ob2xlIEZBSUwgKHVuaW5pdCBieXRlczogMjQpCnRlc3Rfc3RhY2tpbml0OiBiaWdfaG9sZSBG QUlMICh1bmluaXQgYnl0ZXM6IDEyOCkKdGVzdF9zdGFja2luaXQ6IHVzZXIgb2sKdGVzdF9zdGFj a2luaXQ6IGZhaWx1cmVzOiAxNQoKQ09ORklHX0dDQ19QTFVHSU5fU1RSVUNUTEVBSz15CkNPTkZJ R19HQ0NfUExVR0lOX1NUUlVDVExFQUtfQllSRUZfQUxMPXkKVGhpcyBpbml0aWFsaXplcyBhbGwg c3RydWN0dXJlcyBwYXNzZWQgYnkgcmVmZXJlbmNlIChzY2FsYXJzIGFuZCBzdHJpbmdzCnJlbWFp biB1bmluaXRpYWxpemVkLCBidXQgcGFkZGluZyBpcyB3aXBlZCk6Cgp0ZXN0X3N0YWNraW5pdDog c21hbGxfaG9sZV9zdGF0aWNfYWxsIG9rCnRlc3Rfc3RhY2tpbml0OiBiaWdfaG9sZV9zdGF0aWNf YWxsIG9rCnRlc3Rfc3RhY2tpbml0OiBzbWFsbF9ob2xlX2R5bmFtaWNfYWxsIG9rCnRlc3Rfc3Rh Y2tpbml0OiBiaWdfaG9sZV9keW5hbWljX2FsbCBvawp0ZXN0X3N0YWNraW5pdDogc21hbGxfaG9s ZV9ydW50aW1lX3BhcnRpYWwgb2sKdGVzdF9zdGFja2luaXQ6IGJpZ19ob2xlX3J1bnRpbWVfcGFy dGlhbCBvawp0ZXN0X3N0YWNraW5pdDogc21hbGxfaG9sZV9ydW50aW1lX2FsbCBvawp0ZXN0X3N0 YWNraW5pdDogYmlnX2hvbGVfcnVudGltZV9hbGwgb2sKdGVzdF9zdGFja2luaXQ6IHU4IEZBSUwg KHVuaW5pdCBieXRlczogMSkKdGVzdF9zdGFja2luaXQ6IHUxNiBGQUlMICh1bmluaXQgYnl0ZXM6 IDIpCnRlc3Rfc3RhY2tpbml0OiB1MzIgRkFJTCAodW5pbml0IGJ5dGVzOiA0KQp0ZXN0X3N0YWNr aW5pdDogdTY0IEZBSUwgKHVuaW5pdCBieXRlczogOCkKdGVzdF9zdGFja2luaXQ6IGNoYXJfYXJy YXkgRkFJTCAodW5pbml0IGJ5dGVzOiAxNikKdGVzdF9zdGFja2luaXQ6IHNtYWxsX2hvbGUgb2sK dGVzdF9zdGFja2luaXQ6IGJpZ19ob2xlIG9rCnRlc3Rfc3RhY2tpbml0OiB1c2VyIG9rCnRlc3Rf c3RhY2tpbml0OiBmYWlsdXJlczogNQoKQ09ORklHX0dDQ19QTFVHSU5fU1RBQ0tJTklUPXkKVGhp cyBpbml0aWFsaXplcyBhbGwgdmFyaWFibGVzLCBidXQgaGFzIG5vIHNwZWNpYWwgcGFkZGluZyBo YW5kbGluZzoKCnRlc3Rfc3RhY2tpbml0OiBzbWFsbF9ob2xlX3N0YXRpY19hbGwgRkFJTCAodW5p bml0IGJ5dGVzOiAzKQp0ZXN0X3N0YWNraW5pdDogYmlnX2hvbGVfc3RhdGljX2FsbCBGQUlMICh1 bmluaXQgYnl0ZXM6IDYxKQp0ZXN0X3N0YWNraW5pdDogc21hbGxfaG9sZV9keW5hbWljX2FsbCBG QUlMICh1bmluaXQgYnl0ZXM6IDMpCnRlc3Rfc3RhY2tpbml0OiBiaWdfaG9sZV9keW5hbWljX2Fs bCBGQUlMICh1bmluaXQgYnl0ZXM6IDYxKQp0ZXN0X3N0YWNraW5pdDogc21hbGxfaG9sZV9ydW50 aW1lX3BhcnRpYWwgb2sKdGVzdF9zdGFja2luaXQ6IGJpZ19ob2xlX3J1bnRpbWVfcGFydGlhbCBv awp0ZXN0X3N0YWNraW5pdDogc21hbGxfaG9sZV9ydW50aW1lX2FsbCBvawp0ZXN0X3N0YWNraW5p dDogYmlnX2hvbGVfcnVudGltZV9hbGwgb2sKdGVzdF9zdGFja2luaXQ6IHU4IG9rCnRlc3Rfc3Rh Y2tpbml0OiB1MTYgb2sKdGVzdF9zdGFja2luaXQ6IHUzMiBvawp0ZXN0X3N0YWNraW5pdDogdTY0 IG9rCnRlc3Rfc3RhY2tpbml0OiBjaGFyX2FycmF5IG9rCnRlc3Rfc3RhY2tpbml0OiBzbWFsbF9o b2xlIG9rCnRlc3Rfc3RhY2tpbml0OiBiaWdfaG9sZSBvawp0ZXN0X3N0YWNraW5pdDogdXNlciBv awp0ZXN0X3N0YWNraW5pdDogZmFpbHVyZXM6IDQKClNpZ25lZC1vZmYtYnk6IEtlZXMgQ29vayA8 a2Vlc2Nvb2tAY2hyb21pdW0ub3JnPgotLS0KIGxpYi9LY29uZmlnLmRlYnVnICAgIHwgICA5ICsr CiBsaWIvTWFrZWZpbGUgICAgICAgICB8ICAgMSArCiBsaWIvdGVzdF9zdGFja2luaXQuYyB8IDMy NyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAzIGZpbGVzIGNo YW5nZWQsIDMzNyBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgbGliL3Rlc3Rfc3Rh Y2tpbml0LmMKCmRpZmYgLS1naXQgYS9saWIvS2NvbmZpZy5kZWJ1ZyBiL2xpYi9LY29uZmlnLmRl YnVnCmluZGV4IGQ0ZGY1YjI0ZDc1ZS4uMDk3ODhhZmNjY2M5IDEwMDY0NAotLS0gYS9saWIvS2Nv bmZpZy5kZWJ1ZworKysgYi9saWIvS2NvbmZpZy5kZWJ1ZwpAQCAtMjAwMSw2ICsyMDAxLDE1IEBA IGNvbmZpZyBURVNUX09CSkFHRwogCiAJICBJZiB1bnN1cmUsIHNheSBOLgogCitjb25maWcgVEVT VF9TVEFDS0lOSVQKKwl0cmlzdGF0ZSAiVGVzdCBsZXZlbCBvZiBzdGFjayB2YXJpYWJsZSBpbml0 aWFsaXphdGlvbiIKKwloZWxwCisJICBUZXN0IGlmIHRoZSBrZXJuZWwgaXMgemVyby1pbml0aWFs aXppbmcgc3RhY2sgdmFyaWFibGVzCisJICBmcm9tIENPTkZJR19HQ0NfUExVR0lOX1NUQUNLSU5J VCwgQ09ORklHX0dDQ19QTFVHSU5fU1RSVUNUTEVBSywKKwkgIGFuZC9vciBHQ0NfUExVR0lOX1NU UlVDVExFQUtfQllSRUZfQUxMLgorCisJICBJZiB1bnN1cmUsIHNheSBOLgorCiBlbmRpZiAjIFJV TlRJTUVfVEVTVElOR19NRU5VCiAKIGNvbmZpZyBNRU1URVNUCmRpZmYgLS1naXQgYS9saWIvTWFr ZWZpbGUgYi9saWIvTWFrZWZpbGUKaW5kZXggZTFiNTlkYTcxNDE4Li5jODFhNjZkNGQwMGQgMTAw NjQ0Ci0tLSBhL2xpYi9NYWtlZmlsZQorKysgYi9saWIvTWFrZWZpbGUKQEAgLTc2LDYgKzc2LDcg QEAgb2JqLSQoQ09ORklHX1RFU1RfS01PRCkgKz0gdGVzdF9rbW9kLm8KIG9iai0kKENPTkZJR19U RVNUX0RFQlVHX1ZJUlRVQUwpICs9IHRlc3RfZGVidWdfdmlydHVhbC5vCiBvYmotJChDT05GSUdf VEVTVF9NRU1DQVRfUCkgKz0gdGVzdF9tZW1jYXRfcC5vCiBvYmotJChDT05GSUdfVEVTVF9PQkpB R0cpICs9IHRlc3Rfb2JqYWdnLm8KK29iai0kKENPTkZJR19URVNUX1NUQUNLSU5JVCkgKz0gdGVz dF9zdGFja2luaXQubwogCiBpZmVxICgkKENPTkZJR19ERUJVR19LT0JKRUNUKSx5KQogQ0ZMQUdT X2tvYmplY3QubyArPSAtRERFQlVHCmRpZmYgLS1naXQgYS9saWIvdGVzdF9zdGFja2luaXQuYyBi L2xpYi90ZXN0X3N0YWNraW5pdC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMC4uZTJmZjU2YTEwMDJhCi0tLSAvZGV2L251bGwKKysrIGIvbGliL3Rlc3Rfc3RhY2tpbml0 LmMKQEAgLTAsMCArMSwzMjcgQEAKKy8vIFNQRFgtTGljZW5zZXM6IEdQTHYyCisvKgorICogVGVz dCBjYXNlcyBmb3IgLWZpbml0LWxvY2FsLXZhcnMgYW5kIENPTkZJR19HQ0NfUExVR0lOX1NUQUNL SU5JVC4KKyAqLworI2RlZmluZSBwcl9mbXQoZm10KSBLQlVJTERfTU9ETkFNRSAiOiAiIGZtdAor CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2lu Y2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgorCisvKiBF eGZpbHRyYXRpb24gYnVmZmVyLiAqLworI2RlZmluZSBNQVhfVkFSX1NJWkUJMTI4CitzdGF0aWMg Y2hhciBjaGVja19idWZbTUFYX1ZBUl9TSVpFXTsKKworLyogQ2hhcmFjdGVyIGFycmF5IHRvIHRy aWdnZXIgc3RhY2sgcHJvdGVjdG9yIGluIGFsbCBmdW5jdGlvbnMuICovCisjZGVmaW5lIFZBUl9C VUZGRVIJIDMyCisKKy8qIFZvbGF0aWxlIG1hc2sgdG8gY29udmluY2UgY29tcGlsZXIgdG8gY29w eSBtZW1vcnkgd2l0aCAweGZmLiAqLworc3RhdGljIHZvbGF0aWxlIHU4IGZvcmNlZF9tYXNrID0g MHhmZjsKKworLyogTG9jYXRpb24gYW5kIHNpemUgdHJhY2tpbmcgdG8gdmFsaWRhdGUgZmlsbCBh bmQgdGVzdCBhcmUgY29sb2NhdGVkLiAqLworc3RhdGljIHZvaWQgKmZpbGxfc3RhcnQsICp0YXJn ZXRfc3RhcnQ7CitzdGF0aWMgc2l6ZV90IGZpbGxfc2l6ZSwgdGFyZ2V0X3NpemU7CisKK3N0YXRp YyBib29sIHJhbmdlX2NvbnRhaW5zKGNoYXIgKmhheXN0YWNrX3N0YXJ0LCBzaXplX3QgaGF5c3Rh Y2tfc2l6ZSwKKwkJCSAgIGNoYXIgKm5lZWRsZV9zdGFydCwgc2l6ZV90IG5lZWRsZV9zaXplKQor eworCWlmIChuZWVkbGVfc3RhcnQgPj0gaGF5c3RhY2tfc3RhcnQgJiYKKwkgICAgbmVlZGxlX3N0 YXJ0ICsgbmVlZGxlX3NpemUgPD0gaGF5c3RhY2tfc3RhcnQgKyBoYXlzdGFja19zaXplKQorCQly ZXR1cm4gdHJ1ZTsKKwlyZXR1cm4gZmFsc2U7Cit9CisKKyNkZWZpbmUgRE9fTk9USElOR19UWVBF X1NDQUxBUih2YXJfdHlwZSkJdmFyX3R5cGUKKyNkZWZpbmUgRE9fTk9USElOR19UWVBFX1NUUklO Ryh2YXJfdHlwZSkJdm9pZAorI2RlZmluZSBET19OT1RISU5HX1RZUEVfU1RSVUNUKHZhcl90eXBl KQl2b2lkCisKKyNkZWZpbmUgRE9fTk9USElOR19SRVRVUk5fU0NBTEFSKHB0cikJCSoocHRyKQor I2RlZmluZSBET19OT1RISU5HX1JFVFVSTl9TVFJJTkcocHRyKQkJLyoqLworI2RlZmluZSBET19O T1RISU5HX1JFVFVSTl9TVFJVQ1QocHRyKQkJLyoqLworCisjZGVmaW5lIERPX05PVEhJTkdfQ0FM TF9TQ0FMQVIodmFyLCBuYW1lKQkJCVwKKwkJKHZhcikgPSBkb19ub3RoaW5nXyAjIyBuYW1lKCYo dmFyKSkKKyNkZWZpbmUgRE9fTk9USElOR19DQUxMX1NUUklORyh2YXIsIG5hbWUpCQkJXAorCQlk b19ub3RoaW5nXyAjIyBuYW1lKHZhcikKKyNkZWZpbmUgRE9fTk9USElOR19DQUxMX1NUUlVDVCh2 YXIsIG5hbWUpCQkJXAorCQlkb19ub3RoaW5nXyAjIyBuYW1lKCYodmFyKSkKKworI2RlZmluZSBG RVRDSF9BUkdfU0NBTEFSKHZhcikJCSZ2YXIKKyNkZWZpbmUgRkVUQ0hfQVJHX1NUUklORyh2YXIp CQl2YXIKKyNkZWZpbmUgRkVUQ0hfQVJHX1NUUlVDVCh2YXIpCQkmdmFyCisKKyNkZWZpbmUgRklM TF9TSVpFX1NDQUxBUgkJMQorI2RlZmluZSBGSUxMX1NJWkVfU1RSSU5HCQkxNgorI2RlZmluZSBG SUxMX1NJWkVfU1RSVUNUCQkxCisKKyNkZWZpbmUgSU5JVF9DTE9ORV9TQ0FMQVIJCS8qKi8KKyNk ZWZpbmUgSU5JVF9DTE9ORV9TVFJJTkcJCVtGSUxMX1NJWkVfU1RSSU5HXQorI2RlZmluZSBJTklU X0NMT05FX1NUUlVDVAkJLyoqLworCisjZGVmaW5lIElOSVRfU0NBTEFSX05PTkUJCS8qKi8KKyNk ZWZpbmUgSU5JVF9TQ0FMQVJfWkVSTwkJPSAwCisKKyNkZWZpbmUgSU5JVF9TVFJJTkdfTk9ORQkJ W0ZJTExfU0laRV9TVFJJTkddIC8qKi8KKyNkZWZpbmUgSU5JVF9TVFJJTkdfWkVSTwkJW0ZJTExf U0laRV9TVFJJTkddID0geyB9CisKKyNkZWZpbmUgSU5JVF9TVFJVQ1RfTk9ORQkJLyoqLworI2Rl ZmluZSBJTklUX1NUUlVDVF9aRVJPCQk9IHsgfQorI2RlZmluZSBJTklUX1NUUlVDVF9TVEFUSUNf UEFSVElBTAk9IHsgLnR3byA9IDAsIH0KKyNkZWZpbmUgSU5JVF9TVFJVQ1RfU1RBVElDX0FMTAkJ PSB7IC5vbmUgPSBhcmctPm9uZSwJCVwKKwkJCQkJICAgIC50d28gPSBhcmctPnR3bywJCVwKKwkJ CQkJICAgIC50aHJlZSA9IGFyZy0+dGhyZWUsCVwKKwkJCQkJICAgIC5mb3VyID0gYXJnLT5mb3Vy LAkJXAorCQkJCQl9CisjZGVmaW5lIElOSVRfU1RSVUNUX0RZTkFNSUNfUEFSVElBTAk9IHsgLnR3 byA9IGFyZy0+dHdvLCB9CisjZGVmaW5lIElOSVRfU1RSVUNUX0RZTkFNSUNfQUxMCQk9IHsgLm9u ZSA9IGFyZy0+b25lLAkJXAorCQkJCQkgICAgLnR3byA9IGFyZy0+dHdvLAkJXAorCQkJCQkgICAg LnRocmVlID0gYXJnLT50aHJlZSwJXAorCQkJCQkgICAgLmZvdXIgPSBhcmctPmZvdXIsCQlcCisJ CQkJCX0KKyNkZWZpbmUgSU5JVF9TVFJVQ1RfUlVOVElNRV9QQVJUSUFMCTsJCQkJXAorCQkJCQl2 YXIudHdvID0gMAorI2RlZmluZSBJTklUX1NUUlVDVF9SVU5USU1FX0FMTAkJOwkJCQlcCisJCQkJ CXZhci5vbmUgPSAwOwkJCVwKKwkJCQkJdmFyLnR3byA9IDA7CQkJXAorCQkJCQl2YXIudGhyZWUg PSAwOwkJCVwKKwkJCQkJbWVtc2V0KCZ2YXIuZm91ciwgMCwJCVwKKwkJCQkJICAgICAgIHNpemVv Zih2YXIuZm91cikpCisKKy8qCisgKiBAbmFtZTogdW5pcXVlIHN0cmluZyBuYW1lIGZvciB0aGUg dGVzdAorICogQHZhcl90eXBlOiB0eXBlIHRvIGJlIHRlc3RlZCBmb3IgemVyb2luZyBpbml0aWFs aXphdGlvbgorICogQHdoaWNoOiBpcyB0aGlzIGEgU0NBTEFSIG9yIGEgU1RSVUNUIHR5cGU/Cisg KiBAaW5pdF9sZXZlbDogd2hhdCBraW5kIG9mIGluaXRpYWxpemF0aW9uIGlzIHBlcmZvcm1lZAor ICovCisjZGVmaW5lIERFRklORV9URVNUKG5hbWUsIHZhcl90eXBlLCB3aGljaCwgaW5pdF9sZXZl bCkJCVwKK3N0YXRpYyBub2lubGluZSBpbnQgZmlsbF8gIyMgbmFtZSh1bnNpZ25lZCBsb25nIHNw KQkJXAorewkJCQkJCQkJXAorCWNoYXIgYnVmW1ZBUl9CVUZGRVIgKwkJCQkJXAorCQkgc2l6ZW9m KHZhcl90eXBlKSAqIEZJTExfU0laRV8gIyMgd2hpY2ggKiA0XTsJXAorCQkJCQkJCQlcCisJZmls bF9zdGFydCA9IGJ1ZjsJCQkJCVwKKwlmaWxsX3NpemUgPSBzaXplb2YoYnVmKTsJCQkJXAorCS8q IEZpbGwgdmFyaWFibGUgd2l0aCAweEZGLiAqLwkJCQlcCisJbWVtc2V0KGZpbGxfc3RhcnQsIChj aGFyKSgoc3AgJiYgMHhmZikgfCBmb3JjZWRfbWFzayksCVwKKwkgICAgICAgZmlsbF9zaXplKTsJ CQkJCVwKKwkJCQkJCQkJXAorCXJldHVybiAoaW50KWJ1ZlswXSB8IChpbnQpYnVmW3NpemVvZihi dWYpLTFdOwkJXAorfQkJCQkJCQkJXAorLyogbm8tb3AgdG8gZm9yY2UgY29tcGlsZXIgaW50byBp Z25vcmluZyAidW5pbml0aWFsaXplZCIgdmFycyAqL1wKK3N0YXRpYyBub2lubGluZSBET19OT1RI SU5HX1RZUEVfICMjIHdoaWNoKHZhcl90eXBlKQkJXAorZG9fbm90aGluZ18gIyMgbmFtZSh2YXJf dHlwZSAqcHRyKQkJCQlcCit7CQkJCQkJCQlcCisJLyogV2lsbCBhbHdheXMgYmUgdHJ1ZSwgYnV0 IGNvbXBpbGVyIGRvZXNuJ3Qga25vdy4gKi8JXAorCWlmICgodW5zaWduZWQgbG9uZylwdHIgPiAw eDIpCQkJCVwKKwkJcmV0dXJuIERPX05PVEhJTkdfUkVUVVJOXyAjIyB3aGljaChwdHIpOwlcCisJ ZWxzZQkJCQkJCQlcCisJCXJldHVybiBET19OT1RISU5HX1JFVFVSTl8gIyMgd2hpY2gocHRyICsg MSk7CVwKK30JCQkJCQkJCVwKK3N0YXRpYyBub2lubGluZSBpbnQgZmV0Y2hfICMjIG5hbWUodW5z aWduZWQgbG9uZyBzcCwJCVwKKwkJCQkgICB2YXJfdHlwZSAqYXJnKQkJXAorewkJCQkJCQkJXAor CWNoYXIgYnVmW1ZBUl9CVUZGRVJdOwkJCQkJXAorCXZhcl90eXBlIHZhciBJTklUXyAjIyB3aGlj aCAjIyBfICMjIGluaXRfbGV2ZWw7CQlcCisJCQkJCQkJCVwKKwl0YXJnZXRfc3RhcnQgPSAmdmFy OwkJCQkJXAorCXRhcmdldF9zaXplID0gc2l6ZW9mKHZhcik7CQkJCVwKKwkvKgkJCQkJCQlcCisJ ICogS2VlcCB0aGlzIGJ1ZmZlciBhcm91bmQgdG8gbWFrZSBzdXJlIHdlJ3ZlIGdvdCBhCVwKKwkg KiBzdGFjayBmcmFtZSBvZiBTT01FIGtpbmQuLi4JCQkJXAorCSAqLwkJCQkJCQlcCisJbWVtc2V0 KGJ1ZiwgKGNoYXIpKHNwICYmIDB4ZmYpLCBzaXplb2YoYnVmKSk7CQlcCisJCQkJCQkJCVwKKwkv KiBTaWxlbmNlICJuZXZlciBpbml0aWFsaXplZCIgd2FybmluZ3MuICovCQlcCisJRE9fTk9USElO R19DQUxMXyAjIyB3aGljaCh2YXIsIG5hbWUpOwkJCVwKKwkJCQkJCQkJXAorCS8qIEV4ZmlsdHJh dGUgInZhciIgb3IgZmllbGQgb2YgInZhciIuICovCQlcCisJbWVtY3B5KGNoZWNrX2J1ZiwgdGFy Z2V0X3N0YXJ0LCB0YXJnZXRfc2l6ZSk7CQlcCisJCQkJCQkJCVwKKwlyZXR1cm4gKGludClidWZb MF0gfCAoaW50KWJ1ZltzaXplb2YoYnVmKSAtIDFdOwkJXAorfQkJCQkJCQkJXAorLyogUmV0dXJu cyAwIG9uIHN1Y2Nlc3MsIDEgb24gZmFpbHVyZS4gKi8JCQlcCitzdGF0aWMgbm9pbmxpbmUgaW50 IHRlc3RfICMjIG5hbWUgKHZvaWQpCQkJXAorewkJCQkJCQkJXAorCXZhcl90eXBlIHplcm8gSU5J VF9DTE9ORV8gIyMgd2hpY2g7CQkJXAorCWludCBpZ25vcmVkOwkJCQkJCVwKKwl1OCBzdW0gPSAw LCBpOwkJCQkJCVwKKwkJCQkJCQkJXAorCS8qIE5vdGljZSB3aGVuIGEgbmV3IHRlc3QgaXMgbGFy Z2VyIHRoYW4gZXhwZWN0ZWQuICovCVwKKwlCVUlMRF9CVUdfT04oc2l6ZW9mKHplcm8pID4gTUFY X1ZBUl9TSVpFKTsJCVwKKwkvKiBDbGVhciBlbnRpcmUgY2hlY2sgYnVmZmVyIGZvciBsYXRlciBi aXQgdGVzdHMuICovCVwKKwltZW1zZXQoY2hlY2tfYnVmLCAweDAwLCBzaXplb2YoY2hlY2tfYnVm KSk7CQlcCisJCQkJCQkJCVwKKwkvKiBGaWxsIGNsb25lIHR5cGUgd2l0aCB6ZXJvIGZvciBwZXIt ZmllbGQgaW5pdC4gKi8JXAorCW1lbXNldCgmemVybywgMHgwMCwgc2l6ZW9mKHplcm8pKTsJCQlc CisJLyogRmlsbCBzdGFjayB3aXRoIDB4RkYuICovCQkJCVwKKwlpZ25vcmVkID0gZmlsbF8gIyNu YW1lKCh1bnNpZ25lZCBsb25nKSZpZ25vcmVkKTsJXAorCS8qIEV4dHJhY3Qgc3RhY2stZGVmaW5l ZCB2YXJpYWJsZSBjb250ZW50cy4gKi8JCVwKKwlpZ25vcmVkID0gZmV0Y2hfICMjbmFtZSgodW5z aWduZWQgbG9uZykmaWdub3JlZCwJXAorCQkJCUZFVENIX0FSR18gIyMgd2hpY2goemVybykpOwlc CisJCQkJCQkJCVwKKwkvKiBWYWxpZGF0ZSB0aGF0IGNvbXBpbGVyIGxpbmVkIHVwIGZpbGwgYW5k IHRhcmdldC4gKi8JXAorCWlmICghcmFuZ2VfY29udGFpbnMoZmlsbF9zdGFydCwgZmlsbF9zaXpl LAkJXAorCQkJICAgIHRhcmdldF9zdGFydCwgdGFyZ2V0X3NpemUpKSB7CVwKKwkJcHJfZXJyKCNu YW1lICI6IHN0YWNrIGZpbGwgbWlzc2VkIHRhcmdldCE/XG4iKTsJXAorCQlwcl9lcnIoI25hbWUg IjogZmlsbCAlenUgd2lkZVxuIiwgZmlsbF9zaXplKTsJXAorCQlwcl9lcnIoI25hbWUgIjogdGFy Z2V0IG9mZnNldCBieSAlbGRcbiIsCVwKKwkJCShzc2l6ZV90KSh1aW50cHRyX3QpZmlsbF9zdGFy dCAtCVwKKwkJCShzc2l6ZV90KSh1aW50cHRyX3QpdGFyZ2V0X3N0YXJ0KTsJXAorCQlyZXR1cm4g MTsJCQkJCVwKKwl9CQkJCQkJCVwKKwkJCQkJCQkJXAorCS8qIExvb2sgZm9yIGFueSBzZXQgYml0 cyBpbiB0aGUgY2hlY2sgcmVnaW9uLiAqLwlcCisJZm9yIChpID0gMDsgaSA8IHNpemVvZihjaGVj a19idWYpOyBpKyspCQkJXAorCQlzdW0gKz0gKGNoZWNrX2J1ZltpXSAhPSAwKTsJCQlcCisJCQkJ CQkJCVwKKwlpZiAoc3VtID09IDApCQkJCQkJXAorCQlwcl9pbmZvKCNuYW1lICIgb2tcbiIpOwkJ CQlcCisJZWxzZQkJCQkJCQlcCisJCXByX3dhcm4oI25hbWUgIiBGQUlMICh1bmluaXQgYnl0ZXM6 ICVkKVxuIiwJXAorCQkJc3VtKTsJCQkJCVwKKwkJCQkJCQkJXAorCXJldHVybiAoc3VtICE9IDAp OwkJCQkJXAorfQorCisvKiBTdHJ1Y3R1cmUgd2l0aCBubyBwYWRkaW5nLiAqLworc3RydWN0IHRl c3RfcGFja2VkIHsKKwl1bnNpZ25lZCBsb25nIG9uZTsKKwl1bnNpZ25lZCBsb25nIHR3bzsKKwl1 bnNpZ25lZCBsb25nIHRocmVlOworCXVuc2lnbmVkIGxvbmcgZm91cjsKK307CisKKy8qIFNpbXBs ZSBzdHJ1Y3R1cmUgd2l0aCBwYWRkaW5nIGxpa2VseSB0byBiZSBjb3ZlcmVkIGJ5IGNvbXBpbGVy LiAqLworc3RydWN0IHRlc3Rfc21hbGxfaG9sZSB7CisJc2l6ZV90IG9uZTsKKwljaGFyIHR3bzsK KwkvKiAzIGJ5dGUgcGFkZGluZyBob2xlIGhlcmUuICovCisJaW50IHRocmVlOworCXVuc2lnbmVk IGxvbmcgZm91cjsKK307CisKKy8qIFRyeSB0byB0cmlnZ2VyIHVuaGFuZGxlZCBwYWRkaW5nIGlu IGEgc3RydWN0dXJlLiAqLworc3RydWN0IHRlc3RfYWxpZ25lZCB7CisJdTMyIGludGVybmFsMTsK Kwl1NjQgaW50ZXJuYWwyOworfSBfX2FsaWduZWQoNjQpOworCitzdHJ1Y3QgdGVzdF9iaWdfaG9s ZSB7CisJdTggb25lOworCXU4IHR3bzsKKwl1OCB0aHJlZTsKKwkvKiA2MSBieXRlIHBhZGRpbmcg aG9sZSBoZXJlLiAqLworCXN0cnVjdCB0ZXN0X2FsaWduZWQgZm91cjsKK30gX19hbGlnbmVkKDY0 KTsKKworLyogVGVzdCBpZiBTVFJVQ1RMRUFLIGlzIGNsZWFyaW5nIHN0cnVjdHMgd2l0aCBfX3Vz ZXIgZmllbGRzLiAqLworc3RydWN0IHRlc3RfdXNlciB7CisJdTggb25lOworCWNoYXIgX191c2Vy ICp0d287CisJdW5zaWduZWQgbG9uZyB0aHJlZTsKKwl1bnNpZ25lZCBsb25nIGZvdXI7Cit9Owor CisvKiBUaGVzZSBzaG91bGQgYmUgZnVsbHkgaW5pdGlhbGl6ZWQgYWxsIHRoZSB0aW1lISAqLwor REVGSU5FX1RFU1QodThfemVybywgdTgsIFNDQUxBUiwgWkVSTyk7CitERUZJTkVfVEVTVCh1MTZf emVybywgdTE2LCBTQ0FMQVIsIFpFUk8pOworREVGSU5FX1RFU1QodTMyX3plcm8sIHUzMiwgU0NB TEFSLCBaRVJPKTsKK0RFRklORV9URVNUKHU2NF96ZXJvLCB1NjQsIFNDQUxBUiwgWkVSTyk7CitE RUZJTkVfVEVTVChjaGFyX2FycmF5X3plcm8sIHVuc2lnbmVkIGNoYXIsIFNUUklORywgWkVSTyk7 CisKK0RFRklORV9URVNUKHBhY2tlZF96ZXJvLCBzdHJ1Y3QgdGVzdF9wYWNrZWQsIFNUUlVDVCwg WkVSTyk7CitERUZJTkVfVEVTVChzbWFsbF9ob2xlX3plcm8sIHN0cnVjdCB0ZXN0X3NtYWxsX2hv bGUsIFNUUlVDVCwgWkVSTyk7CitERUZJTkVfVEVTVChiaWdfaG9sZV96ZXJvLCBzdHJ1Y3QgdGVz dF9iaWdfaG9sZSwgU1RSVUNULCBaRVJPKTsKKworLyogU3RhdGljIGluaXRpYWxpemF0aW9uOiBw YWRkaW5nIG1heSBiZSBsZWZ0IHVuaW5pdGlhbGl6ZWQuICovCitERUZJTkVfVEVTVChwYWNrZWRf c3RhdGljX3BhcnRpYWwsIHN0cnVjdCB0ZXN0X3BhY2tlZCwgU1RSVUNULCBTVEFUSUNfUEFSVElB TCk7CitERUZJTkVfVEVTVChzbWFsbF9ob2xlX3N0YXRpY19wYXJ0aWFsLCBzdHJ1Y3QgdGVzdF9z bWFsbF9ob2xlLCBTVFJVQ1QsIFNUQVRJQ19QQVJUSUFMKTsKK0RFRklORV9URVNUKGJpZ19ob2xl X3N0YXRpY19wYXJ0aWFsLCBzdHJ1Y3QgdGVzdF9iaWdfaG9sZSwgU1RSVUNULCBTVEFUSUNfUEFS VElBTCk7CisKK0RFRklORV9URVNUKHNtYWxsX2hvbGVfc3RhdGljX2FsbCwgc3RydWN0IHRlc3Rf c21hbGxfaG9sZSwgU1RSVUNULCBTVEFUSUNfQUxMKTsKK0RFRklORV9URVNUKGJpZ19ob2xlX3N0 YXRpY19hbGwsIHN0cnVjdCB0ZXN0X2JpZ19ob2xlLCBTVFJVQ1QsIFNUQVRJQ19BTEwpOworCisv KiBEeW5hbWljIGluaXRpYWxpemF0aW9uOiBwYWRkaW5nIG1heSBiZSBsZWZ0IHVuaW5pdGlhbGl6 ZWQuICovCitERUZJTkVfVEVTVChzbWFsbF9ob2xlX2R5bmFtaWNfcGFydGlhbCwgc3RydWN0IHRl c3Rfc21hbGxfaG9sZSwgU1RSVUNULCBEWU5BTUlDX1BBUlRJQUwpOworREVGSU5FX1RFU1QoYmln X2hvbGVfZHluYW1pY19wYXJ0aWFsLCBzdHJ1Y3QgdGVzdF9iaWdfaG9sZSwgU1RSVUNULCBEWU5B TUlDX1BBUlRJQUwpOworCitERUZJTkVfVEVTVChzbWFsbF9ob2xlX2R5bmFtaWNfYWxsLCBzdHJ1 Y3QgdGVzdF9zbWFsbF9ob2xlLCBTVFJVQ1QsIERZTkFNSUNfQUxMKTsKK0RFRklORV9URVNUKGJp Z19ob2xlX2R5bmFtaWNfYWxsLCBzdHJ1Y3QgdGVzdF9iaWdfaG9sZSwgU1RSVUNULCBEWU5BTUlD X0FMTCk7CisKKy8qIFJ1bnRpbWUgaW5pdGlhbGl6YXRpb246IHBhZGRpbmcgbWF5IGJlIGxlZnQg dW5pbml0aWFsaXplZC4gKi8KK0RFRklORV9URVNUKHNtYWxsX2hvbGVfcnVudGltZV9wYXJ0aWFs LCBzdHJ1Y3QgdGVzdF9zbWFsbF9ob2xlLCBTVFJVQ1QsIFJVTlRJTUVfUEFSVElBTCk7CitERUZJ TkVfVEVTVChiaWdfaG9sZV9ydW50aW1lX3BhcnRpYWwsIHN0cnVjdCB0ZXN0X2JpZ19ob2xlLCBT VFJVQ1QsIFJVTlRJTUVfUEFSVElBTCk7CisKK0RFRklORV9URVNUKHNtYWxsX2hvbGVfcnVudGlt ZV9hbGwsIHN0cnVjdCB0ZXN0X3NtYWxsX2hvbGUsIFNUUlVDVCwgUlVOVElNRV9BTEwpOworREVG SU5FX1RFU1QoYmlnX2hvbGVfcnVudGltZV9hbGwsIHN0cnVjdCB0ZXN0X2JpZ19ob2xlLCBTVFJV Q1QsIFJVTlRJTUVfQUxMKTsKKworLyogTm8gaW5pdGlhbGl6YXRpb24gd2l0aG91dCBjb21waWxl ciBpbnN0cnVtZW50YXRpb24uICovCitERUZJTkVfVEVTVCh1OCwgdTgsIFNDQUxBUiwgTk9ORSk7 CitERUZJTkVfVEVTVCh1MTYsIHUxNiwgU0NBTEFSLCBOT05FKTsKK0RFRklORV9URVNUKHUzMiwg dTMyLCBTQ0FMQVIsIE5PTkUpOworREVGSU5FX1RFU1QodTY0LCB1NjQsIFNDQUxBUiwgTk9ORSk7 CitERUZJTkVfVEVTVChjaGFyX2FycmF5LCB1bnNpZ25lZCBjaGFyLCBTVFJJTkcsIE5PTkUpOwor REVGSU5FX1RFU1Qoc21hbGxfaG9sZSwgc3RydWN0IHRlc3Rfc21hbGxfaG9sZSwgU1RSVUNULCBO T05FKTsKK0RFRklORV9URVNUKGJpZ19ob2xlLCBzdHJ1Y3QgdGVzdF9iaWdfaG9sZSwgU1RSVUNU LCBOT05FKTsKK0RFRklORV9URVNUKHVzZXIsIHN0cnVjdCB0ZXN0X3VzZXIsIFNUUlVDVCwgTk9O RSk7CisKK3N0YXRpYyBpbnQgX19pbml0IHRlc3Rfc3RhY2tpbml0X2luaXQodm9pZCkKK3sKKwl1 bnNpZ25lZCBpbnQgZmFpbHVyZXMgPSAwOworCisJLyogVGhlc2UgYXJlIGV4cGxpY2l0bHkgaW5p dGlhbGl6ZWQgYW5kIHNob3VsZCBhbHdheXMgcGFzcy4gKi8KKwlmYWlsdXJlcyArPSB0ZXN0X3U4 X3plcm8oKTsKKwlmYWlsdXJlcyArPSB0ZXN0X3UxNl96ZXJvKCk7CisJZmFpbHVyZXMgKz0gdGVz dF91MzJfemVybygpOworCWZhaWx1cmVzICs9IHRlc3RfdTY0X3plcm8oKTsKKwlmYWlsdXJlcyAr PSB0ZXN0X2NoYXJfYXJyYXlfemVybygpOworCWZhaWx1cmVzICs9IHRlc3Rfc21hbGxfaG9sZV96 ZXJvKCk7CisJZmFpbHVyZXMgKz0gdGVzdF9iaWdfaG9sZV96ZXJvKCk7CisJZmFpbHVyZXMgKz0g dGVzdF9wYWNrZWRfemVybygpOworCisJLyogUGFkZGluZyBoZXJlIGFwcGVhcnMgdG8gYmUgYWNj aWRlbnRhbGx5IGFsd2F5cyBpbml0aWFsaXplZC4gKi8KKwlmYWlsdXJlcyArPSB0ZXN0X3NtYWxs X2hvbGVfZHluYW1pY19wYXJ0aWFsKCk7CisJZmFpbHVyZXMgKz0gdGVzdF9iaWdfaG9sZV9keW5h bWljX3BhcnRpYWwoKTsKKwlmYWlsdXJlcyArPSB0ZXN0X3BhY2tlZF9zdGF0aWNfcGFydGlhbCgp OworCisJLyogUGFkZGluZyBpbml0aWFsaXphdGlvbiBkZXBlbmRzIG9uIGNvbXBpbGVyIGJlaGF2 aW9ycy4gKi8KKwlmYWlsdXJlcyArPSB0ZXN0X3NtYWxsX2hvbGVfc3RhdGljX3BhcnRpYWwoKTsK KwlmYWlsdXJlcyArPSB0ZXN0X2JpZ19ob2xlX3N0YXRpY19wYXJ0aWFsKCk7CisJZmFpbHVyZXMg Kz0gdGVzdF9zbWFsbF9ob2xlX3N0YXRpY19hbGwoKTsKKwlmYWlsdXJlcyArPSB0ZXN0X2JpZ19o b2xlX3N0YXRpY19hbGwoKTsKKwlmYWlsdXJlcyArPSB0ZXN0X3NtYWxsX2hvbGVfZHluYW1pY19h bGwoKTsKKwlmYWlsdXJlcyArPSB0ZXN0X2JpZ19ob2xlX2R5bmFtaWNfYWxsKCk7CisJZmFpbHVy ZXMgKz0gdGVzdF9zbWFsbF9ob2xlX3J1bnRpbWVfcGFydGlhbCgpOworCWZhaWx1cmVzICs9IHRl c3RfYmlnX2hvbGVfcnVudGltZV9wYXJ0aWFsKCk7CisJZmFpbHVyZXMgKz0gdGVzdF9zbWFsbF9o b2xlX3J1bnRpbWVfYWxsKCk7CisJZmFpbHVyZXMgKz0gdGVzdF9iaWdfaG9sZV9ydW50aW1lX2Fs bCgpOworCisJLyogU1RBQ0tJTklUIHNob3VsZCBjb3ZlciBldmVyeXRoaW5nIGZyb20gaGVyZSBk b3duLiAqLworCWZhaWx1cmVzICs9IHRlc3RfdTgoKTsKKwlmYWlsdXJlcyArPSB0ZXN0X3UxNigp OworCWZhaWx1cmVzICs9IHRlc3RfdTMyKCk7CisJZmFpbHVyZXMgKz0gdGVzdF91NjQoKTsKKwlm YWlsdXJlcyArPSB0ZXN0X2NoYXJfYXJyYXkoKTsKKworCS8qIFNUUlVDVExFQUtfQllSRUZfQUxM IHNob3VsZCBjb3ZlciBmcm9tIGhlcmUgZG93bi4gKi8KKwlmYWlsdXJlcyArPSB0ZXN0X3NtYWxs X2hvbGUoKTsKKwlmYWlsdXJlcyArPSB0ZXN0X2JpZ19ob2xlKCk7CisKKwkvKiBTVFJVQ1RMRUFL IHNob3VsZCBjb3ZlciB0aGlzLiAqLworCWZhaWx1cmVzICs9IHRlc3RfdXNlcigpOworCisJaWYg KGZhaWx1cmVzID09IDApCisJCXByX2luZm8oImFsbCB0ZXN0cyBwYXNzZWQhXG4iKTsKKwllbHNl CisJCXByX2VycigiZmFpbHVyZXM6ICV1XG4iLCBmYWlsdXJlcyk7CisKKwlyZXR1cm4gZmFpbHVy ZXMgPyAtRUlOVkFMIDogMDsKK30KK21vZHVsZV9pbml0KHRlc3Rfc3RhY2tpbml0X2luaXQpOwor CitzdGF0aWMgdm9pZCBfX2V4aXQgdGVzdF9zdGFja2luaXRfZXhpdCh2b2lkKQoreyB9Cittb2R1 bGVfZXhpdCh0ZXN0X3N0YWNraW5pdF9leGl0KTsKKworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwot LSAKMi4xNy4xCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f XwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcK aHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK From mboxrd@z Thu Jan 1 00:00:00 1970 From: Kees Cook Date: Wed, 23 Jan 2019 03:03:49 -0800 Subject: [Intel-wired-lan] [PATCH 3/3] lib: Introduce test_stackinit module In-Reply-To: <20190123110349.35882-1-keescook@chromium.org> References: <20190123110349.35882-1-keescook@chromium.org> Message-ID: <20190123110349.35882-4-keescook@chromium.org> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: intel-wired-lan@osuosl.org List-ID: Adds test for stack initialization coverage. We have several build options that control the level of stack variable initialization. This test lets us visualize which options cover which cases, and provide tests for options that are currently not available (padding initialization). All options pass the explicit initialization cases and the partial initializers (even with padding): test_stackinit: u8_zero ok test_stackinit: u16_zero ok test_stackinit: u32_zero ok test_stackinit: u64_zero ok test_stackinit: char_array_zero ok test_stackinit: small_hole_zero ok test_stackinit: big_hole_zero ok test_stackinit: packed_zero ok test_stackinit: small_hole_dynamic_partial ok test_stackinit: big_hole_dynamic_partial ok test_stackinit: packed_static_partial ok test_stackinit: small_hole_static_partial ok test_stackinit: big_hole_static_partial ok The results of the other tests (which contain no explicit initialization), change based on the build's configured compiler instrumentation. No options: test_stackinit: small_hole_static_all FAIL (uninit bytes: 3) test_stackinit: big_hole_static_all FAIL (uninit bytes: 61) test_stackinit: small_hole_dynamic_all FAIL (uninit bytes: 3) test_stackinit: big_hole_dynamic_all FAIL (uninit bytes: 61) test_stackinit: small_hole_runtime_partial FAIL (uninit bytes: 23) test_stackinit: big_hole_runtime_partial FAIL (uninit bytes: 127) test_stackinit: small_hole_runtime_all FAIL (uninit bytes: 3) test_stackinit: big_hole_runtime_all FAIL (uninit bytes: 61) test_stackinit: u8 FAIL (uninit bytes: 1) test_stackinit: u16 FAIL (uninit bytes: 2) test_stackinit: u32 FAIL (uninit bytes: 4) test_stackinit: u64 FAIL (uninit bytes: 8) test_stackinit: char_array FAIL (uninit bytes: 16) test_stackinit: small_hole FAIL (uninit bytes: 24) test_stackinit: big_hole FAIL (uninit bytes: 128) test_stackinit: user FAIL (uninit bytes: 32) test_stackinit: failures: 16 CONFIG_GCC_PLUGIN_STRUCTLEAK=y This only tries to initialize structs with __user markings: test_stackinit: small_hole_static_all FAIL (uninit bytes: 3) test_stackinit: big_hole_static_all FAIL (uninit bytes: 61) test_stackinit: small_hole_dynamic_all FAIL (uninit bytes: 3) test_stackinit: big_hole_dynamic_all FAIL (uninit bytes: 61) test_stackinit: small_hole_runtime_partial FAIL (uninit bytes: 23) test_stackinit: big_hole_runtime_partial FAIL (uninit bytes: 127) test_stackinit: small_hole_runtime_all FAIL (uninit bytes: 3) test_stackinit: big_hole_runtime_all FAIL (uninit bytes: 61) test_stackinit: u8 FAIL (uninit bytes: 1) test_stackinit: u16 FAIL (uninit bytes: 2) test_stackinit: u32 FAIL (uninit bytes: 4) test_stackinit: u64 FAIL (uninit bytes: 8) test_stackinit: char_array FAIL (uninit bytes: 16) test_stackinit: small_hole FAIL (uninit bytes: 24) test_stackinit: big_hole FAIL (uninit bytes: 128) test_stackinit: user ok test_stackinit: failures: 15 CONFIG_GCC_PLUGIN_STRUCTLEAK=y CONFIG_GCC_PLUGIN_STRUCTLEAK_BYREF_ALL=y This initializes all structures passed by reference (scalars and strings remain uninitialized, but padding is wiped): test_stackinit: small_hole_static_all ok test_stackinit: big_hole_static_all ok test_stackinit: small_hole_dynamic_all ok test_stackinit: big_hole_dynamic_all ok test_stackinit: small_hole_runtime_partial ok test_stackinit: big_hole_runtime_partial ok test_stackinit: small_hole_runtime_all ok test_stackinit: big_hole_runtime_all ok test_stackinit: u8 FAIL (uninit bytes: 1) test_stackinit: u16 FAIL (uninit bytes: 2) test_stackinit: u32 FAIL (uninit bytes: 4) test_stackinit: u64 FAIL (uninit bytes: 8) test_stackinit: char_array FAIL (uninit bytes: 16) test_stackinit: small_hole ok test_stackinit: big_hole ok test_stackinit: user ok test_stackinit: failures: 5 CONFIG_GCC_PLUGIN_STACKINIT=y This initializes all variables, but has no special padding handling: test_stackinit: small_hole_static_all FAIL (uninit bytes: 3) test_stackinit: big_hole_static_all FAIL (uninit bytes: 61) test_stackinit: small_hole_dynamic_all FAIL (uninit bytes: 3) test_stackinit: big_hole_dynamic_all FAIL (uninit bytes: 61) test_stackinit: small_hole_runtime_partial ok test_stackinit: big_hole_runtime_partial ok test_stackinit: small_hole_runtime_all ok test_stackinit: big_hole_runtime_all ok test_stackinit: u8 ok test_stackinit: u16 ok test_stackinit: u32 ok test_stackinit: u64 ok test_stackinit: char_array ok test_stackinit: small_hole ok test_stackinit: big_hole ok test_stackinit: user ok test_stackinit: failures: 4 Signed-off-by: Kees Cook --- lib/Kconfig.debug | 9 ++ lib/Makefile | 1 + lib/test_stackinit.c | 327 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 337 insertions(+) create mode 100644 lib/test_stackinit.c diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index d4df5b24d75e..09788afcccc9 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -2001,6 +2001,15 @@ config TEST_OBJAGG If unsure, say N. +config TEST_STACKINIT + tristate "Test level of stack variable initialization" + help + Test if the kernel is zero-initializing stack variables + from CONFIG_GCC_PLUGIN_STACKINIT, CONFIG_GCC_PLUGIN_STRUCTLEAK, + and/or GCC_PLUGIN_STRUCTLEAK_BYREF_ALL. + + If unsure, say N. + endif # RUNTIME_TESTING_MENU config MEMTEST diff --git a/lib/Makefile b/lib/Makefile index e1b59da71418..c81a66d4d00d 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -76,6 +76,7 @@ obj-$(CONFIG_TEST_KMOD) += test_kmod.o obj-$(CONFIG_TEST_DEBUG_VIRTUAL) += test_debug_virtual.o obj-$(CONFIG_TEST_MEMCAT_P) += test_memcat_p.o obj-$(CONFIG_TEST_OBJAGG) += test_objagg.o +obj-$(CONFIG_TEST_STACKINIT) += test_stackinit.o ifeq ($(CONFIG_DEBUG_KOBJECT),y) CFLAGS_kobject.o += -DDEBUG diff --git a/lib/test_stackinit.c b/lib/test_stackinit.c new file mode 100644 index 000000000000..e2ff56a1002a --- /dev/null +++ b/lib/test_stackinit.c @@ -0,0 +1,327 @@ +// SPDX-Licenses: GPLv2 +/* + * Test cases for -finit-local-vars and CONFIG_GCC_PLUGIN_STACKINIT. + */ +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include +#include +#include + +/* Exfiltration buffer. */ +#define MAX_VAR_SIZE 128 +static char check_buf[MAX_VAR_SIZE]; + +/* Character array to trigger stack protector in all functions. */ +#define VAR_BUFFER 32 + +/* Volatile mask to convince compiler to copy memory with 0xff. */ +static volatile u8 forced_mask = 0xff; + +/* Location and size tracking to validate fill and test are colocated. */ +static void *fill_start, *target_start; +static size_t fill_size, target_size; + +static bool range_contains(char *haystack_start, size_t haystack_size, + char *needle_start, size_t needle_size) +{ + if (needle_start >= haystack_start && + needle_start + needle_size <= haystack_start + haystack_size) + return true; + return false; +} + +#define DO_NOTHING_TYPE_SCALAR(var_type) var_type +#define DO_NOTHING_TYPE_STRING(var_type) void +#define DO_NOTHING_TYPE_STRUCT(var_type) void + +#define DO_NOTHING_RETURN_SCALAR(ptr) *(ptr) +#define DO_NOTHING_RETURN_STRING(ptr) /**/ +#define DO_NOTHING_RETURN_STRUCT(ptr) /**/ + +#define DO_NOTHING_CALL_SCALAR(var, name) \ + (var) = do_nothing_ ## name(&(var)) +#define DO_NOTHING_CALL_STRING(var, name) \ + do_nothing_ ## name(var) +#define DO_NOTHING_CALL_STRUCT(var, name) \ + do_nothing_ ## name(&(var)) + +#define FETCH_ARG_SCALAR(var) &var +#define FETCH_ARG_STRING(var) var +#define FETCH_ARG_STRUCT(var) &var + +#define FILL_SIZE_SCALAR 1 +#define FILL_SIZE_STRING 16 +#define FILL_SIZE_STRUCT 1 + +#define INIT_CLONE_SCALAR /**/ +#define INIT_CLONE_STRING [FILL_SIZE_STRING] +#define INIT_CLONE_STRUCT /**/ + +#define INIT_SCALAR_NONE /**/ +#define INIT_SCALAR_ZERO = 0 + +#define INIT_STRING_NONE [FILL_SIZE_STRING] /**/ +#define INIT_STRING_ZERO [FILL_SIZE_STRING] = { } + +#define INIT_STRUCT_NONE /**/ +#define INIT_STRUCT_ZERO = { } +#define INIT_STRUCT_STATIC_PARTIAL = { .two = 0, } +#define INIT_STRUCT_STATIC_ALL = { .one = arg->one, \ + .two = arg->two, \ + .three = arg->three, \ + .four = arg->four, \ + } +#define INIT_STRUCT_DYNAMIC_PARTIAL = { .two = arg->two, } +#define INIT_STRUCT_DYNAMIC_ALL = { .one = arg->one, \ + .two = arg->two, \ + .three = arg->three, \ + .four = arg->four, \ + } +#define INIT_STRUCT_RUNTIME_PARTIAL ; \ + var.two = 0 +#define INIT_STRUCT_RUNTIME_ALL ; \ + var.one = 0; \ + var.two = 0; \ + var.three = 0; \ + memset(&var.four, 0, \ + sizeof(var.four)) + +/* + * @name: unique string name for the test + * @var_type: type to be tested for zeroing initialization + * @which: is this a SCALAR or a STRUCT type? + * @init_level: what kind of initialization is performed + */ +#define DEFINE_TEST(name, var_type, which, init_level) \ +static noinline int fill_ ## name(unsigned long sp) \ +{ \ + char buf[VAR_BUFFER + \ + sizeof(var_type) * FILL_SIZE_ ## which * 4]; \ + \ + fill_start = buf; \ + fill_size = sizeof(buf); \ + /* Fill variable with 0xFF. */ \ + memset(fill_start, (char)((sp && 0xff) | forced_mask), \ + fill_size); \ + \ + return (int)buf[0] | (int)buf[sizeof(buf)-1]; \ +} \ +/* no-op to force compiler into ignoring "uninitialized" vars */\ +static noinline DO_NOTHING_TYPE_ ## which(var_type) \ +do_nothing_ ## name(var_type *ptr) \ +{ \ + /* Will always be true, but compiler doesn't know. */ \ + if ((unsigned long)ptr > 0x2) \ + return DO_NOTHING_RETURN_ ## which(ptr); \ + else \ + return DO_NOTHING_RETURN_ ## which(ptr + 1); \ +} \ +static noinline int fetch_ ## name(unsigned long sp, \ + var_type *arg) \ +{ \ + char buf[VAR_BUFFER]; \ + var_type var INIT_ ## which ## _ ## init_level; \ + \ + target_start = &var; \ + target_size = sizeof(var); \ + /* \ + * Keep this buffer around to make sure we've got a \ + * stack frame of SOME kind... \ + */ \ + memset(buf, (char)(sp && 0xff), sizeof(buf)); \ + \ + /* Silence "never initialized" warnings. */ \ + DO_NOTHING_CALL_ ## which(var, name); \ + \ + /* Exfiltrate "var" or field of "var". */ \ + memcpy(check_buf, target_start, target_size); \ + \ + return (int)buf[0] | (int)buf[sizeof(buf) - 1]; \ +} \ +/* Returns 0 on success, 1 on failure. */ \ +static noinline int test_ ## name (void) \ +{ \ + var_type zero INIT_CLONE_ ## which; \ + int ignored; \ + u8 sum = 0, i; \ + \ + /* Notice when a new test is larger than expected. */ \ + BUILD_BUG_ON(sizeof(zero) > MAX_VAR_SIZE); \ + /* Clear entire check buffer for later bit tests. */ \ + memset(check_buf, 0x00, sizeof(check_buf)); \ + \ + /* Fill clone type with zero for per-field init. */ \ + memset(&zero, 0x00, sizeof(zero)); \ + /* Fill stack with 0xFF. */ \ + ignored = fill_ ##name((unsigned long)&ignored); \ + /* Extract stack-defined variable contents. */ \ + ignored = fetch_ ##name((unsigned long)&ignored, \ + FETCH_ARG_ ## which(zero)); \ + \ + /* Validate that compiler lined up fill and target. */ \ + if (!range_contains(fill_start, fill_size, \ + target_start, target_size)) { \ + pr_err(#name ": stack fill missed target!?\n"); \ + pr_err(#name ": fill %zu wide\n", fill_size); \ + pr_err(#name ": target offset by %ld\n", \ + (ssize_t)(uintptr_t)fill_start - \ + (ssize_t)(uintptr_t)target_start); \ + return 1; \ + } \ + \ + /* Look for any set bits in the check region. */ \ + for (i = 0; i < sizeof(check_buf); i++) \ + sum += (check_buf[i] != 0); \ + \ + if (sum == 0) \ + pr_info(#name " ok\n"); \ + else \ + pr_warn(#name " FAIL (uninit bytes: %d)\n", \ + sum); \ + \ + return (sum != 0); \ +} + +/* Structure with no padding. */ +struct test_packed { + unsigned long one; + unsigned long two; + unsigned long three; + unsigned long four; +}; + +/* Simple structure with padding likely to be covered by compiler. */ +struct test_small_hole { + size_t one; + char two; + /* 3 byte padding hole here. */ + int three; + unsigned long four; +}; + +/* Try to trigger unhandled padding in a structure. */ +struct test_aligned { + u32 internal1; + u64 internal2; +} __aligned(64); + +struct test_big_hole { + u8 one; + u8 two; + u8 three; + /* 61 byte padding hole here. */ + struct test_aligned four; +} __aligned(64); + +/* Test if STRUCTLEAK is clearing structs with __user fields. */ +struct test_user { + u8 one; + char __user *two; + unsigned long three; + unsigned long four; +}; + +/* These should be fully initialized all the time! */ +DEFINE_TEST(u8_zero, u8, SCALAR, ZERO); +DEFINE_TEST(u16_zero, u16, SCALAR, ZERO); +DEFINE_TEST(u32_zero, u32, SCALAR, ZERO); +DEFINE_TEST(u64_zero, u64, SCALAR, ZERO); +DEFINE_TEST(char_array_zero, unsigned char, STRING, ZERO); + +DEFINE_TEST(packed_zero, struct test_packed, STRUCT, ZERO); +DEFINE_TEST(small_hole_zero, struct test_small_hole, STRUCT, ZERO); +DEFINE_TEST(big_hole_zero, struct test_big_hole, STRUCT, ZERO); + +/* Static initialization: padding may be left uninitialized. */ +DEFINE_TEST(packed_static_partial, struct test_packed, STRUCT, STATIC_PARTIAL); +DEFINE_TEST(small_hole_static_partial, struct test_small_hole, STRUCT, STATIC_PARTIAL); +DEFINE_TEST(big_hole_static_partial, struct test_big_hole, STRUCT, STATIC_PARTIAL); + +DEFINE_TEST(small_hole_static_all, struct test_small_hole, STRUCT, STATIC_ALL); +DEFINE_TEST(big_hole_static_all, struct test_big_hole, STRUCT, STATIC_ALL); + +/* Dynamic initialization: padding may be left uninitialized. */ +DEFINE_TEST(small_hole_dynamic_partial, struct test_small_hole, STRUCT, DYNAMIC_PARTIAL); +DEFINE_TEST(big_hole_dynamic_partial, struct test_big_hole, STRUCT, DYNAMIC_PARTIAL); + +DEFINE_TEST(small_hole_dynamic_all, struct test_small_hole, STRUCT, DYNAMIC_ALL); +DEFINE_TEST(big_hole_dynamic_all, struct test_big_hole, STRUCT, DYNAMIC_ALL); + +/* Runtime initialization: padding may be left uninitialized. */ +DEFINE_TEST(small_hole_runtime_partial, struct test_small_hole, STRUCT, RUNTIME_PARTIAL); +DEFINE_TEST(big_hole_runtime_partial, struct test_big_hole, STRUCT, RUNTIME_PARTIAL); + +DEFINE_TEST(small_hole_runtime_all, struct test_small_hole, STRUCT, RUNTIME_ALL); +DEFINE_TEST(big_hole_runtime_all, struct test_big_hole, STRUCT, RUNTIME_ALL); + +/* No initialization without compiler instrumentation. */ +DEFINE_TEST(u8, u8, SCALAR, NONE); +DEFINE_TEST(u16, u16, SCALAR, NONE); +DEFINE_TEST(u32, u32, SCALAR, NONE); +DEFINE_TEST(u64, u64, SCALAR, NONE); +DEFINE_TEST(char_array, unsigned char, STRING, NONE); +DEFINE_TEST(small_hole, struct test_small_hole, STRUCT, NONE); +DEFINE_TEST(big_hole, struct test_big_hole, STRUCT, NONE); +DEFINE_TEST(user, struct test_user, STRUCT, NONE); + +static int __init test_stackinit_init(void) +{ + unsigned int failures = 0; + + /* These are explicitly initialized and should always pass. */ + failures += test_u8_zero(); + failures += test_u16_zero(); + failures += test_u32_zero(); + failures += test_u64_zero(); + failures += test_char_array_zero(); + failures += test_small_hole_zero(); + failures += test_big_hole_zero(); + failures += test_packed_zero(); + + /* Padding here appears to be accidentally always initialized. */ + failures += test_small_hole_dynamic_partial(); + failures += test_big_hole_dynamic_partial(); + failures += test_packed_static_partial(); + + /* Padding initialization depends on compiler behaviors. */ + failures += test_small_hole_static_partial(); + failures += test_big_hole_static_partial(); + failures += test_small_hole_static_all(); + failures += test_big_hole_static_all(); + failures += test_small_hole_dynamic_all(); + failures += test_big_hole_dynamic_all(); + failures += test_small_hole_runtime_partial(); + failures += test_big_hole_runtime_partial(); + failures += test_small_hole_runtime_all(); + failures += test_big_hole_runtime_all(); + + /* STACKINIT should cover everything from here down. */ + failures += test_u8(); + failures += test_u16(); + failures += test_u32(); + failures += test_u64(); + failures += test_char_array(); + + /* STRUCTLEAK_BYREF_ALL should cover from here down. */ + failures += test_small_hole(); + failures += test_big_hole(); + + /* STRUCTLEAK should cover this. */ + failures += test_user(); + + if (failures == 0) + pr_info("all tests passed!\n"); + else + pr_err("failures: %u\n", failures); + + return failures ? -EINVAL : 0; +} +module_init(test_stackinit_init); + +static void __exit test_stackinit_exit(void) +{ } +module_exit(test_stackinit_exit); + +MODULE_LICENSE("GPL"); -- 2.17.1