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 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 39587ECAAA1 for ; Mon, 24 Oct 2022 14:10:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=M7F2T5WypZ5VczyqRv+I/u3XEHbFyCCVXbTPl6ORqXA=; b=l8HWxlGRMr08N3 Tv9SDpIfPXyTpjt21aW0BJ/lZ09vsYGOEG4+XKXFaa+2rloADSDcrSJHEundiom44BAhanA59ZoFb ufVDSBSG4A4spYUlFt+pvDCJPVzik9DAO2r+RizFVf5qakW8yo79rP4KXLe9wNiDeMxVS4/YgoAkN Su8IQkdlw1AXuYGZrCG0OREe1KFif4KUwV/C0zvw1iShDVwDE+ARaeXHa775MwMai5H36x6o/6T+X FTDQnCinHPQIKJogAnTq6DyGDo2XfjUCriTua/Bx8LNZneEwj2789Sel98Sw8hnwV+thzBlzAs4SP f/AHSKKCMyBZNhpRB0gw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1omy9B-001pJi-KA; Mon, 24 Oct 2022 14:09:45 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1omy8V-001p21-OY for linux-arm-kernel@lists.infradead.org; Mon, 24 Oct 2022 14:09:09 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 2944D143D; Mon, 24 Oct 2022 07:09:08 -0700 (PDT) Received: from lakrids.cambridge.arm.com (usa-sjc-imap-foss1.foss.arm.com [10.121.207.14]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPA id AD7BD3F792; Mon, 24 Oct 2022 07:09:00 -0700 (PDT) From: Mark Rutland To: linux-kernel@vger.kernel.org Cc: catalin.marinas@arm.com, linux-arm-kernel@lists.infradead.org, mark.rutland@arm.com, mhiramat@kernel.org, revest@chromium.org, rostedt@goodmis.org, will@kernel.org Subject: [PATCH 4/4] ftrace: arm64: move from REGS to ARGS Date: Mon, 24 Oct 2022 15:08:46 +0100 Message-Id: <20221024140846.3555435-5-mark.rutland@arm.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20221024140846.3555435-1-mark.rutland@arm.com> References: <20221024140846.3555435-1-mark.rutland@arm.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20221024_070903_977786_0CC451B2 X-CRM114-Status: GOOD ( 32.48 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org VGhpcyBjb21taXQgcmVwbGFjZXMgYXJtNjQncyBzdXBwb3J0IGZvciBGVFJBQ0VfV0lUSF9SRUdT IHdpdGggc3VwcG9ydApmb3IgRlRSQUNFX1dJVEhfQVJHUy4gVGhpcyByZW1vdmVzIHNvbWUgb3Zl cmhlYWQgYW5kIGNvbXBsZXhpdHksIGFuZApyZW1vdmVzIHNvbWUgbGF0ZW50IGlzc3VlcyB3aXRo IGluY29uc2lzdGVudCBwcmVzZW50YXRpb24gb2Ygc3RydWN0CnB0X3JlZ3MgKHdoaWNoIGNhbiBv bmx5IGJlIHJlbGlhYmx5IHNhdmVkL3Jlc3RvcmVkIGF0IGV4Y2VwdGlvbgpib3VuZGFyaWVzKS4K CkZUUkFDRV9XSVRIX1JFR1MgaGFzIGJlZW4gc3VwcG9ydGVkIG9uIGFybTY0IHNpbmNlIGNvbW1p dDoKCiAgM2IyM2U0OTkxZmI2NmY2ZCAoImFybTY0OiBpbXBsZW1lbnQgZnRyYWNlIHdpdGggcmVn cyIpCgpBcyBub3RlZCBpbiB0aGUgY29tbWl0IG1lc3NhZ2UsIHRoZSBtYWpvciByZWFzb25zIGZv ciBpbXBsZW1lbnRpbmcKRlRSQUNFX1dJVEhfUkVHUyB3ZXJlOgoKKDEpIFRvIG1ha2UgaXQgcG9z c2libGUgdG8gdXNlIHRoZSBmdHJhY2UgZ3JhcGggdHJhY2VyIHdpdGggcG9pbnRlcgogICAgYXV0 aGVudGljYXRpb24sIHdoZXJlIGl0J3MgbmVjZXNzYXJ5IHRvIHNuYXBzaG90L21hbmlwdWxhdGUg dGhlIExSCiAgICBiZWZvcmUgaXQgaXMgc2lnbmVkIGJ5IHRoZSBpbnN0cnVtZW50ZWQgZnVuY3Rp b24uCgooMikgVG8gbWFrZSBpdCBwb3NzaWJsZSB0byBpbXBsZW1lbnQgTElWRVBBVENIIGluIGZ1 dHVyZSwgd2hlcmUgd2UgbmVlZAogICAgdG8gaG9vayBmdW5jdGlvbiBlbnRyeSBiZWZvcmUgYW4g aW5zdHJ1bWVudGVkIGZ1bmN0aW9uIG1hbmlwdWxhdGVzCiAgICB0aGUgc3RhY2sgb3IgYXJndW1l bnQgcmVnaXN0ZXJzLiBQcmFjdGljYWxseSBzcGVha2luZywgd2UgbmVlZCB0bwogICAgcHJlc2Vy dmUgdGhlIGFyZ3VtZW50L3JldHVybiByZWdpc3RlcnMsIFBDLCBMUiwgYW5kIFNQLgoKTmVpdGhl ciBvZiB0aGVzZSBuZWVkIGEgc3RydWN0IHB0X3JlZ3MsIGFuZCBvbmx5IHJlcXVpcmUgdGhlIHNl dCBvZgpyZWdpc3RlcnMgd2hpY2ggYXJlIGxpdmUgYXQgZnVuY3Rpb24gY2FsbC9yZXR1cm4gYm91 bmRhcmllcy4gT3VyIGNhbGxpbmcKY29udmVudGlvbiBpcyBkZWZpbmVkIGJ5ICJQcm9jZWR1cmUg Q2FsbCBTdGFuZGFyZCBmb3IgdGhlIEFybcKuIDY0LWJpdApBcmNoaXRlY3R1cmUgKEFBcmNoNjQp IiAoQUtBICJBQVBDUzY0IiksIHdoaWNoIGNhbiBjdXJyZW50bHkgYmUgZm91bmQKYXQ6CgogIGh0 dHBzOi8vZ2l0aHViLmNvbS9BUk0tc29mdHdhcmUvYWJpLWFhL2Jsb2IvbWFpbi9hYXBjczY0L2Fh cGNzNjQucnN0CgpQZXIgQUFQQ1M2NCwgYWxsIGZ1bmN0aW9uIGNhbGwgYXJndW1lbnQgYW5kIHJl dHVybiB2YWx1ZXMgYXJlIGhlbGQgaW4KdGhlIGZvbGxvd2luZyBHUFJzOgoKKiBYMCAtIFg3IDog cGFyYW1ldGVyIC8gcmVzdWx0IHJlZ2lzdGVycwoqIFg4ICAgICAgOiBpbmRpcmVjdCByZXN1bHQg bG9jYXRpb24gcmVnaXN0ZXIKKiBTUCAgICAgIDogc3RhY2sgcG9pbnRlciAoQUtBIFNQKQoKQWRk aXRpb25hbGx5LCBhZCBmdW5jdGlvbiBjYWxsIGJvdW5kYXJpZXMsIHRoZSBmb2xsb3dpbmcgR1BS cyBob2xkCmNvbnRleHQvcmV0dXJuIGluZm9ybWF0aW9uOgoKKiBYMjkgOiBmcmFtZSBwb2ludGVy IChBS0EgRlApCiogWDMwIDogbGluayByZWdpc3RlciAoQUtBIExSKQoKLi4uIGFuZCBmb3IgZnRy YWNlIHdlIG5lZWQgdG8gY2FwdHVyZSB0aGUgaW5zdHJ1bWVudGVkIGFkZHJlc3M6CgogKiBQQyAg OiBwcm9ncmFtIGNvdW50ZXIKCk5vIG90aGVyIEdQUnMgYXJlIHJlbGV2YW50LCBhcyBub25lIG9m IHRoZSBvdGhlciBhcmd1bWVudHMgaG9sZApwYXJhbWV0ZXJzIG9yIHJldHVybiB2YWx1ZXM6Cgoq IFg5ICAtIFgxNyA6IHRlbXBvcmFyaWVzLCBtYXkgYmUgY2xvYmJlcmVkCiogWDE4ICAgICAgIDog c2hhZG93IGNhbGwgc3RhY2sgcG9pbnRlciAob3IgdGVtb3JhcnkpCiogWDE5IC0gWDI4IDogY2Fs bGVlIHNhdmVkCgpUaGlzIHBhdGNoIGltcGxlbWVudHMgRlRSQUNFX1dJVEhfQVJHUyBmb3IgYXJt NjQsIG9ubHkgc2F2aW5nL3Jlc3RvcmluZwp0aGUgbWluaW1hbCBzZXQgb2YgcmVnaXN0ZXJzIG5l Y2Vzc2FyeS4gVGhpcyBpcyBhbHdheXMgc3VmZmljaWVudCB0bwptYW5pcHVsYXRlIGNvbnRyb2wg ZmxvdyAoZS5nLiBmb3IgbGl2ZS1wYXRjaGluZykgb3IgdG8gbWFuaXB1bGF0ZQpmdW5jdGlvbiBh cmd1bWVudHMgYW5kIHJldHVybiB2YWx1ZXMuCgpBcyB0aGVyZSBpcyBubyBsb25nZXIgYSBuZWVk IHRvIHNhdmUgZGlmZmVyZW50IHNldHMgb2YgcmVnaXN0ZXJzIGZvcgpkaWZmZXJlbnQgZmVhdHVy ZXMsIHdlIG5vIGxvbmdlciBuZWVkIGRpc3RpbmN0IGBmdHJhY2VfY2FsbGVyYCBhbmQKYGZ0cmFj ZV9yZWdzX2NhbGxlcmAgdHJhbXBvbGluZXMuIFRoaXMgYWxsb3dzIHRoZSB0cmFtcG9saW5lIGFz c2VtYmx5IHRvCmJlIHNpbXBsZXIsIGFuZCBzaW1wbGlmaWVzIGNvZGUgd2hpY2ggcHJldmlvdXNs eSBoYWQgdG8gaGFuZGxlIHRoZSB0d28KdHJhbXBvbGluZXMuCgpJJ3ZlIHRlc3RlZCB0aGlzIHdp dGggdGhlIGZ0cmFjZSBzZWxmdGVzdHMsIHdoZXJlIHRoZXJlIGFyZSBubwp1bmV4cGVjdGVkIGZh aWx1cmVzLgoKQ28tZGV2ZWxvcGVkLWJ5OiBGbG9yZW50IFJldmVzdCA8cmV2ZXN0QGNocm9taXVt Lm9yZz4KU2lnbmVkLW9mZi1ieTogTWFyayBSdXRsYW5kIDxtYXJrLnJ1dGxhbmRAYXJtLmNvbT4K U2lnbmVkLW9mZi1ieTogRmxvcmVudCBSZXZlc3QgPHJldmVzdEBjaHJvbWl1bS5vcmc+CkNjOiBD YXRhbGluIE1hcmluYXMgPGNhdGFsaW4ubWFyaW5hc0Bhcm0uY29tPgpDYzogTWFzYW1pIEhpcmFt YXRzdSA8bWhpcmFtYXRAa2VybmVsLm9yZz4KQ2M6IFN0ZXZlbiBSb3N0ZWR0IDxyb3N0ZWR0QGdv b2RtaXMub3JnPgpDYzogV2lsbCBEZWFjb24gPHdpbGxAa2VybmVsLm9yZz4KLS0tCiBhcmNoL2Fy bTY0L0tjb25maWcgICAgICAgICAgICAgICB8ICAxOCArKy0tLQogYXJjaC9hcm02NC9NYWtlZmls ZSAgICAgICAgICAgICAgfCAgIDIgKy0KIGFyY2gvYXJtNjQvaW5jbHVkZS9hc20vZnRyYWNlLmgg IHwgIDcwICsrKysrKysrKysrKysrKystLQogYXJjaC9hcm02NC9rZXJuZWwvYXNtLW9mZnNldHMu YyAgfCAgMTMgKysrKwogYXJjaC9hcm02NC9rZXJuZWwvZW50cnktZnRyYWNlLlMgfCAxMTcgKysr KysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLQogYXJjaC9hcm02NC9rZXJuZWwvZnRyYWNlLmMg ICAgICAgfCAgMzcgKystLS0tLS0tLQogYXJjaC9hcm02NC9rZXJuZWwvbW9kdWxlLmMgICAgICAg fCAgIDMgLQogNyBmaWxlcyBjaGFuZ2VkLCAxMzggaW5zZXJ0aW9ucygrKSwgMTIyIGRlbGV0aW9u cygtKQoKZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQvS2NvbmZpZyBiL2FyY2gvYXJtNjQvS2NvbmZp ZwppbmRleCA1MDVjOGExY2NiZTAuLmI2YjMzMDViYTcwMSAxMDA2NDQKLS0tIGEvYXJjaC9hcm02 NC9LY29uZmlnCisrKyBiL2FyY2gvYXJtNjQvS2NvbmZpZwpAQCAtMTgxLDggKzE4MSwxMCBAQCBj b25maWcgQVJNNjQKIAlzZWxlY3QgSEFWRV9ERUJVR19LTUVNTEVBSwogCXNlbGVjdCBIQVZFX0RN QV9DT05USUdVT1VTCiAJc2VsZWN0IEhBVkVfRFlOQU1JQ19GVFJBQ0UKKwlzZWxlY3QgSEFWRV9E WU5BTUlDX0ZUUkFDRV9XSVRIX0FSR1MgXAorCQlpZiAkKGNjLW9wdGlvbiwtZnBhdGNoYWJsZS1m dW5jdGlvbi1lbnRyeT0yKQogCXNlbGVjdCBGVFJBQ0VfTUNPVU5UX1VTRV9QQVRDSEFCTEVfRlVO Q1RJT05fRU5UUlkgXAotCQlpZiBEWU5BTUlDX0ZUUkFDRV9XSVRIX1JFR1MKKwkJaWYgRFlOQU1J Q19GVFJBQ0VfV0lUSF9BUkdTCiAJc2VsZWN0IEhBVkVfRUZGSUNJRU5UX1VOQUxJR05FRF9BQ0NF U1MKIAlzZWxlY3QgSEFWRV9GQVNUX0dVUAogCXNlbGVjdCBIQVZFX0ZUUkFDRV9NQ09VTlRfUkVD T1JECkBAIC0yMzMsMTYgKzIzNSwxNiBAQCBjb25maWcgQVJNNjQKIAloZWxwCiAJICBBUk0gNjQt Yml0IChBQXJjaDY0KSBMaW51eCBzdXBwb3J0LgogCi1jb25maWcgQ0xBTkdfU1VQUE9SVFNfRFlO QU1JQ19GVFJBQ0VfV0lUSF9SRUdTCitjb25maWcgQ0xBTkdfU1VQUE9SVFNfRFlOQU1JQ19GVFJB Q0VfV0lUSF9BUkdTCiAJZGVmX2Jvb2wgQ0NfSVNfQ0xBTkcKIAkjIGh0dHBzOi8vZ2l0aHViLmNv bS9DbGFuZ0J1aWx0TGludXgvbGludXgvaXNzdWVzLzE1MDcKIAlkZXBlbmRzIG9uIEFTX0lTX0dO VSB8fCAoQVNfSVNfTExWTSAmJiAoTERfSVNfTExEIHx8IExEX1ZFUlNJT04gPj0gMjM2MDApKQot CXNlbGVjdCBIQVZFX0RZTkFNSUNfRlRSQUNFX1dJVEhfUkVHUworCXNlbGVjdCBIQVZFX0RZTkFN SUNfRlRSQUNFX1dJVEhfQVJHUwogCi1jb25maWcgR0NDX1NVUFBPUlRTX0RZTkFNSUNfRlRSQUNF X1dJVEhfUkVHUworY29uZmlnIEdDQ19TVVBQT1JUU19EWU5BTUlDX0ZUUkFDRV9XSVRIX0FSR1MK IAlkZWZfYm9vbCBDQ19JU19HQ0MKIAlkZXBlbmRzIG9uICQoY2Mtb3B0aW9uLC1mcGF0Y2hhYmxl LWZ1bmN0aW9uLWVudHJ5PTIpCi0Jc2VsZWN0IEhBVkVfRFlOQU1JQ19GVFJBQ0VfV0lUSF9SRUdT CisJc2VsZWN0IEhBVkVfRFlOQU1JQ19GVFJBQ0VfV0lUSF9BUkdTCiAKIGNvbmZpZyA2NEJJVAog CWRlZl9ib29sIHkKQEAgLTE4MTYsNyArMTgxOCw3IEBAIGNvbmZpZyBBUk02NF9QVFJfQVVUSF9L RVJORUwKIAkjIHdoaWNoIGlzIG9ubHkgdW5kZXJzdG9vZCBieSBiaW51dGlscyBzdGFydGluZyB3 aXRoIHZlcnNpb24gMi4zMy4xLgogCWRlcGVuZHMgb24gTERfSVNfTExEIHx8IExEX1ZFUlNJT04g Pj0gMjMzMDEgfHwgKENDX0lTX0dDQyAmJiBHQ0NfVkVSU0lPTiA8IDkwMTAwKQogCWRlcGVuZHMg b24gIUNDX0lTX0NMQU5HIHx8IEFTX0hBU19DRklfTkVHQVRFX1JBX1NUQVRFCi0JZGVwZW5kcyBv biAoIUZVTkNUSU9OX0dSQVBIX1RSQUNFUiB8fCBEWU5BTUlDX0ZUUkFDRV9XSVRIX1JFR1MpCisJ ZGVwZW5kcyBvbiAoIUZVTkNUSU9OX0dSQVBIX1RSQUNFUiB8fCBEWU5BTUlDX0ZUUkFDRV9XSVRI X0FSR1MpCiAJaGVscAogCSAgSWYgdGhlIGNvbXBpbGVyIHN1cHBvcnRzIHRoZSAtbWJyYW5jaC1w cm90ZWN0aW9uIG9yCiAJICAtbXNpZ24tcmV0dXJuLWFkZHJlc3MgZmxhZyAoZS5nLiBHQ0MgNyBv ciBsYXRlciksIHRoZW4gdGhpcyBvcHRpb24KQEAgLTE4MjYsNyArMTgyOCw3IEBAIGNvbmZpZyBB Uk02NF9QVFJfQVVUSF9LRVJORUwKIAkgIGRpc2FibGVkIHdpdGggbWluaW1hbCBsb3NzIG9mIHBy b3RlY3Rpb24uCiAKIAkgIFRoaXMgZmVhdHVyZSB3b3JrcyB3aXRoIEZVTkNUSU9OX0dSQVBIX1RS QUNFUiBvcHRpb24gb25seSBpZgotCSAgRFlOQU1JQ19GVFJBQ0VfV0lUSF9SRUdTIGlzIGVuYWJs ZWQuCisJICBEWU5BTUlDX0ZUUkFDRV9XSVRIX0FSR1MgaXMgZW5hYmxlZC4KIAogY29uZmlnIEND X0hBU19CUkFOQ0hfUFJPVF9QQUNfUkVUCiAJIyBHQ0MgOSBvciBsYXRlciwgY2xhbmcgOCBvciBs YXRlcgpAQCAtMTkyNCw3ICsxOTI2LDcgQEAgY29uZmlnIEFSTTY0X0JUSV9LRVJORUwKIAlkZXBl bmRzIG9uICFDQ19JU19HQ0MKIAkjIGh0dHBzOi8vZ2l0aHViLmNvbS9sbHZtL2xsdm0tcHJvamVj dC9jb21taXQvYTg4YzcyMmU2ODdlNjc4MGRjZDZhNTg3MTgzNTBkYzc2ZmNjNGNjOQogCWRlcGVu ZHMgb24gIUNDX0lTX0NMQU5HIHx8IENMQU5HX1ZFUlNJT04gPj0gMTIwMDAwCi0JZGVwZW5kcyBv biAoIUZVTkNUSU9OX0dSQVBIX1RSQUNFUiB8fCBEWU5BTUlDX0ZUUkFDRV9XSVRIX1JFR1MpCisJ ZGVwZW5kcyBvbiAoIUZVTkNUSU9OX0dSQVBIX1RSQUNFUiB8fCBEWU5BTUlDX0ZUUkFDRV9XSVRI X0FSR1MpCiAJaGVscAogCSAgQnVpbGQgdGhlIGtlcm5lbCB3aXRoIEJyYW5jaCBUYXJnZXQgSWRl bnRpZmljYXRpb24gYW5ub3RhdGlvbnMKIAkgIGFuZCBlbmFibGUgZW5mb3JjZW1lbnQgb2YgdGhp cyBmb3Iga2VybmVsIGNvZGUuIFdoZW4gdGhpcyBvcHRpb24KZGlmZiAtLWdpdCBhL2FyY2gvYXJt NjQvTWFrZWZpbGUgYi9hcmNoL2FybTY0L01ha2VmaWxlCmluZGV4IDVlNTZkMjZhMjIzOS4uYjEy MDJmYTg0YmFiIDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L01ha2VmaWxlCisrKyBiL2FyY2gvYXJt NjQvTWFrZWZpbGUKQEAgLTEyOCw3ICsxMjgsNyBAQCBlbmRpZgogCiBDSEVDS0ZMQUdTCSs9IC1E X19hYXJjaDY0X18KIAotaWZlcSAoJChDT05GSUdfRFlOQU1JQ19GVFJBQ0VfV0lUSF9SRUdTKSx5 KQoraWZlcSAoJChDT05GSUdfRFlOQU1JQ19GVFJBQ0VfV0lUSF9BUkdTKSx5KQogICBLQlVJTERf Q1BQRkxBR1MgKz0gLURDQ19VU0lOR19QQVRDSEFCTEVfRlVOQ1RJT05fRU5UUlkKICAgQ0NfRkxB R1NfRlRSQUNFIDo9IC1mcGF0Y2hhYmxlLWZ1bmN0aW9uLWVudHJ5PTIKIGVuZGlmCmRpZmYgLS1n aXQgYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2Z0cmFjZS5oIGIvYXJjaC9hcm02NC9pbmNsdWRl L2FzbS9mdHJhY2UuaAppbmRleCAzMjlkYmJkNGQ1MGIuLjI2OTEwNjRkNGUwNCAxMDA2NDQKLS0t IGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9mdHJhY2UuaAorKysgYi9hcmNoL2FybTY0L2luY2x1 ZGUvYXNtL2Z0cmFjZS5oCkBAIC0yMyw3ICsyMyw3IEBACiAgKi8KICNkZWZpbmUgSEFWRV9GVU5D VElPTl9HUkFQSF9SRVRfQUREUl9QVFIKIAotI2lmZGVmIENPTkZJR19EWU5BTUlDX0ZUUkFDRV9X SVRIX1JFR1MKKyNpZmRlZiBDT05GSUdfRFlOQU1JQ19GVFJBQ0VfV0lUSF9BUkdTCiAjZGVmaW5l IEFSQ0hfU1VQUE9SVFNfRlRSQUNFX09QUyAxCiAjZWxzZQogI2RlZmluZSBNQ09VTlRfQUREUgkJ KCh1bnNpZ25lZCBsb25nKV9tY291bnQpCkBAIC0zMyw4ICszMyw3IEBACiAjZGVmaW5lIE1DT1VO VF9JTlNOX1NJWkUJQUFSQ0g2NF9JTlNOX1NJWkUKIAogI2RlZmluZSBGVFJBQ0VfUExUX0lEWAkJ MAotI2RlZmluZSBGVFJBQ0VfUkVHU19QTFRfSURYCTEKLSNkZWZpbmUgTlJfRlRSQUNFX1BMVFMJ CTIKKyNkZWZpbmUgTlJfRlRSQUNFX1BMVFMJCTEKIAogLyoKICAqIEN1cnJlbnRseSwgZ2NjIHRl bmRzIHRvIHNhdmUgdGhlIGxpbmsgcmVnaXN0ZXIgYWZ0ZXIgdGhlIGxvY2FsIHZhcmlhYmxlcwpA QCAtNjksNyArNjgsNyBAQCBzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgZnRyYWNlX2NhbGxf YWRqdXN0KHVuc2lnbmVkIGxvbmcgYWRkcikKIAkgKiBBZGp1c3QgYWRkciB0byBwb2ludCBhdCB0 aGUgQkwgaW4gdGhlIGNhbGxzaXRlLgogCSAqIFNlZSBmdHJhY2VfaW5pdF9ub3AoKSBmb3IgdGhl IGNhbGxzaXRlIHNlcXVlbmNlLgogCSAqLwotCWlmIChJU19FTkFCTEVEKENPTkZJR19EWU5BTUlD X0ZUUkFDRV9XSVRIX1JFR1MpKQorCWlmIChJU19FTkFCTEVEKENPTkZJR19EWU5BTUlDX0ZUUkFD RV9XSVRIX0FSR1MpKQogCQlyZXR1cm4gYWRkciArIEFBUkNINjRfSU5TTl9TSVpFOwogCS8qCiAJ ICogYWRkciBpcyB0aGUgYWRkcmVzcyBvZiB0aGUgbWNvdW50IGNhbGwgaW5zdHJ1Y3Rpb24uCkBA IC03OCwxMCArNzcsNjkgQEAgc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIGZ0cmFjZV9jYWxs X2FkanVzdCh1bnNpZ25lZCBsb25nIGFkZHIpCiAJcmV0dXJuIGFkZHI7CiB9CiAKLSNpZmRlZiBD T05GSUdfRFlOQU1JQ19GVFJBQ0VfV0lUSF9SRUdTCisjaWZkZWYgQ09ORklHX0RZTkFNSUNfRlRS QUNFX1dJVEhfQVJHUwogc3RydWN0IGR5bl9mdHJhY2U7CiBzdHJ1Y3QgZnRyYWNlX29wczsKLXN0 cnVjdCBmdHJhY2VfcmVnczsKKworI2RlZmluZSBhcmNoX2Z0cmFjZV9nZXRfcmVncyhyZWdzKSBO VUxMCisKK3N0cnVjdCBmdHJhY2VfcmVncyB7CisJLyogeDAgLSB4OCAqLworCXVuc2lnbmVkIGxv bmcgcmVnc1s5XTsKKwl1bnNpZ25lZCBsb25nIF9fdW51c2VkOworCisJdW5zaWduZWQgbG9uZyBm cDsKKwl1bnNpZ25lZCBsb25nIGxyOworCisJdW5zaWduZWQgbG9uZyBzcDsKKwl1bnNpZ25lZCBs b25nIHBjOworfTsKKworc3RhdGljIF9fYWx3YXlzX2lubGluZSB1bnNpZ25lZCBsb25nCitmdHJh Y2VfcmVnc19nZXRfaW5zdHJ1Y3Rpb25fcG9pbnRlcihjb25zdCBzdHJ1Y3QgZnRyYWNlX3JlZ3Mg KmZyZWdzKQoreworCXJldHVybiBmcmVncy0+cGM7Cit9CisKK3N0YXRpYyBfX2Fsd2F5c19pbmxp bmUgdm9pZAorZnRyYWNlX3JlZ3Nfc2V0X2luc3RydWN0aW9uX3BvaW50ZXIoc3RydWN0IGZ0cmFj ZV9yZWdzICpmcmVncywKKwkJCQkgICAgdW5zaWduZWQgbG9uZyBwYykKK3sKKwlmcmVncy0+cGMg PSBwYzsKK30KKworc3RhdGljIF9fYWx3YXlzX2lubGluZSB1bnNpZ25lZCBsb25nCitmdHJhY2Vf cmVnc19nZXRfc3RhY2tfcG9pbnRlcihjb25zdCBzdHJ1Y3QgZnRyYWNlX3JlZ3MgKmZyZWdzKQor eworCXJldHVybiBmcmVncy0+c3A7Cit9CisKK3N0YXRpYyBfX2Fsd2F5c19pbmxpbmUgdW5zaWdu ZWQgbG9uZworZnRyYWNlX3JlZ3NfZ2V0X2FyZ3VtZW50KHN0cnVjdCBmdHJhY2VfcmVncyAqZnJl Z3MsIHVuc2lnbmVkIGludCBuKQoreworCWlmIChuIDwgOCkKKwkJcmV0dXJuIGZyZWdzLT5yZWdz W25dOworCXJldHVybiAwOworfQorCitzdGF0aWMgX19hbHdheXNfaW5saW5lIHVuc2lnbmVkIGxv bmcKK2Z0cmFjZV9yZWdzX2dldF9yZXR1cm5fdmFsdWUoY29uc3Qgc3RydWN0IGZ0cmFjZV9yZWdz ICpmcmVncykKK3sKKwlyZXR1cm4gZnJlZ3MtPnJlZ3NbMF07Cit9CisKK3N0YXRpYyBfX2Fsd2F5 c19pbmxpbmUgdm9pZAorZnRyYWNlX3JlZ3Nfc2V0X3JldHVybl92YWx1ZShzdHJ1Y3QgZnRyYWNl X3JlZ3MgKmZyZWdzLAorCQkJICAgICB1bnNpZ25lZCBsb25nIHJldCkKK3sKKwlmcmVncy0+cmVn c1swXSA9IHJldDsKK30KKworc3RhdGljIF9fYWx3YXlzX2lubGluZSB2b2lkCitmdHJhY2Vfb3Zl cnJpZGVfZnVuY3Rpb25fd2l0aF9yZXR1cm4oc3RydWN0IGZ0cmFjZV9yZWdzICpmcmVncykKK3sK KwlmcmVncy0+cGMgPSBmcmVncy0+bHI7Cit9CiAKIGludCBmdHJhY2VfaW5pdF9ub3Aoc3RydWN0 IG1vZHVsZSAqbW9kLCBzdHJ1Y3QgZHluX2Z0cmFjZSAqcmVjKTsKICNkZWZpbmUgZnRyYWNlX2lu aXRfbm9wIGZ0cmFjZV9pbml0X25vcApkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9rZXJuZWwvYXNt LW9mZnNldHMuYyBiL2FyY2gvYXJtNjQva2VybmVsL2FzbS1vZmZzZXRzLmMKaW5kZXggMTE5N2U3 Njc5ODgyLi4yMjM0NjI0NTM2ZDkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQva2VybmVsL2FzbS1v ZmZzZXRzLmMKKysrIGIvYXJjaC9hcm02NC9rZXJuZWwvYXNtLW9mZnNldHMuYwpAQCAtODIsNiAr ODIsMTkgQEAgaW50IG1haW4odm9pZCkKICAgREVGSU5FKFNfU1RBQ0tGUkFNRSwJCW9mZnNldG9m KHN0cnVjdCBwdF9yZWdzLCBzdGFja2ZyYW1lKSk7CiAgIERFRklORShQVF9SRUdTX1NJWkUsCQlz aXplb2Yoc3RydWN0IHB0X3JlZ3MpKTsKICAgQkxBTksoKTsKKyNpZmRlZiBDT05GSUdfRFlOQU1J Q19GVFJBQ0VfV0lUSF9BUkdTCisgIERFRklORShGUkVHU19YMCwJCW9mZnNldG9mKHN0cnVjdCBm dHJhY2VfcmVncywgcmVnc1swXSkpOworICBERUZJTkUoRlJFR1NfWDIsCQlvZmZzZXRvZihzdHJ1 Y3QgZnRyYWNlX3JlZ3MsIHJlZ3NbMl0pKTsKKyAgREVGSU5FKEZSRUdTX1g0LAkJb2Zmc2V0b2Yo c3RydWN0IGZ0cmFjZV9yZWdzLCByZWdzWzRdKSk7CisgIERFRklORShGUkVHU19YNiwJCW9mZnNl dG9mKHN0cnVjdCBmdHJhY2VfcmVncywgcmVnc1s2XSkpOworICBERUZJTkUoRlJFR1NfWDgsCQlv ZmZzZXRvZihzdHJ1Y3QgZnRyYWNlX3JlZ3MsIHJlZ3NbOF0pKTsKKyAgREVGSU5FKEZSRUdTX0ZQ LAkJb2Zmc2V0b2Yoc3RydWN0IGZ0cmFjZV9yZWdzLCBmcCkpOworICBERUZJTkUoRlJFR1NfTFIs CQlvZmZzZXRvZihzdHJ1Y3QgZnRyYWNlX3JlZ3MsIGxyKSk7CisgIERFRklORShGUkVHU19TUCwJ CW9mZnNldG9mKHN0cnVjdCBmdHJhY2VfcmVncywgc3ApKTsKKyAgREVGSU5FKEZSRUdTX1BDLAkJ b2Zmc2V0b2Yoc3RydWN0IGZ0cmFjZV9yZWdzLCBwYykpOworICBERUZJTkUoRlJFR1NfU0laRSwJ CXNpemVvZihzdHJ1Y3QgZnRyYWNlX3JlZ3MpKTsKKyAgQkxBTksoKTsKKyNlbmRpZgogI2lmZGVm IENPTkZJR19DT01QQVQKICAgREVGSU5FKENPTVBBVF9TSUdGUkFNRV9SRUdTX09GRlNFVCwJCW9m ZnNldG9mKHN0cnVjdCBjb21wYXRfc2lnZnJhbWUsIHVjLnVjX21jb250ZXh0LmFybV9yMCkpOwog ICBERUZJTkUoQ09NUEFUX1JUX1NJR0ZSQU1FX1JFR1NfT0ZGU0VULAlvZmZzZXRvZihzdHJ1Y3Qg Y29tcGF0X3J0X3NpZ2ZyYW1lLCBzaWcudWMudWNfbWNvbnRleHQuYXJtX3IwKSk7CmRpZmYgLS1n aXQgYS9hcmNoL2FybTY0L2tlcm5lbC9lbnRyeS1mdHJhY2UuUyBiL2FyY2gvYXJtNjQva2VybmVs L2VudHJ5LWZ0cmFjZS5TCmluZGV4IDc5NTM0NGFiNGVjNC4uNGQzMDUwNTQ5YWE2IDEwMDY0NAot LS0gYS9hcmNoL2FybTY0L2tlcm5lbC9lbnRyeS1mdHJhY2UuUworKysgYi9hcmNoL2FybTY0L2tl cm5lbC9lbnRyeS1mdHJhY2UuUwpAQCAtMTMsODMgKzEzLDU4IEBACiAjaW5jbHVkZSA8YXNtL2Z0 cmFjZS5oPgogI2luY2x1ZGUgPGFzbS9pbnNuLmg+CiAKLSNpZmRlZiBDT05GSUdfRFlOQU1JQ19G VFJBQ0VfV0lUSF9SRUdTCisjaWZkZWYgQ09ORklHX0RZTkFNSUNfRlRSQUNFX1dJVEhfQVJHUwog LyoKICAqIER1ZSB0byAtZnBhdGNoYWJsZS1mdW5jdGlvbi1lbnRyeT0yLCB0aGUgY29tcGlsZXIg aGFzIHBsYWNlZCB0d28gTk9QcyBiZWZvcmUKICAqIHRoZSByZWd1bGFyIGZ1bmN0aW9uIHByb2xv Z3VlLiBGb3IgYW4gZW5hYmxlZCBjYWxsc2l0ZSwgZnRyYWNlX2luaXRfbm9wKCkgYW5kCiAgKiBm dHJhY2VfbWFrZV9jYWxsKCkgaGF2ZSBwYXRjaGVkIHRob3NlIE5PUHMgdG86CiAgKgogICogCU1P VglYOSwgTFIKLSAqIAlCTAk8ZW50cnk+Ci0gKgotICogLi4uIHdoZXJlIDxlbnRyeT4gaXMgZWl0 aGVyIGZ0cmFjZV9jYWxsZXIgb3IgZnRyYWNlX3JlZ3NfY2FsbGVyLgorICogCUJMCWZ0cmFjZV9j YWxsZXIKICAqCiAgKiBFYWNoIGluc3RydW1lbnRlZCBmdW5jdGlvbiBmb2xsb3dzIHRoZSBBQVBD Uywgc28gaGVyZSB4MC14OCBhbmQgeDE4LXgzMCBhcmUKICAqIGxpdmUgKHgxOCBob2xkcyB0aGUg U2hhZG93IENhbGwgU3RhY2sgcG9pbnRlciksIGFuZCB4OS14MTcgYXJlIHNhZmUgdG8KICAqIGNs b2JiZXIuCiAgKgotICogV2Ugc2F2ZSB0aGUgY2FsbHNpdGUncyBjb250ZXh0IGludG8gYSBwdF9y ZWdzIGJlZm9yZSBpbnZva2luZyBhbnkgZnRyYWNlCi0gKiBjYWxsYmFja3MuIFNvIHRoYXQgd2Ug Y2FuIGdldCBhIHNlbnNpYmxlIGJhY2t0cmFjZSwgd2UgY3JlYXRlIGEgc3RhY2sgcmVjb3JkCi0g KiBmb3IgdGhlIGNhbGxzaXRlIGFuZCB0aGUgZnRyYWNlIGVudHJ5IGFzc2VtYmx5LiBUaGlzIGlz IG5vdCBzdWZmaWNpZW50IGZvcgotICogcmVsaWFibGUgc3RhY2t0cmFjZTogdW50aWwgd2UgY3Jl YXRlIHRoZSBjYWxsc2l0ZSBzdGFjayByZWNvcmQsIGl0cyBjYWxsZXIKLSAqIGlzIG1pc3Npbmcg ZnJvbSB0aGUgTFIgYW5kIGV4aXN0aW5nIGNoYWluIG9mIGZyYW1lIHJlY29yZHMuCisgKiBXZSBz YXZlIHRoZSBjYWxsc2l0ZSdzIGNvbnRleHQgaW50byBhIHN0cnVjdCBmdHJhY2VfcmVncyBiZWZv cmUgaW52b2tpbmcgYW55CisgKiBmdHJhY2UgY2FsbGJhY2tzLiBTbyB0aGF0IHdlIGNhbiBnZXQg YSBzZW5zaWJsZSBiYWNrdHJhY2UsIHdlIGNyZWF0ZSBmcmFtZQorICogcmVjb3JkcyBmb3IgdGhl IGNhbGxzaXRlIGFuZCB0aGUgZnRyYWNlIGVudHJ5IGFzc2VtYmx5LiBUaGlzIGlzIG5vdAorICog c3VmZmljaWVudCBmb3IgcmVsaWFibGUgc3RhY2t0cmFjZTogdW50aWwgd2UgY3JlYXRlIHRoZSBj YWxsc2l0ZSBzdGFjaworICogcmVjb3JkLCBpdHMgY2FsbGVyIGlzIG1pc3NpbmcgZnJvbSB0aGUg TFIgYW5kIGV4aXN0aW5nIGNoYWluIG9mIGZyYW1lCisgKiByZWNvcmRzLgogICovCi0JLm1hY3Jv ICBmdHJhY2VfcmVnc19lbnRyeSwgYWxscmVncz0wCi0JLyogTWFrZSByb29tIGZvciBwdF9yZWdz LCBwbHVzIGEgY2FsbGVlIGZyYW1lICovCi0Jc3ViCXNwLCBzcCwgIyhQVF9SRUdTX1NJWkUgKyAx NikKLQotCS8qIFNhdmUgZnVuY3Rpb24gYXJndW1lbnRzIChhbmQgeDkgZm9yIHNpbXBsaWNpdHkp ICovCi0Jc3RwCXgwLCB4MSwgW3NwLCAjU19YMF0KLQlzdHAJeDIsIHgzLCBbc3AsICNTX1gyXQot CXN0cAl4NCwgeDUsIFtzcCwgI1NfWDRdCi0Jc3RwCXg2LCB4NywgW3NwLCAjU19YNl0KLQlzdHAJ eDgsIHg5LCBbc3AsICNTX1g4XQotCi0JLyogT3B0aW9uYWxseSBzYXZlIHRoZSBjYWxsZWUtc2F2 ZWQgcmVnaXN0ZXJzLCBhbHdheXMgc2F2ZSB0aGUgRlAgKi8KLQkuaWYgXGFsbHJlZ3MgPT0gMQot CXN0cAl4MTAsIHgxMSwgW3NwLCAjU19YMTBdCi0Jc3RwCXgxMiwgeDEzLCBbc3AsICNTX1gxMl0K LQlzdHAJeDE0LCB4MTUsIFtzcCwgI1NfWDE0XQotCXN0cAl4MTYsIHgxNywgW3NwLCAjU19YMTZd Ci0Jc3RwCXgxOCwgeDE5LCBbc3AsICNTX1gxOF0KLQlzdHAJeDIwLCB4MjEsIFtzcCwgI1NfWDIw XQotCXN0cAl4MjIsIHgyMywgW3NwLCAjU19YMjJdCi0Jc3RwCXgyNCwgeDI1LCBbc3AsICNTX1gy NF0KLQlzdHAJeDI2LCB4MjcsIFtzcCwgI1NfWDI2XQotCXN0cAl4MjgsIHgyOSwgW3NwLCAjU19Y MjhdCi0JLmVsc2UKLQlzdHIJeDI5LCBbc3AsICNTX0ZQXQotCS5lbmRpZgotCi0JLyogU2F2ZSB0 aGUgY2FsbHNpdGUncyBTUCBhbmQgTFIgKi8KLQlhZGQJeDEwLCBzcCwgIyhQVF9SRUdTX1NJWkUg KyAxNikKLQlzdHAJeDksIHgxMCwgW3NwLCAjU19MUl0KK1NZTV9DT0RFX1NUQVJUKGZ0cmFjZV9j YWxsZXIpCisJYnRpCWMKIAotCS8qIFNhdmUgdGhlIFBDIGFmdGVyIHRoZSBmdHJhY2UgY2FsbHNp dGUgKi8KLQlzdHIJeDMwLCBbc3AsICNTX1BDXQorCS8qIFNhdmUgb3JpZ2luYWwgU1AgKi8KKwlt b3YJeDEwLCBzcAogCi0JLyogQ3JlYXRlIGEgZnJhbWUgcmVjb3JkIGZvciB0aGUgY2FsbHNpdGUg YWJvdmUgcHRfcmVncyAqLwotCXN0cAl4MjksIHg5LCBbc3AsICNQVF9SRUdTX1NJWkVdCi0JYWRk CXgyOSwgc3AsICNQVF9SRUdTX1NJWkUKKwkvKiBNYWtlIHJvb20gZm9yIGZ0cmFjZSByZWdzLCBw bHVzIHR3byBmcmFtZSByZWNvcmRzICovCisJc3ViCXNwLCBzcCwgIyhGUkVHU19TSVpFICsgMzIp CiAKLQkvKiBDcmVhdGUgb3VyIGZyYW1lIHJlY29yZCB3aXRoaW4gcHRfcmVncy4gKi8KLQlzdHAJ eDI5LCB4MzAsIFtzcCwgI1NfU1RBQ0tGUkFNRV0KLQlhZGQJeDI5LCBzcCwgI1NfU1RBQ0tGUkFN RQotCS5lbmRtCisJLyogU2F2ZSBmdW5jdGlvbiBhcmd1bWVudHMgKi8KKwlzdHAJeDAsIHgxLCBb c3AsICNGUkVHU19YMF0KKwlzdHAJeDIsIHgzLCBbc3AsICNGUkVHU19YMl0KKwlzdHAJeDQsIHg1 LCBbc3AsICNGUkVHU19YNF0KKwlzdHAJeDYsIHg3LCBbc3AsICNGUkVHU19YNl0KKwlzdHIJeDgs ICAgICBbc3AsICNGUkVHU19YOF0KIAotU1lNX0NPREVfU1RBUlQoZnRyYWNlX3JlZ3NfY2FsbGVy KQotCWJ0aQljCi0JZnRyYWNlX3JlZ3NfZW50cnkJMQotCWIJZnRyYWNlX2NvbW1vbgotU1lNX0NP REVfRU5EKGZ0cmFjZV9yZWdzX2NhbGxlcikKKwkvKiBTYXZlIHRoZSBjYWxsc2l0ZSdzIEZQLCBM UiwgU1AgKi8KKwlzdHIJeDI5LCBbc3AsICNGUkVHU19GUF0KKwlzdHIJeDksICBbc3AsICNGUkVH U19MUl0KKwlzdHIJeDEwLCBbc3AsICNGUkVHU19TUF0KIAotU1lNX0NPREVfU1RBUlQoZnRyYWNl X2NhbGxlcikKLQlidGkJYwotCWZ0cmFjZV9yZWdzX2VudHJ5CTAKLQliCWZ0cmFjZV9jb21tb24K LVNZTV9DT0RFX0VORChmdHJhY2VfY2FsbGVyKQorCS8qIFNhdmUgdGhlIFBDIGFmdGVyIHRoZSBm dHJhY2UgY2FsbHNpdGUgKi8KKwlzdHIJeDMwLCBbc3AsICNGUkVHU19QQ10KKworCS8qIENyZWF0 ZSBhIGZyYW1lIHJlY29yZCBmb3IgdGhlIGNhbGxzaXRlIGFib3ZlIHRoZSBmdHJhY2UgcmVncyAq LworCXN0cAl4MjksIHg5LCBbc3AsICNGUkVHU19TSVpFICsgMTZdCisJYWRkCXgyOSwgc3AsICNG UkVHU19TSVpFICsgMTYKKworCS8qIENyZWF0ZSBvdXIgZnJhbWUgcmVjb3JkIGFib3ZlIHRoZSBm dHJhY2UgcmVncyAqLworCXN0cAl4MjksIHgzMCwgW3NwLCAjRlJFR1NfU0laRV0KKwlhZGQJeDI5 LCBzcCwgI0ZSRUdTX1NJWkUKIAotU1lNX0NPREVfU1RBUlQoZnRyYWNlX2NvbW1vbikKIAlzdWIJ eDAsIHgzMCwgI0FBUkNINjRfSU5TTl9TSVpFCS8vIGlwIChjYWxsc2l0ZSdzIEJMIGluc24pCiAJ bW92CXgxLCB4OQkJCQkvLyBwYXJlbnRfaXAgKGNhbGxzaXRlJ3MgTFIpCiAJbGRyX2wJeDIsIGZ1 bmN0aW9uX3RyYWNlX29wCQkvLyBvcApAQCAtMTA0LDI0ICs3OSwyNCBAQCBTWU1fSU5ORVJfTEFC RUwoZnRyYWNlX2NhbGwsIFNZTV9MX0dMT0JBTCkKICAqIHRvIHJlc3RvcmUgeDAteDgsIHgyOSwg YW5kIHgzMC4KICAqLwogCS8qIFJlc3RvcmUgZnVuY3Rpb24gYXJndW1lbnRzICovCi0JbGRwCXgw LCB4MSwgW3NwXQotCWxkcAl4MiwgeDMsIFtzcCwgI1NfWDJdCi0JbGRwCXg0LCB4NSwgW3NwLCAj U19YNF0KLQlsZHAJeDYsIHg3LCBbc3AsICNTX1g2XQotCWxkcgl4OCwgW3NwLCAjU19YOF0KKwls ZHAJeDAsIHgxLCBbc3AsICNGUkVHU19YMF0KKwlsZHAJeDIsIHgzLCBbc3AsICNGUkVHU19YMl0K KwlsZHAJeDQsIHg1LCBbc3AsICNGUkVHU19YNF0KKwlsZHAJeDYsIHg3LCBbc3AsICNGUkVHU19Y Nl0KKwlsZHIJeDgsICAgICBbc3AsICNGUkVHU19YOF0KIAogCS8qIFJlc3RvcmUgdGhlIGNhbGxz aXRlJ3MgRlAsIExSLCBQQyAqLwotCWxkcgl4MjksIFtzcCwgI1NfRlBdCi0JbGRyCXgzMCwgW3Nw LCAjU19MUl0KLQlsZHIJeDksIFtzcCwgI1NfUENdCisJbGRyCXgyOSwgW3NwLCAjRlJFR1NfRlBd CisJbGRyCXgzMCwgW3NwLCAjRlJFR1NfTFJdCisJbGRyCXg5LCAgW3NwLCAjRlJFR1NfUENdCiAK IAkvKiBSZXN0b3JlIHRoZSBjYWxsc2l0ZSdzIFNQICovCi0JYWRkCXNwLCBzcCwgI1BUX1JFR1Nf U0laRSArIDE2CisJYWRkCXNwLCBzcCwgI0ZSRUdTX1NJWkUgKyAzMgogCiAJcmV0CXg5Ci1TWU1f Q09ERV9FTkQoZnRyYWNlX2NvbW1vbikKK1NZTV9DT0RFX0VORChmdHJhY2VfY2FsbGVyKQogCi0j ZWxzZSAvKiBDT05GSUdfRFlOQU1JQ19GVFJBQ0VfV0lUSF9SRUdTICovCisjZWxzZSAvKiBDT05G SUdfRFlOQU1JQ19GVFJBQ0VfV0lUSF9BUkdTICovCiAKIC8qCiAgKiBHY2Mgd2l0aCAtcGcgd2ls bCBwdXQgdGhlIGZvbGxvd2luZyBjb2RlIGluIHRoZSBiZWdpbm5pbmcgb2YgZWFjaCBmdW5jdGlv bjoKQEAgLTI5Myw3ICsyNjgsNyBAQCBTWU1fRlVOQ19TVEFSVChmdHJhY2VfZ3JhcGhfY2FsbGVy KQogCW1jb3VudF9leGl0CiBTWU1fRlVOQ19FTkQoZnRyYWNlX2dyYXBoX2NhbGxlcikKICNlbmRp ZiAvKiBDT05GSUdfRlVOQ1RJT05fR1JBUEhfVFJBQ0VSICovCi0jZW5kaWYgLyogQ09ORklHX0RZ TkFNSUNfRlRSQUNFX1dJVEhfUkVHUyAqLworI2VuZGlmIC8qIENPTkZJR19EWU5BTUlDX0ZUUkFD RV9XSVRIX0FSR1MgKi8KIAogU1lNX1RZUEVEX0ZVTkNfU1RBUlQoZnRyYWNlX3N0dWIpCiAJcmV0 CmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2tlcm5lbC9mdHJhY2UuYyBiL2FyY2gvYXJtNjQva2Vy bmVsL2Z0cmFjZS5jCmluZGV4IDg3NDUxNzVmNGE3NS4uZWQ2YjhhNzBjMGQxIDEwMDY0NAotLS0g YS9hcmNoL2FybTY0L2tlcm5lbC9mdHJhY2UuYworKysgYi9hcmNoL2FybTY0L2tlcm5lbC9mdHJh Y2UuYwpAQCAtNzAsOSArNzAsNiBAQCBzdGF0aWMgc3RydWN0IHBsdF9lbnRyeSAqZ2V0X2Z0cmFj ZV9wbHQoc3RydWN0IG1vZHVsZSAqbW9kLCB1bnNpZ25lZCBsb25nIGFkZHIpCiAKIAlpZiAoYWRk ciA9PSBGVFJBQ0VfQUREUikKIAkJcmV0dXJuICZwbHRbRlRSQUNFX1BMVF9JRFhdOwotCWlmIChh ZGRyID09IEZUUkFDRV9SRUdTX0FERFIgJiYKLQkgICAgSVNfRU5BQkxFRChDT05GSUdfRFlOQU1J Q19GVFJBQ0VfV0lUSF9SRUdTKSkKLQkJcmV0dXJuICZwbHRbRlRSQUNFX1JFR1NfUExUX0lEWF07 CiAjZW5kaWYKIAlyZXR1cm4gTlVMTDsKIH0KQEAgLTE1NCwyNSArMTUxLDcgQEAgaW50IGZ0cmFj ZV9tYWtlX2NhbGwoc3RydWN0IGR5bl9mdHJhY2UgKnJlYywgdW5zaWduZWQgbG9uZyBhZGRyKQog CXJldHVybiBmdHJhY2VfbW9kaWZ5X2NvZGUocGMsIG9sZCwgbmV3LCB0cnVlKTsKIH0KIAotI2lm ZGVmIENPTkZJR19EWU5BTUlDX0ZUUkFDRV9XSVRIX1JFR1MKLWludCBmdHJhY2VfbW9kaWZ5X2Nh bGwoc3RydWN0IGR5bl9mdHJhY2UgKnJlYywgdW5zaWduZWQgbG9uZyBvbGRfYWRkciwKLQkJCXVu c2lnbmVkIGxvbmcgYWRkcikKLXsKLQl1bnNpZ25lZCBsb25nIHBjID0gcmVjLT5pcDsKLQl1MzIg b2xkLCBuZXc7Ci0KLQlpZiAoIWZ0cmFjZV9maW5kX2NhbGxhYmxlX2FkZHIocmVjLCBOVUxMLCAm b2xkX2FkZHIpKQotCQlyZXR1cm4gLUVJTlZBTDsKLQlpZiAoIWZ0cmFjZV9maW5kX2NhbGxhYmxl X2FkZHIocmVjLCBOVUxMLCAmYWRkcikpCi0JCXJldHVybiAtRUlOVkFMOwotCi0Jb2xkID0gYWFy Y2g2NF9pbnNuX2dlbl9icmFuY2hfaW1tKHBjLCBvbGRfYWRkciwKLQkJCQkJICBBQVJDSDY0X0lO U05fQlJBTkNIX0xJTkspOwotCW5ldyA9IGFhcmNoNjRfaW5zbl9nZW5fYnJhbmNoX2ltbShwYywg YWRkciwgQUFSQ0g2NF9JTlNOX0JSQU5DSF9MSU5LKTsKLQotCXJldHVybiBmdHJhY2VfbW9kaWZ5 X2NvZGUocGMsIG9sZCwgbmV3LCB0cnVlKTsKLX0KLQorI2lmZGVmIENPTkZJR19EWU5BTUlDX0ZU UkFDRV9XSVRIX0FSR1MKIC8qCiAgKiBUaGUgY29tcGlsZXIgaGFzIGluc2VydGVkIHR3byBOT1Bz IGJlZm9yZSB0aGUgcmVndWxhciBmdW5jdGlvbiBwcm9sb2d1ZS4KICAqIEFsbCBpbnN0cnVtZW50 ZWQgZnVuY3Rpb25zIGZvbGxvdyB0aGUgQUFQQ1MsIHNvIHgwLXg4IGFuZCB4MTkteDMwIGFyZSBs aXZlLApAQCAtMjc5LDE5ICsyNTgsMTEgQEAgdm9pZCBwcmVwYXJlX2Z0cmFjZV9yZXR1cm4odW5z aWduZWQgbG9uZyBzZWxmX2FkZHIsIHVuc2lnbmVkIGxvbmcgKnBhcmVudCwKIAogI2lmZGVmIENP TkZJR19EWU5BTUlDX0ZUUkFDRQogCi0jaWZkZWYgQ09ORklHX0RZTkFNSUNfRlRSQUNFX1dJVEhf UkVHUworI2lmZGVmIENPTkZJR19EWU5BTUlDX0ZUUkFDRV9XSVRIX0FSR1MKIHZvaWQgZnRyYWNl X2dyYXBoX2Z1bmModW5zaWduZWQgbG9uZyBpcCwgdW5zaWduZWQgbG9uZyBwYXJlbnRfaXAsCiAJ CSAgICAgICBzdHJ1Y3QgZnRyYWNlX29wcyAqb3AsIHN0cnVjdCBmdHJhY2VfcmVncyAqZnJlZ3Mp CiB7Ci0JLyoKLQkgKiBXaGVuIERZTkFNSUNfRlRSQUNFX1dJVEhfUkVHUyBpcyBzZWxlY3RlZCwg YGZyZWdzYCBjYW4gbmV2ZXIgYmUgTlVMTAotCSAqIGFuZCBhcmNoX2Z0cmFjZV9nZXRfcmVncyhm cmVncykgd2lsbCBhbHdheXMgZ2l2ZSBhIG5vbi1OVUxMIHB0X3JlZ3MKLQkgKiBpbiB3aGljaCB3 ZSBjYW4gc2FmZWx5IG1vZGlmeSB0aGUgTFIuCi0JICovCi0Jc3RydWN0IHB0X3JlZ3MgKnJlZ3Mg PSBhcmNoX2Z0cmFjZV9nZXRfcmVncyhmcmVncyk7Ci0JdW5zaWduZWQgbG9uZyAqcGFyZW50ID0g KHVuc2lnbmVkIGxvbmcgKikmcHJvY2VkdXJlX2xpbmtfcG9pbnRlcihyZWdzKTsKLQotCXByZXBh cmVfZnRyYWNlX3JldHVybihpcCwgcGFyZW50LCBmcmFtZV9wb2ludGVyKHJlZ3MpKTsKKwlwcmVw YXJlX2Z0cmFjZV9yZXR1cm4oaXAsICZmcmVncy0+bHIsIGZyZWdzLT5mcCk7CiB9CiAjZWxzZQog LyoKQEAgLTMyMyw2ICsyOTQsNiBAQCBpbnQgZnRyYWNlX2Rpc2FibGVfZnRyYWNlX2dyYXBoX2Nh bGxlcih2b2lkKQogewogCXJldHVybiBmdHJhY2VfbW9kaWZ5X2dyYXBoX2NhbGxlcihmYWxzZSk7 CiB9Ci0jZW5kaWYgLyogQ09ORklHX0RZTkFNSUNfRlRSQUNFX1dJVEhfUkVHUyAqLworI2VuZGlm IC8qIENPTkZJR19EWU5BTUlDX0ZUUkFDRV9XSVRIX0FSR1MgKi8KICNlbmRpZiAvKiBDT05GSUdf RFlOQU1JQ19GVFJBQ0UgKi8KICNlbmRpZiAvKiBDT05GSUdfRlVOQ1RJT05fR1JBUEhfVFJBQ0VS ICovCmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2tlcm5lbC9tb2R1bGUuYyBiL2FyY2gvYXJtNjQv a2VybmVsL21vZHVsZS5jCmluZGV4IDc2YjQxZTRjYTlmYS4uYWNkMGQ4ODNlOWNhIDEwMDY0NAot LS0gYS9hcmNoL2FybTY0L2tlcm5lbC9tb2R1bGUuYworKysgYi9hcmNoL2FybTY0L2tlcm5lbC9t b2R1bGUuYwpAQCAtNDk3LDkgKzQ5Nyw2IEBAIHN0YXRpYyBpbnQgbW9kdWxlX2luaXRfZnRyYWNl X3BsdChjb25zdCBFbGZfRWhkciAqaGRyLAogCiAJX19pbml0X3BsdCgmcGx0c1tGVFJBQ0VfUExU X0lEWF0sIEZUUkFDRV9BRERSKTsKIAotCWlmIChJU19FTkFCTEVEKENPTkZJR19EWU5BTUlDX0ZU UkFDRV9XSVRIX1JFR1MpKQotCQlfX2luaXRfcGx0KCZwbHRzW0ZUUkFDRV9SRUdTX1BMVF9JRFhd LCBGVFJBQ0VfUkVHU19BRERSKTsKLQogCW1vZC0+YXJjaC5mdHJhY2VfdHJhbXBvbGluZXMgPSBw bHRzOwogI2VuZGlmCiAJcmV0dXJuIDA7Ci0tIAoyLjMwLjIKCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlz dApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJh ZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg== 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 Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id AB5A9C67871 for ; Mon, 24 Oct 2022 22:29:36 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230257AbiJXW3e (ORCPT ); Mon, 24 Oct 2022 18:29:34 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43944 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230208AbiJXW2m (ORCPT ); Mon, 24 Oct 2022 18:28:42 -0400 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id A347F18A018 for ; Mon, 24 Oct 2022 13:51:02 -0700 (PDT) Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 2944D143D; Mon, 24 Oct 2022 07:09:08 -0700 (PDT) Received: from lakrids.cambridge.arm.com (usa-sjc-imap-foss1.foss.arm.com [10.121.207.14]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPA id AD7BD3F792; Mon, 24 Oct 2022 07:09:00 -0700 (PDT) From: Mark Rutland To: linux-kernel@vger.kernel.org Cc: catalin.marinas@arm.com, linux-arm-kernel@lists.infradead.org, mark.rutland@arm.com, mhiramat@kernel.org, revest@chromium.org, rostedt@goodmis.org, will@kernel.org Subject: [PATCH 4/4] ftrace: arm64: move from REGS to ARGS Date: Mon, 24 Oct 2022 15:08:46 +0100 Message-Id: <20221024140846.3555435-5-mark.rutland@arm.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20221024140846.3555435-1-mark.rutland@arm.com> References: <20221024140846.3555435-1-mark.rutland@arm.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This commit replaces arm64's support for FTRACE_WITH_REGS with support for FTRACE_WITH_ARGS. This removes some overhead and complexity, and removes some latent issues with inconsistent presentation of struct pt_regs (which can only be reliably saved/restored at exception boundaries). FTRACE_WITH_REGS has been supported on arm64 since commit: 3b23e4991fb66f6d ("arm64: implement ftrace with regs") As noted in the commit message, the major reasons for implementing FTRACE_WITH_REGS were: (1) To make it possible to use the ftrace graph tracer with pointer authentication, where it's necessary to snapshot/manipulate the LR before it is signed by the instrumented function. (2) To make it possible to implement LIVEPATCH in future, where we need to hook function entry before an instrumented function manipulates the stack or argument registers. Practically speaking, we need to preserve the argument/return registers, PC, LR, and SP. Neither of these need a struct pt_regs, and only require the set of registers which are live at function call/return boundaries. Our calling convention is defined by "Procedure Call Standard for the Arm® 64-bit Architecture (AArch64)" (AKA "AAPCS64"), which can currently be found at: https://github.com/ARM-software/abi-aa/blob/main/aapcs64/aapcs64.rst Per AAPCS64, all function call argument and return values are held in the following GPRs: * X0 - X7 : parameter / result registers * X8 : indirect result location register * SP : stack pointer (AKA SP) Additionally, ad function call boundaries, the following GPRs hold context/return information: * X29 : frame pointer (AKA FP) * X30 : link register (AKA LR) ... and for ftrace we need to capture the instrumented address: * PC : program counter No other GPRs are relevant, as none of the other arguments hold parameters or return values: * X9 - X17 : temporaries, may be clobbered * X18 : shadow call stack pointer (or temorary) * X19 - X28 : callee saved This patch implements FTRACE_WITH_ARGS for arm64, only saving/restoring the minimal set of registers necessary. This is always sufficient to manipulate control flow (e.g. for live-patching) or to manipulate function arguments and return values. As there is no longer a need to save different sets of registers for different features, we no longer need distinct `ftrace_caller` and `ftrace_regs_caller` trampolines. This allows the trampoline assembly to be simpler, and simplifies code which previously had to handle the two trampolines. I've tested this with the ftrace selftests, where there are no unexpected failures. Co-developed-by: Florent Revest Signed-off-by: Mark Rutland Signed-off-by: Florent Revest Cc: Catalin Marinas Cc: Masami Hiramatsu Cc: Steven Rostedt Cc: Will Deacon --- arch/arm64/Kconfig | 18 ++--- arch/arm64/Makefile | 2 +- arch/arm64/include/asm/ftrace.h | 70 ++++++++++++++++-- arch/arm64/kernel/asm-offsets.c | 13 ++++ arch/arm64/kernel/entry-ftrace.S | 117 ++++++++++++------------------- arch/arm64/kernel/ftrace.c | 37 ++-------- arch/arm64/kernel/module.c | 3 - 7 files changed, 138 insertions(+), 122 deletions(-) diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig index 505c8a1ccbe0..b6b3305ba701 100644 --- a/arch/arm64/Kconfig +++ b/arch/arm64/Kconfig @@ -181,8 +181,10 @@ config ARM64 select HAVE_DEBUG_KMEMLEAK select HAVE_DMA_CONTIGUOUS select HAVE_DYNAMIC_FTRACE + select HAVE_DYNAMIC_FTRACE_WITH_ARGS \ + if $(cc-option,-fpatchable-function-entry=2) select FTRACE_MCOUNT_USE_PATCHABLE_FUNCTION_ENTRY \ - if DYNAMIC_FTRACE_WITH_REGS + if DYNAMIC_FTRACE_WITH_ARGS select HAVE_EFFICIENT_UNALIGNED_ACCESS select HAVE_FAST_GUP select HAVE_FTRACE_MCOUNT_RECORD @@ -233,16 +235,16 @@ config ARM64 help ARM 64-bit (AArch64) Linux support. -config CLANG_SUPPORTS_DYNAMIC_FTRACE_WITH_REGS +config CLANG_SUPPORTS_DYNAMIC_FTRACE_WITH_ARGS def_bool CC_IS_CLANG # https://github.com/ClangBuiltLinux/linux/issues/1507 depends on AS_IS_GNU || (AS_IS_LLVM && (LD_IS_LLD || LD_VERSION >= 23600)) - select HAVE_DYNAMIC_FTRACE_WITH_REGS + select HAVE_DYNAMIC_FTRACE_WITH_ARGS -config GCC_SUPPORTS_DYNAMIC_FTRACE_WITH_REGS +config GCC_SUPPORTS_DYNAMIC_FTRACE_WITH_ARGS def_bool CC_IS_GCC depends on $(cc-option,-fpatchable-function-entry=2) - select HAVE_DYNAMIC_FTRACE_WITH_REGS + select HAVE_DYNAMIC_FTRACE_WITH_ARGS config 64BIT def_bool y @@ -1816,7 +1818,7 @@ config ARM64_PTR_AUTH_KERNEL # which is only understood by binutils starting with version 2.33.1. depends on LD_IS_LLD || LD_VERSION >= 23301 || (CC_IS_GCC && GCC_VERSION < 90100) depends on !CC_IS_CLANG || AS_HAS_CFI_NEGATE_RA_STATE - depends on (!FUNCTION_GRAPH_TRACER || DYNAMIC_FTRACE_WITH_REGS) + depends on (!FUNCTION_GRAPH_TRACER || DYNAMIC_FTRACE_WITH_ARGS) help If the compiler supports the -mbranch-protection or -msign-return-address flag (e.g. GCC 7 or later), then this option @@ -1826,7 +1828,7 @@ config ARM64_PTR_AUTH_KERNEL disabled with minimal loss of protection. This feature works with FUNCTION_GRAPH_TRACER option only if - DYNAMIC_FTRACE_WITH_REGS is enabled. + DYNAMIC_FTRACE_WITH_ARGS is enabled. config CC_HAS_BRANCH_PROT_PAC_RET # GCC 9 or later, clang 8 or later @@ -1924,7 +1926,7 @@ config ARM64_BTI_KERNEL depends on !CC_IS_GCC # https://github.com/llvm/llvm-project/commit/a88c722e687e6780dcd6a58718350dc76fcc4cc9 depends on !CC_IS_CLANG || CLANG_VERSION >= 120000 - depends on (!FUNCTION_GRAPH_TRACER || DYNAMIC_FTRACE_WITH_REGS) + depends on (!FUNCTION_GRAPH_TRACER || DYNAMIC_FTRACE_WITH_ARGS) help Build the kernel with Branch Target Identification annotations and enable enforcement of this for kernel code. When this option diff --git a/arch/arm64/Makefile b/arch/arm64/Makefile index 5e56d26a2239..b1202fa84bab 100644 --- a/arch/arm64/Makefile +++ b/arch/arm64/Makefile @@ -128,7 +128,7 @@ endif CHECKFLAGS += -D__aarch64__ -ifeq ($(CONFIG_DYNAMIC_FTRACE_WITH_REGS),y) +ifeq ($(CONFIG_DYNAMIC_FTRACE_WITH_ARGS),y) KBUILD_CPPFLAGS += -DCC_USING_PATCHABLE_FUNCTION_ENTRY CC_FLAGS_FTRACE := -fpatchable-function-entry=2 endif diff --git a/arch/arm64/include/asm/ftrace.h b/arch/arm64/include/asm/ftrace.h index 329dbbd4d50b..2691064d4e04 100644 --- a/arch/arm64/include/asm/ftrace.h +++ b/arch/arm64/include/asm/ftrace.h @@ -23,7 +23,7 @@ */ #define HAVE_FUNCTION_GRAPH_RET_ADDR_PTR -#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS +#ifdef CONFIG_DYNAMIC_FTRACE_WITH_ARGS #define ARCH_SUPPORTS_FTRACE_OPS 1 #else #define MCOUNT_ADDR ((unsigned long)_mcount) @@ -33,8 +33,7 @@ #define MCOUNT_INSN_SIZE AARCH64_INSN_SIZE #define FTRACE_PLT_IDX 0 -#define FTRACE_REGS_PLT_IDX 1 -#define NR_FTRACE_PLTS 2 +#define NR_FTRACE_PLTS 1 /* * Currently, gcc tends to save the link register after the local variables @@ -69,7 +68,7 @@ static inline unsigned long ftrace_call_adjust(unsigned long addr) * Adjust addr to point at the BL in the callsite. * See ftrace_init_nop() for the callsite sequence. */ - if (IS_ENABLED(CONFIG_DYNAMIC_FTRACE_WITH_REGS)) + if (IS_ENABLED(CONFIG_DYNAMIC_FTRACE_WITH_ARGS)) return addr + AARCH64_INSN_SIZE; /* * addr is the address of the mcount call instruction. @@ -78,10 +77,69 @@ static inline unsigned long ftrace_call_adjust(unsigned long addr) return addr; } -#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS +#ifdef CONFIG_DYNAMIC_FTRACE_WITH_ARGS struct dyn_ftrace; struct ftrace_ops; -struct ftrace_regs; + +#define arch_ftrace_get_regs(regs) NULL + +struct ftrace_regs { + /* x0 - x8 */ + unsigned long regs[9]; + unsigned long __unused; + + unsigned long fp; + unsigned long lr; + + unsigned long sp; + unsigned long pc; +}; + +static __always_inline unsigned long +ftrace_regs_get_instruction_pointer(const struct ftrace_regs *fregs) +{ + return fregs->pc; +} + +static __always_inline void +ftrace_regs_set_instruction_pointer(struct ftrace_regs *fregs, + unsigned long pc) +{ + fregs->pc = pc; +} + +static __always_inline unsigned long +ftrace_regs_get_stack_pointer(const struct ftrace_regs *fregs) +{ + return fregs->sp; +} + +static __always_inline unsigned long +ftrace_regs_get_argument(struct ftrace_regs *fregs, unsigned int n) +{ + if (n < 8) + return fregs->regs[n]; + return 0; +} + +static __always_inline unsigned long +ftrace_regs_get_return_value(const struct ftrace_regs *fregs) +{ + return fregs->regs[0]; +} + +static __always_inline void +ftrace_regs_set_return_value(struct ftrace_regs *fregs, + unsigned long ret) +{ + fregs->regs[0] = ret; +} + +static __always_inline void +ftrace_override_function_with_return(struct ftrace_regs *fregs) +{ + fregs->pc = fregs->lr; +} int ftrace_init_nop(struct module *mod, struct dyn_ftrace *rec); #define ftrace_init_nop ftrace_init_nop diff --git a/arch/arm64/kernel/asm-offsets.c b/arch/arm64/kernel/asm-offsets.c index 1197e7679882..2234624536d9 100644 --- a/arch/arm64/kernel/asm-offsets.c +++ b/arch/arm64/kernel/asm-offsets.c @@ -82,6 +82,19 @@ int main(void) DEFINE(S_STACKFRAME, offsetof(struct pt_regs, stackframe)); DEFINE(PT_REGS_SIZE, sizeof(struct pt_regs)); BLANK(); +#ifdef CONFIG_DYNAMIC_FTRACE_WITH_ARGS + DEFINE(FREGS_X0, offsetof(struct ftrace_regs, regs[0])); + DEFINE(FREGS_X2, offsetof(struct ftrace_regs, regs[2])); + DEFINE(FREGS_X4, offsetof(struct ftrace_regs, regs[4])); + DEFINE(FREGS_X6, offsetof(struct ftrace_regs, regs[6])); + DEFINE(FREGS_X8, offsetof(struct ftrace_regs, regs[8])); + DEFINE(FREGS_FP, offsetof(struct ftrace_regs, fp)); + DEFINE(FREGS_LR, offsetof(struct ftrace_regs, lr)); + DEFINE(FREGS_SP, offsetof(struct ftrace_regs, sp)); + DEFINE(FREGS_PC, offsetof(struct ftrace_regs, pc)); + DEFINE(FREGS_SIZE, sizeof(struct ftrace_regs)); + BLANK(); +#endif #ifdef CONFIG_COMPAT DEFINE(COMPAT_SIGFRAME_REGS_OFFSET, offsetof(struct compat_sigframe, uc.uc_mcontext.arm_r0)); DEFINE(COMPAT_RT_SIGFRAME_REGS_OFFSET, offsetof(struct compat_rt_sigframe, sig.uc.uc_mcontext.arm_r0)); diff --git a/arch/arm64/kernel/entry-ftrace.S b/arch/arm64/kernel/entry-ftrace.S index 795344ab4ec4..4d3050549aa6 100644 --- a/arch/arm64/kernel/entry-ftrace.S +++ b/arch/arm64/kernel/entry-ftrace.S @@ -13,83 +13,58 @@ #include #include -#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS +#ifdef CONFIG_DYNAMIC_FTRACE_WITH_ARGS /* * Due to -fpatchable-function-entry=2, the compiler has placed two NOPs before * the regular function prologue. For an enabled callsite, ftrace_init_nop() and * ftrace_make_call() have patched those NOPs to: * * MOV X9, LR - * BL - * - * ... where is either ftrace_caller or ftrace_regs_caller. + * BL ftrace_caller * * Each instrumented function follows the AAPCS, so here x0-x8 and x18-x30 are * live (x18 holds the Shadow Call Stack pointer), and x9-x17 are safe to * clobber. * - * We save the callsite's context into a pt_regs before invoking any ftrace - * callbacks. So that we can get a sensible backtrace, we create a stack record - * for the callsite and the ftrace entry assembly. This is not sufficient for - * reliable stacktrace: until we create the callsite stack record, its caller - * is missing from the LR and existing chain of frame records. + * We save the callsite's context into a struct ftrace_regs before invoking any + * ftrace callbacks. So that we can get a sensible backtrace, we create frame + * records for the callsite and the ftrace entry assembly. This is not + * sufficient for reliable stacktrace: until we create the callsite stack + * record, its caller is missing from the LR and existing chain of frame + * records. */ - .macro ftrace_regs_entry, allregs=0 - /* Make room for pt_regs, plus a callee frame */ - sub sp, sp, #(PT_REGS_SIZE + 16) - - /* Save function arguments (and x9 for simplicity) */ - stp x0, x1, [sp, #S_X0] - stp x2, x3, [sp, #S_X2] - stp x4, x5, [sp, #S_X4] - stp x6, x7, [sp, #S_X6] - stp x8, x9, [sp, #S_X8] - - /* Optionally save the callee-saved registers, always save the FP */ - .if \allregs == 1 - stp x10, x11, [sp, #S_X10] - stp x12, x13, [sp, #S_X12] - stp x14, x15, [sp, #S_X14] - stp x16, x17, [sp, #S_X16] - stp x18, x19, [sp, #S_X18] - stp x20, x21, [sp, #S_X20] - stp x22, x23, [sp, #S_X22] - stp x24, x25, [sp, #S_X24] - stp x26, x27, [sp, #S_X26] - stp x28, x29, [sp, #S_X28] - .else - str x29, [sp, #S_FP] - .endif - - /* Save the callsite's SP and LR */ - add x10, sp, #(PT_REGS_SIZE + 16) - stp x9, x10, [sp, #S_LR] +SYM_CODE_START(ftrace_caller) + bti c - /* Save the PC after the ftrace callsite */ - str x30, [sp, #S_PC] + /* Save original SP */ + mov x10, sp - /* Create a frame record for the callsite above pt_regs */ - stp x29, x9, [sp, #PT_REGS_SIZE] - add x29, sp, #PT_REGS_SIZE + /* Make room for ftrace regs, plus two frame records */ + sub sp, sp, #(FREGS_SIZE + 32) - /* Create our frame record within pt_regs. */ - stp x29, x30, [sp, #S_STACKFRAME] - add x29, sp, #S_STACKFRAME - .endm + /* Save function arguments */ + stp x0, x1, [sp, #FREGS_X0] + stp x2, x3, [sp, #FREGS_X2] + stp x4, x5, [sp, #FREGS_X4] + stp x6, x7, [sp, #FREGS_X6] + str x8, [sp, #FREGS_X8] -SYM_CODE_START(ftrace_regs_caller) - bti c - ftrace_regs_entry 1 - b ftrace_common -SYM_CODE_END(ftrace_regs_caller) + /* Save the callsite's FP, LR, SP */ + str x29, [sp, #FREGS_FP] + str x9, [sp, #FREGS_LR] + str x10, [sp, #FREGS_SP] -SYM_CODE_START(ftrace_caller) - bti c - ftrace_regs_entry 0 - b ftrace_common -SYM_CODE_END(ftrace_caller) + /* Save the PC after the ftrace callsite */ + str x30, [sp, #FREGS_PC] + + /* Create a frame record for the callsite above the ftrace regs */ + stp x29, x9, [sp, #FREGS_SIZE + 16] + add x29, sp, #FREGS_SIZE + 16 + + /* Create our frame record above the ftrace regs */ + stp x29, x30, [sp, #FREGS_SIZE] + add x29, sp, #FREGS_SIZE -SYM_CODE_START(ftrace_common) sub x0, x30, #AARCH64_INSN_SIZE // ip (callsite's BL insn) mov x1, x9 // parent_ip (callsite's LR) ldr_l x2, function_trace_op // op @@ -104,24 +79,24 @@ SYM_INNER_LABEL(ftrace_call, SYM_L_GLOBAL) * to restore x0-x8, x29, and x30. */ /* Restore function arguments */ - ldp x0, x1, [sp] - ldp x2, x3, [sp, #S_X2] - ldp x4, x5, [sp, #S_X4] - ldp x6, x7, [sp, #S_X6] - ldr x8, [sp, #S_X8] + ldp x0, x1, [sp, #FREGS_X0] + ldp x2, x3, [sp, #FREGS_X2] + ldp x4, x5, [sp, #FREGS_X4] + ldp x6, x7, [sp, #FREGS_X6] + ldr x8, [sp, #FREGS_X8] /* Restore the callsite's FP, LR, PC */ - ldr x29, [sp, #S_FP] - ldr x30, [sp, #S_LR] - ldr x9, [sp, #S_PC] + ldr x29, [sp, #FREGS_FP] + ldr x30, [sp, #FREGS_LR] + ldr x9, [sp, #FREGS_PC] /* Restore the callsite's SP */ - add sp, sp, #PT_REGS_SIZE + 16 + add sp, sp, #FREGS_SIZE + 32 ret x9 -SYM_CODE_END(ftrace_common) +SYM_CODE_END(ftrace_caller) -#else /* CONFIG_DYNAMIC_FTRACE_WITH_REGS */ +#else /* CONFIG_DYNAMIC_FTRACE_WITH_ARGS */ /* * Gcc with -pg will put the following code in the beginning of each function: @@ -293,7 +268,7 @@ SYM_FUNC_START(ftrace_graph_caller) mcount_exit SYM_FUNC_END(ftrace_graph_caller) #endif /* CONFIG_FUNCTION_GRAPH_TRACER */ -#endif /* CONFIG_DYNAMIC_FTRACE_WITH_REGS */ +#endif /* CONFIG_DYNAMIC_FTRACE_WITH_ARGS */ SYM_TYPED_FUNC_START(ftrace_stub) ret diff --git a/arch/arm64/kernel/ftrace.c b/arch/arm64/kernel/ftrace.c index 8745175f4a75..ed6b8a70c0d1 100644 --- a/arch/arm64/kernel/ftrace.c +++ b/arch/arm64/kernel/ftrace.c @@ -70,9 +70,6 @@ static struct plt_entry *get_ftrace_plt(struct module *mod, unsigned long addr) if (addr == FTRACE_ADDR) return &plt[FTRACE_PLT_IDX]; - if (addr == FTRACE_REGS_ADDR && - IS_ENABLED(CONFIG_DYNAMIC_FTRACE_WITH_REGS)) - return &plt[FTRACE_REGS_PLT_IDX]; #endif return NULL; } @@ -154,25 +151,7 @@ int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr) return ftrace_modify_code(pc, old, new, true); } -#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS -int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr, - unsigned long addr) -{ - unsigned long pc = rec->ip; - u32 old, new; - - if (!ftrace_find_callable_addr(rec, NULL, &old_addr)) - return -EINVAL; - if (!ftrace_find_callable_addr(rec, NULL, &addr)) - return -EINVAL; - - old = aarch64_insn_gen_branch_imm(pc, old_addr, - AARCH64_INSN_BRANCH_LINK); - new = aarch64_insn_gen_branch_imm(pc, addr, AARCH64_INSN_BRANCH_LINK); - - return ftrace_modify_code(pc, old, new, true); -} - +#ifdef CONFIG_DYNAMIC_FTRACE_WITH_ARGS /* * The compiler has inserted two NOPs before the regular function prologue. * All instrumented functions follow the AAPCS, so x0-x8 and x19-x30 are live, @@ -279,19 +258,11 @@ void prepare_ftrace_return(unsigned long self_addr, unsigned long *parent, #ifdef CONFIG_DYNAMIC_FTRACE -#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS +#ifdef CONFIG_DYNAMIC_FTRACE_WITH_ARGS void ftrace_graph_func(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *op, struct ftrace_regs *fregs) { - /* - * When DYNAMIC_FTRACE_WITH_REGS is selected, `fregs` can never be NULL - * and arch_ftrace_get_regs(fregs) will always give a non-NULL pt_regs - * in which we can safely modify the LR. - */ - struct pt_regs *regs = arch_ftrace_get_regs(fregs); - unsigned long *parent = (unsigned long *)&procedure_link_pointer(regs); - - prepare_ftrace_return(ip, parent, frame_pointer(regs)); + prepare_ftrace_return(ip, &fregs->lr, fregs->fp); } #else /* @@ -323,6 +294,6 @@ int ftrace_disable_ftrace_graph_caller(void) { return ftrace_modify_graph_caller(false); } -#endif /* CONFIG_DYNAMIC_FTRACE_WITH_REGS */ +#endif /* CONFIG_DYNAMIC_FTRACE_WITH_ARGS */ #endif /* CONFIG_DYNAMIC_FTRACE */ #endif /* CONFIG_FUNCTION_GRAPH_TRACER */ diff --git a/arch/arm64/kernel/module.c b/arch/arm64/kernel/module.c index 76b41e4ca9fa..acd0d883e9ca 100644 --- a/arch/arm64/kernel/module.c +++ b/arch/arm64/kernel/module.c @@ -497,9 +497,6 @@ static int module_init_ftrace_plt(const Elf_Ehdr *hdr, __init_plt(&plts[FTRACE_PLT_IDX], FTRACE_ADDR); - if (IS_ENABLED(CONFIG_DYNAMIC_FTRACE_WITH_REGS)) - __init_plt(&plts[FTRACE_REGS_PLT_IDX], FTRACE_REGS_ADDR); - mod->arch.ftrace_trampolines = plts; #endif return 0; -- 2.30.2