From patchwork Sun Aug 29 10:22:37 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Leo Yan X-Patchwork-Id: 12463863 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=-17.1 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=unavailable 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 944D4C4320E for ; Sun, 29 Aug 2021 10:26:02 +0000 (UTC) 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 mail.kernel.org (Postfix) with ESMTPS id 5261560E90 for ; Sun, 29 Aug 2021 10:26:02 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org 5261560E90 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linaro.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=lists.infradead.org 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=njmZ1Ahy7bUlmya11P2f+67cZbYEm6Lr7oK3Gc+OaAo=; b=a5QHmZrwL3kHwf E5ZDNf8mnUkt+L+0vNXunA8C/3VHBNaW2GBIUEO3LK7JzXzahxb7yDYoLCrjEptNA2rdISvgQ/AL7 LjG/1kgGRK9FpxyStABWn96OGgmm4KxSYTifqc/w8x4uD05oDpn4e5LrklIEfANObQkhRXqFr8MvC xbiuIwwTf3uhjERbmV7A2vQX+fbp0xz4mLudVPzzWB7k8nCaumPLMt2hX18ZXcSMY2SfXFZzoRu/G 2JQ01St/MeFvKZG1O+pqe0wOgnJbIf6cXOU9ig9OAFnvrDPVs15mO2AbrN36s3fBd97gg8J35xev1 Y1e0y66tTfu8cFartGbw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1mKHyF-00FNG8-9N; Sun, 29 Aug 2021 10:23:23 +0000 Received: from mail-pg1-x530.google.com ([2607:f8b0:4864:20::530]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1mKHxr-00FNDn-2A for linux-arm-kernel@lists.infradead.org; Sun, 29 Aug 2021 10:23:02 +0000 Received: by mail-pg1-x530.google.com with SMTP id q68so10416024pga.9 for ; Sun, 29 Aug 2021 03:22:58 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=ZCTED9Rc9DrmSApqJuoEoooUilGQMSmT0h7tdXp9XtE=; b=QufaFJu8mn5eZnC8eoPjdR2WJTrXvJonp/QxAFjYZP5Nsh82uxSJPA7zyDpSAzDlUE SdBU38oRyd6Tdep1zZ1Zfsmv9ECc4sTlKiKZDKz+vvL8G4Dd0RbIqbDHYaik+PbDdk6m IcU+d47a91XFLkmBo8CY8yJcY2JqOonklCqq05Se0jsXU3PP1js2+AdJHViVphQgM4X1 5pzH21d1dObhQicJQZ+QO3L3Ec6MdF6tgvQZaev5owukc50DfhKof2ppU2q8YS34yxb0 93pBYylYeszdet0oV8dFJlAcg9aZyxW0uqIUNYYOnKH/ybSNLxSVNzTC0r9q76+Zmce2 /5QQ== 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:mime-version:content-transfer-encoding; bh=ZCTED9Rc9DrmSApqJuoEoooUilGQMSmT0h7tdXp9XtE=; b=OpcnfoC1Ivp/RLhVxDAnYVaQX98sd0s4q2vdUrXvhBCbDiVeCsNFMZmWYjx2/aksew Td2hzRmV2U1jqQJdHLNAub05WDq8dct99LGlLMH6noFTOvGOMkSLVOBUhIdvfYzcOv3H NjVXf2RGjMbVgHgq+GT1mT3SC450MO5FKIWhxbd58WpthbUOmQxN6ctxNhhqOjsOWS2C gUB/PEsgKAkAX4rIDSv0TW1Y2Z+cGb/pUqUZVGzVMiNa/PxUvqsczC3KkpLE5HM4+XHT IrPER59k0N5vKmoE+JensniNxq3BEmrUr8aCZ9p64S60d0+or6Hp4N2b92RhL0fJusDl iOeQ== X-Gm-Message-State: AOAM531XqxVGSIIgoZb1H2CQzoA8CSOVGwM++HRE9d2P9buLTkqETCcZ lDm/2c/FQthH0SA1n5gHw8HvAA== X-Google-Smtp-Source: ABdhPJwZHsG7wyWCUEelUzrj0hy6XWetupcOjR0KhJsxKIDEkzgBBgA/+6dQ7sIOD8m6FxUzcpEF8g== X-Received: by 2002:a05:6a00:1245:b029:30f:2098:fcf4 with SMTP id u5-20020a056a001245b029030f2098fcf4mr17823079pfi.66.1630232578143; Sun, 29 Aug 2021 03:22:58 -0700 (PDT) Received: from localhost ([134.195.101.46]) by smtp.gmail.com with ESMTPSA id y5sm11266623pfa.5.2021.08.29.03.22.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 29 Aug 2021 03:22:57 -0700 (PDT) From: Leo Yan To: Arnaldo Carvalho de Melo , Adrian Hunter , James Clark , Mathieu Poirier , Suzuki K Poulose , Mike Leach , John Garry , Will Deacon , Peter Zijlstra , Ingo Molnar , Mark Rutland , Alexander Shishkin , Jiri Olsa , Namhyung Kim , Andi Kleen , coresight@lists.linaro.org, linux-arm-kernel@lists.infradead.org, linux-perf-users@vger.kernel.org, linux-kernel@vger.kernel.org, "Russell King (Oracle)" Cc: Leo Yan Subject: [PATCH v2 1/2] perf auxtrace: Add compat_auxtrace_mmap__{read_head|write_tail} Date: Sun, 29 Aug 2021 18:22:37 +0800 Message-Id: <20210829102238.19693-2-leo.yan@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210829102238.19693-1-leo.yan@linaro.org> References: <20210829102238.19693-1-leo.yan@linaro.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210829_032259_154138_C03EDC44 X-CRM114-Status: GOOD ( 30.26 ) 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: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org When perf runs in compat mode (kernel in 64-bit mode and the perf is in 32-bit mode), the 64-bit value atomicity in the user space cannot be assured, E.g. on some architectures, the 64-bit value accessing is split into two instructions, one is for the low 32-bit word accessing and another is for the high 32-bit word. This patch introduces weak functions compat_auxtrace_mmap__read_head() and compat_auxtrace_mmap__write_tail(), as their naming indicates, when perf tool works in compat mode, it uses these two functions to access the AUX head and tail. These two functions can allow the perf tool to work properly in certain conditions, e.g. when perf tool works in snapshot mode with only using AUX head pointer, or perf tool uses the AUX buffer and the incremented tail is not bigger than 4GB. When perf tool cannot handle the case when the AUX tail is bigger than 4GB, the function compat_auxtrace_mmap__write_tail() returns -1 and tells the caller to bail out for the error. These two functions are declared as weak attribute, this allows to implement arch specific functions if any arch can support the 64-bit value atomicity in compat mode. Suggested-by: Adrian Hunter Signed-off-by: Leo Yan Acked-by: Adrian Hunter --- tools/perf/util/auxtrace.c | 88 ++++++++++++++++++++++++++++++++++++-- tools/perf/util/auxtrace.h | 22 ++++++++-- 2 files changed, 103 insertions(+), 7 deletions(-) diff --git a/tools/perf/util/auxtrace.c b/tools/perf/util/auxtrace.c index f33f09b8b535..8d2865b9ade2 100644 --- a/tools/perf/util/auxtrace.c +++ b/tools/perf/util/auxtrace.c @@ -1669,6 +1669,82 @@ int perf_event__process_auxtrace_error(struct perf_session *session, return 0; } +/* + * In the compat mode kernel runs in 64-bit and perf tool runs in 32-bit mode, + * 32-bit perf tool cannot access 64-bit value atomically, which might lead to + * the issues caused by the below sequence on multiple CPUs: when perf tool + * accesses either the load operation or the store operation for 64-bit value, + * on some architectures the operation is divided into two instructions, one + * is for accessing the low 32-bit value and another is for the high 32-bit; + * thus these two user operations can give the kernel chances to access the + * 64-bit value, and thus leads to the unexpected load values. + * + * kernel (64-bit) user (32-bit) + * + * if (LOAD ->aux_tail) { --, LOAD ->aux_head_lo + * STORE $aux_data | ,---> + * FLUSH $aux_data | | LOAD ->aux_head_hi + * STORE ->aux_head --|-------` smp_rmb() + * } | LOAD $data + * | smp_mb() + * | STORE ->aux_tail_lo + * `-----------> + * STORE ->aux_tail_hi + * + * For this reason, it's impossible for the perf tool to work correctly when + * the AUX head or tail is bigger than 4GB (more than 32 bits length); and we + * can not simply limit the AUX ring buffer to less than 4GB, the reason is + * the pointers can be increased monotonically, whatever the buffer size it is, + * at the end the head and tail can be bigger than 4GB and carry out to the + * high 32-bit. + * + * To mitigate the issues and improve the user experience, we can allow the + * perf tool working in certain conditions and bail out with error if detect + * any overflow cannot be handled. + * + * For reading the AUX head, it reads out the values for three times, and + * compares the high 4 bytes of the values between the first time and the last + * time, if there has no change for high 4 bytes injected by the kernel during + * the user reading sequence, it's safe for use the second value. + * + * When compat_auxtrace_mmap__write_tail() detects any carrying in the high + * 32 bits, it means there have two store operations in user space and it cannot + * promise the atomicity for 64-bit write, so return '-1' in this case to tell + * the caller an overflow error has happened. + */ +u64 __weak compat_auxtrace_mmap__read_head(struct auxtrace_mmap *mm) +{ + struct perf_event_mmap_page *pc = mm->userpg; + u64 first, second, last; + u64 mask = (u64)(UINT32_MAX) << 32; + + do { + first = READ_ONCE(pc->aux_head); + /* Ensure all reads are done after we read the head */ + smp_rmb(); + second = READ_ONCE(pc->aux_head); + /* Ensure all reads are done after we read the head */ + smp_rmb(); + last = READ_ONCE(pc->aux_head); + } while ((first & mask) != (last & mask)); + + return second; +} + +int __weak compat_auxtrace_mmap__write_tail(struct auxtrace_mmap *mm, u64 tail) +{ + struct perf_event_mmap_page *pc = mm->userpg; + u64 mask = (u64)(UINT32_MAX) << 32; + + if (tail & mask) + return -1; + + /* Ensure all reads are done before we write the tail out */ + smp_mb(); + WRITE_ONCE(pc->aux_tail, tail); + return 0; +} + static int __auxtrace_mmap__read(struct mmap *map, struct auxtrace_record *itr, struct perf_tool *tool, process_auxtrace_t fn, @@ -1680,8 +1756,9 @@ static int __auxtrace_mmap__read(struct mmap *map, size_t size, head_off, old_off, len1, len2, padding; union perf_event ev; void *data1, *data2; + int kernel_is_64_bit = perf_env__kernel_is_64_bit(evsel__env(NULL)); - head = auxtrace_mmap__read_head(mm); + head = auxtrace_mmap__read_head(mm, kernel_is_64_bit); if (snapshot && auxtrace_record__find_snapshot(itr, mm->idx, mm, data, &head, &old)) @@ -1764,10 +1841,13 @@ static int __auxtrace_mmap__read(struct mmap *map, mm->prev = head; if (!snapshot) { - auxtrace_mmap__write_tail(mm, head); - if (itr->read_finish) { - int err; + int err; + + err = auxtrace_mmap__write_tail(mm, head, kernel_is_64_bit); + if (err < 0) + return err; + if (itr->read_finish) { err = itr->read_finish(itr, mm->idx); if (err < 0) return err; diff --git a/tools/perf/util/auxtrace.h b/tools/perf/util/auxtrace.h index d68a5e80b217..5f383908ca6e 100644 --- a/tools/perf/util/auxtrace.h +++ b/tools/perf/util/auxtrace.h @@ -440,23 +440,39 @@ struct auxtrace_cache; #ifdef HAVE_AUXTRACE_SUPPORT -static inline u64 auxtrace_mmap__read_head(struct auxtrace_mmap *mm) +u64 compat_auxtrace_mmap__read_head(struct auxtrace_mmap *mm); +int compat_auxtrace_mmap__write_tail(struct auxtrace_mmap *mm, u64 tail); + +static inline u64 auxtrace_mmap__read_head(struct auxtrace_mmap *mm, + int kernel_is_64_bit __maybe_unused) { struct perf_event_mmap_page *pc = mm->userpg; - u64 head = READ_ONCE(pc->aux_head); + u64 head; + +#if BITS_PER_LONG == 32 + if (kernel_is_64_bit) + return compat_auxtrace_mmap__read_head(mm); +#endif + head = READ_ONCE(pc->aux_head); /* Ensure all reads are done after we read the head */ smp_rmb(); return head; } -static inline void auxtrace_mmap__write_tail(struct auxtrace_mmap *mm, u64 tail) +static inline int auxtrace_mmap__write_tail(struct auxtrace_mmap *mm, u64 tail, + int kernel_is_64_bit __maybe_unused) { struct perf_event_mmap_page *pc = mm->userpg; +#if BITS_PER_LONG == 32 + if (kernel_is_64_bit) + return compat_auxtrace_mmap__write_tail(mm, tail); +#endif /* Ensure all reads are done before we write the tail out */ smp_mb(); WRITE_ONCE(pc->aux_tail, tail); + return 0; } int auxtrace_mmap__mmap(struct auxtrace_mmap *mm, From patchwork Sun Aug 29 10:22:38 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Leo Yan X-Patchwork-Id: 12463865 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=-17.1 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,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 5CB95C432BE for ; Sun, 29 Aug 2021 10:26:08 +0000 (UTC) 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 mail.kernel.org (Postfix) with ESMTPS id 2851760E73 for ; Sun, 29 Aug 2021 10:26:08 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org 2851760E73 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linaro.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=lists.infradead.org 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=O5kEIfVYlV5xFa3XW1Bo8Fd0bQ+08ZX3b0ZsP00fcDQ=; b=iDzQIlemBq2JPw 48eMT4uS6JUA/EfdFf6VHEaIVB40J36UebsBHutvUet8EKVJHYRG1eSzXgU0EabHqml0+n2Ne8WZn xj05h9Yw6U0FX+qgLrPokscQIAGSfJGqvlGU3t9ASXGgvCZvHFgxg3CrMF6t2y2YYt0Frm1s5R8Cm nnVA8oaoW0f2O9PIFmm+F+ZysWclOu9DTCH+eyvEZTg7a9lsJNb0Q3MOtr4fA/ZJGvv//hrxboEyo RuEdaQV8VXgP0J0cbgmsCIBSKvzRo5R160ju1ULEvtIS8kp3eOWgYGdVqfHyoWTflpDp1tDaB5C5I cymu5TEYNeOevazP2n/Q==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1mKHyP-00FNGN-H9; Sun, 29 Aug 2021 10:23:33 +0000 Received: from mail-pf1-x429.google.com ([2607:f8b0:4864:20::429]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1mKHxv-00FNEj-TC for linux-arm-kernel@lists.infradead.org; Sun, 29 Aug 2021 10:23:05 +0000 Received: by mail-pf1-x429.google.com with SMTP id 2so9751946pfo.8 for ; Sun, 29 Aug 2021 03:23:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=+tIlR3yAnihc/8N68dAkVCR/HC1yo91sWJBQN/lr8bM=; b=EpBQc1jEbWZQDKA/Hd96/dSblduNlrZBfncFOQFXZpBZasUh1zyFsHwfMwKgYRKn2h q4NE7GP+NXGct8xScaCRIZnWy+hcmxCEq/nCYqgCQNL6rwF/YRU1M6f1fD4O4cbNoTzz uXwFsacODV17YlAKMBclA++GTdimgD4pqTRn5Q4GCyKHe6AgjXLUHb8GqfqPlIGscUaX ZgDzHZA0qamkZz1/SgpKYCbiJR76MPDn6r/4PVd/QIasX3mNJggJd6mDMt0CtC5TAb4i KmmVTatyoe7/Mi9gAG1PbwKdoNzQK3A0UihvZVjffBNZQkyZ5IEgzccZ6tRbr9QFbn7X 5f6g== 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:mime-version:content-transfer-encoding; bh=+tIlR3yAnihc/8N68dAkVCR/HC1yo91sWJBQN/lr8bM=; b=f3La5CfRFTmxmmvgnnI5MbSQqlWoJUciBxSH20k3woc+JbxW+ItAiexgQVPxLVvma8 /JQsvAsZdaLUx2P0vrNetljwZrHW7VZ5XbV5slEPf+m9pkhy+63XsNBXdLK6LherU5kb nXDW/8XcRIJPn40C5y0lNeJKi8wUquDY8QjGFZ6p66Ur/blLED6bWqGTu7eeTs0uWsoG iEOjOioto/9X1fVAac/zPH31WkUpiokj6lm4OjvzTqBf7H+GJn3MEham/XB8Pyk0obH1 rtVQ/VdU+dk3Q8ChJaUeYGbwPw1auboW9f6vPnC8zgFaYSqNSqV6eVbwgHiT8PdIyMyi WeQg== X-Gm-Message-State: AOAM530PIm0TyFALT4+ZuJGANqMICvZmCvvZqOyVMRorpfSuKJm/A99B UjBQlThjgHluX1grfW56NAstXQ== X-Google-Smtp-Source: ABdhPJx0z9GdJsy4ggFkGrduZsKKGG/vfDnVoFB9KZKLY9yy2wtvbqbnc5phggOaYFxXoxCi8NiAQQ== X-Received: by 2002:a62:8603:0:b029:3c8:3fdb:4aea with SMTP id x3-20020a6286030000b02903c83fdb4aeamr17882261pfd.6.1630232583070; Sun, 29 Aug 2021 03:23:03 -0700 (PDT) Received: from localhost ([134.195.101.46]) by smtp.gmail.com with ESMTPSA id b20sm11404522pfl.9.2021.08.29.03.23.01 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 29 Aug 2021 03:23:02 -0700 (PDT) From: Leo Yan To: Arnaldo Carvalho de Melo , Adrian Hunter , James Clark , Mathieu Poirier , Suzuki K Poulose , Mike Leach , John Garry , Will Deacon , Peter Zijlstra , Ingo Molnar , Mark Rutland , Alexander Shishkin , Jiri Olsa , Namhyung Kim , Andi Kleen , coresight@lists.linaro.org, linux-arm-kernel@lists.infradead.org, linux-perf-users@vger.kernel.org, linux-kernel@vger.kernel.org, "Russell King (Oracle)" Cc: Leo Yan Subject: [PATCH v2 2/2] perf auxtrace arm: Support compat_auxtrace_mmap__{read_head|write_tail} Date: Sun, 29 Aug 2021 18:22:38 +0800 Message-Id: <20210829102238.19693-3-leo.yan@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210829102238.19693-1-leo.yan@linaro.org> References: <20210829102238.19693-1-leo.yan@linaro.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210829_032303_988226_253AB76A X-CRM114-Status: GOOD ( 15.27 ) 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: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org When the tool runs with compat mode on Arm platform, the kernel is in 64-bit mode and user space is in 32-bit mode; the user space can use instructions "ldrd" and "strd" for 64-bit value atomicity. This patch adds compat_auxtrace_mmap__{read_head|write_tail} for arm building, it uses "ldrd" and "strd" instructions to ensure accessing atomicity for aux head and tail. The file arch/arm/util/auxtrace.c is built for arm and arm64 building, these two functions are not needed for arm64, so check the compiler macro "__arm__" to only include them for arm building. Signed-off-by: Leo Yan Reviewed-by: James Clark Tested-by: James Clark --- tools/perf/arch/arm/util/auxtrace.c | 32 +++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/tools/perf/arch/arm/util/auxtrace.c b/tools/perf/arch/arm/util/auxtrace.c index b187bddbd01a..c7c7ec0812d5 100644 --- a/tools/perf/arch/arm/util/auxtrace.c +++ b/tools/perf/arch/arm/util/auxtrace.c @@ -107,3 +107,35 @@ struct auxtrace_record *err = 0; return NULL; } + +#if defined(__arm__) +u64 compat_auxtrace_mmap__read_head(struct auxtrace_mmap *mm) +{ + struct perf_event_mmap_page *pc = mm->userpg; + u64 result; + + __asm__ __volatile__( +" ldrd %0, %H0, [%1]" + : "=&r" (result) + : "r" (&pc->aux_head), "Qo" (pc->aux_head) + ); + + return result; +} + +int compat_auxtrace_mmap__write_tail(struct auxtrace_mmap *mm, u64 tail) +{ + struct perf_event_mmap_page *pc = mm->userpg; + + /* Ensure all reads are done before we write the tail out */ + smp_mb(); + + __asm__ __volatile__( +" strd %2, %H2, [%1]" + : "=Qo" (pc->aux_tail) + : "r" (&pc->aux_tail), "r" (tail) + ); + + return 0; +} +#endif