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 kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 026D5C83F17 for ; Fri, 18 Jul 2025 14:34:10 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 979E86B00A4; Fri, 18 Jul 2025 10:34:10 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 9519B6B00A6; Fri, 18 Jul 2025 10:34:10 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 88EDA6B00A8; Fri, 18 Jul 2025 10:34:10 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0014.hostedemail.com [216.40.44.14]) by kanga.kvack.org (Postfix) with ESMTP id 78B8C6B00A4 for ; Fri, 18 Jul 2025 10:34:10 -0400 (EDT) Received: from smtpin05.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay02.hostedemail.com (Postfix) with ESMTP id 4112512F1BF for ; Fri, 18 Jul 2025 14:34:10 +0000 (UTC) X-FDA: 83677630260.05.E17D1FD Received: from mail-oo1-f50.google.com (mail-oo1-f50.google.com [209.85.161.50]) by imf28.hostedemail.com (Postfix) with ESMTP id 9B836C0006 for ; Fri, 18 Jul 2025 14:34:07 +0000 (UTC) Authentication-Results: imf28.hostedemail.com; dkim=pass header.d=bytedance.com header.s=google header.b=cVcr21PL; spf=pass (imf28.hostedemail.com: domain of cuiyunhui@bytedance.com designates 209.85.161.50 as permitted sender) smtp.mailfrom=cuiyunhui@bytedance.com; dmarc=pass (policy=quarantine) header.from=bytedance.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1752849248; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=bWzhDhdiFr0536BRqzyoEm8becCS9ZtrzmuFNx2GoNA=; b=G3Pq1SGRGFzJh4vIdB4NKNJ5YivJKdRUOr5mslFZhYTbuATsx9G4mfRuo4C/Coth5+pgGw 2ghl7PN866x2pffVUjCfbYbv9I6xcqgqAqaqDn36gcodzrULsq6cJE2ASnRMh5P5TORmuk cnJnkc4cRg/KxEKeq+bpsyJwfLLEWHw= ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1752849248; a=rsa-sha256; cv=none; b=PfMz39PWqCZC7XfmLlYN3gooETXYAXo2BkpzoedSWC+R0+QXmiBP07oMXyIciwt8L0qLdx Zrs4tMb32aZBDiR+yI8XGc/X2WE3GwUg/wqNfyvXSLpEPIxhoxwZ2+t4ZSlGkc0j/1Vepb Ms3GNR/OKT3rmEkIqKJqAfteLIW3FGc= ARC-Authentication-Results: i=1; imf28.hostedemail.com; dkim=pass header.d=bytedance.com header.s=google header.b=cVcr21PL; spf=pass (imf28.hostedemail.com: domain of cuiyunhui@bytedance.com designates 209.85.161.50 as permitted sender) smtp.mailfrom=cuiyunhui@bytedance.com; dmarc=pass (policy=quarantine) header.from=bytedance.com Received: by mail-oo1-f50.google.com with SMTP id 006d021491bc7-615913ff67fso1365972eaf.0 for ; Fri, 18 Jul 2025 07:34:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance.com; s=google; t=1752849246; x=1753454046; darn=kvack.org; h=content-transfer-encoding:cc:to:subject:message-id:date:from :in-reply-to:references:mime-version:from:to:cc:subject:date :message-id:reply-to; bh=bWzhDhdiFr0536BRqzyoEm8becCS9ZtrzmuFNx2GoNA=; b=cVcr21PLlgJyT5/NcR2bEIZbSEnHBokeB1wChDNLW4KeVpG8YiXscLJY014S9lyjLU 3xyvaNoVqsXCVmHLc4xRnNCW8ZbsgYqLQYl67rtZzsuy7ot9NT/sHzfQEM/VM3aQSs4I Y+156nLJqm6kEaHozRwjE2C9mr/ZMkubdqH7OLbkpZRryfK4+qxH4IKTqywEQUQx8iN7 fAiQSSUG6MK2fQqPF6J03Hgo1oLaav2XBohty193kI6Vxyt8ZE9e2NEeLlCaEMRA+viP MHDSenAy/LR18l4cMeD/PmAau6sTWiYa0+oJbKGYSesHMF11jxR/6fCkOX/8k/tw6Ql7 wsRg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1752849246; x=1753454046; h=content-transfer-encoding:cc:to:subject:message-id:date:from :in-reply-to:references:mime-version:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=bWzhDhdiFr0536BRqzyoEm8becCS9ZtrzmuFNx2GoNA=; b=tKed0bIOu35o2nTjooUtodXD+VqOTDiGFjA2iCkuv/ORPrl1mL3IOtULv/DCs2gJnO 81EgScbSuVw40lF21lOFDxfLQjuu1Y7LXfIYvVLpqs8HTJ3roWXecfGedyPdpNrsV52z AYrVp9CJ06uzjet/2QhIS+r7XlxyYJvi5k39N6EmDhoqZitx0h9voEPj+yUzc7Ced0Zl zDcFW3JkwGvz8TPBeauhYzuAnDSxA4nHCAXFuWhCt/2YAiRSe1dXUCTnh444+aTBpL+j UkPS8PF6P5GBcG3FqdU7el1ijhAGBhnc+IfTyNF7UGCG2iVU42NrC/wjJLBqxSGJzPhU 6AUA== X-Forwarded-Encrypted: i=1; AJvYcCW6ozpVLlWhSpAzuizuDKBKLaiHVA162aMffklIRjci8mIdpDMO6q1DyamLx26B2iFb6SqgQZOtHg==@kvack.org X-Gm-Message-State: AOJu0YxjykC2/dxr/YRf1VUFzA+ghaEUzc5zywbA74+Tav5nC+i4Wr+j bxjo/syZkWvWPAAV5ZsFPX1RvFW2fBKCh4NRsX1sLbI8J+2zwsNHIrrq3sRaf29+xpn4o7e2QAf LyQq86gu8wyragmmsk4oLOvY60yAp8eyxLffZJBzKEw== X-Gm-Gg: ASbGncsh7VbeOg+6+4qDAJxODrjpJS4GbKJt9kKbpJJRuEkRD1yas2pzXK4s+r5voRf ++aKoqHNY9K3alA0TLznwgKlNAb68FIiNNf3xRZ0uEJEB6utT1k4Jzw5uvuqm1ID5vv/JQeKIxv Oq4y2+D+frzWaU4H7Rs8qPNBD2Zzn1aAcghlhDulLSUgvFpG9zbag4RC54PMxcbgxm7292Yoy7S XIiBW4PbA== X-Google-Smtp-Source: AGHT+IEHkurpOPtUp6OR3kn00/uY/HZ2UhpECPN3W/Tg9e2NmMIkABeCYHxhO9+UZXpYExhWb/47mYBBDH6C49i9MLg= X-Received: by 2002:a05:6820:4de7:b0:611:adce:2cb4 with SMTP id 006d021491bc7-615accb4d53mr4933477eaf.3.1752849246312; Fri, 18 Jul 2025 07:34:06 -0700 (PDT) MIME-Version: 1.0 References: <20250618034328.21904-1-cuiyunhui@bytedance.com> <20250618034328.21904-2-cuiyunhui@bytedance.com> <404d38d7-f21b-4c97-b851-8b331deb3f8a@ghiti.fr> In-Reply-To: <404d38d7-f21b-4c97-b851-8b331deb3f8a@ghiti.fr> From: yunhui cui Date: Fri, 18 Jul 2025 22:33:55 +0800 X-Gm-Features: Ac12FXxpxLAOCgYhedquCSjid6kKOf5qoRGghZ8OElxrVL9g9z3nooKBwWcqkL4 Message-ID: Subject: Re: [External] Re: [PATCH RFC 2/2] riscv: introduce percpu.h into include/asm To: Alexandre Ghiti Cc: yury.norov@gmail.com, linux@rasmusvillemoes.dk, paul.walmsley@sifive.com, palmer@dabbelt.com, aou@eecs.berkeley.edu, linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, dennis@kernel.org, tj@kernel.org, cl@gentwo.org, linux-mm@kvack.org Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable X-Rspamd-Server: rspam03 X-Rspamd-Queue-Id: 9B836C0006 X-Stat-Signature: z64un9dfqyhhw7ec43ojauzhdx7o5ino X-Rspam-User: X-HE-Tag: 1752849247-379442 X-HE-Meta: U2FsdGVkX183JC7VqaK9uLt11sptAs4FctqYpDIZMzyw5DKol2OEfByEWz8k76Imv6/js+dLprV1Ctf53gPUtLSZKXpYf9eKS0m5VjeBxeATjPByB3SH3/eOy/kOFuvqc3zHxXuUqGPSyYjBRpUR2PSTvCyxBp5OPa07xuw/YH5JlLsxbzD9TDtYeoMh2i4Z7WDWs28Z8lahO9aaBrYH5A5KSYTyIPvo1TfveBk1vieMSWQsLjqKe4PmSmA0lIIPkYDcgoDS1j2kbKuWZRfpTbyd43FcghzlLQnAuyzOnTutHUtHihTRPSytq1a0ydjX6ZMXGh7hNgTN7tKImow7Mr7nkdGphMcpfL1XLDDJWkhVdbDPXX3O1OKNspVdut3aTVhIpRir6N1uXKmpBEEgXovcQK/eTze955sWuggik5CP5QbflWl8TXhwwmfJ+3fOq46nm1sprKyIsInJ6QpmYLOVTsWG+4rcqloNMV2R+FGgAPCWDeNvm8NNh+PhkzO61Yq2/cq+qaYtyxyGp4CTbhHIGqXc9eMYZbD448kf0aMVZacl+J6fNsiQy1gt76YzzMeUGVWUpKnT0OPBjKvuxn+ZzRmiDMT+W+jWp7Zy+bpmfcjpjJMsGfWt1rcBYGo9HVuSHFrA7dzRku5sL3qQV57kwWvSqwXgSUN5fc192WQ7vWaE7HRyLK81BDaucGRFzeOLqfL7m0pARzgL54FrFkzUr66rpBYeEA8INX6omrZp3SY1O850q/wxMWNhrUxhi1/KeOaP44s1l2HRzTMVkAIId4emK7WrImTrP3STHWrrxbhqjmqq2Wu9f66DUYW53EhZOm+lUJCWoLEdUU9ZSkC1jUvUVXECVt0WN063Xeu7F8i523tgOKDnbEuhFOmuCeBVIHL4qchABrayF6fdyRkWvin7gHZiccpq2YqmbqKRA//WJtI+otp75QJWZulTYCqTiXSs67/E0ZSCwjN QrEv7AXR xd/RWQP9z/0ScCyHHhQL7fSzpnsjShhFWyHD4wzdaU53VYVrUYZd8/+UKIeEHonVXoch0GaQsOpyJRNsWekZKL3VvMkvLZ9M4tvBluZDsHiKIn8EoUx2NoPBsOQm6gVu/3+VnPXvOJKb9GYluHL97C+0s8jCtEYlm7snT6yHDNIVwACm7vFVzSbag5psErsTxyj1VoOkz6PN0TFzZtixYjCcDCfZJubL7EnT8W4gD/dDLZhcMYFBXlWPmRVXNTp0iqDx5SE9uTV1D2ndSZ1boyz5gPKM5QWHSzsTZ5Hnotj5y6a1zBfGgh3HoO33PeAuvm0T9i6KMDJlHQuXcHGOcsZkYf0GnEKKgs8KcBPDjGBGIJ9iy70S3DYOlYZuQzsaaIh+r X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: Hi Alex=EF=BC=8C On Fri, Jul 18, 2025 at 10:23=E2=80=AFPM Alexandre Ghiti wr= ote: > > Hi Yunhui, > > On 7/18/25 08:40, yunhui cui wrote: > > Hi Alex, > > > > On Thu, Jul 17, 2025 at 9:06=E2=80=AFPM Alexandre Ghiti = wrote: > >> On 7/17/25 15:04, Alexandre Ghiti wrote: > >>> Hi Yunhui, > >>> > >>> On 6/18/25 05:43, Yunhui Cui wrote: > >>>> Current percpu operations rely on generic implementations, where > >>>> raw_local_irq_save() introduces substantial overhead. Optimization > >>>> is achieved through atomic operations and preemption disabling. > >>>> > >>>> Signed-off-by: Yunhui Cui > >>>> --- > >>>> arch/riscv/include/asm/percpu.h | 138 +++++++++++++++++++++++++++= +++++ > >>>> 1 file changed, 138 insertions(+) > >>>> create mode 100644 arch/riscv/include/asm/percpu.h > >>>> > >>>> diff --git a/arch/riscv/include/asm/percpu.h > >>>> b/arch/riscv/include/asm/percpu.h > >>>> new file mode 100644 > >>>> index 0000000000000..423c0d01f874c > >>>> --- /dev/null > >>>> +++ b/arch/riscv/include/asm/percpu.h > >>>> @@ -0,0 +1,138 @@ > >>>> +/* SPDX-License-Identifier: GPL-2.0-only */ > >>>> + > >>>> +#ifndef __ASM_PERCPU_H > >>>> +#define __ASM_PERCPU_H > >>>> + > >>>> +#include > >>>> + > >>>> +#define PERCPU_RW_OPS(sz) \ > >>>> +static inline unsigned long __percpu_read_##sz(void *ptr) \ > >>>> +{ \ > >>>> + return READ_ONCE(*(u##sz *)ptr); \ > >>>> +} \ > >>>> + \ > >>>> +static inline void __percpu_write_##sz(void *ptr, unsigned long > >>>> val) \ > >>>> +{ \ > >>>> + WRITE_ONCE(*(u##sz *)ptr, (u##sz)val); \ > >>>> +} > >>>> + > >>>> +#define __PERCPU_AMO_OP_CASE(sfx, name, sz, amo_insn) \ > >>>> +static inline void \ > >>>> +__percpu_##name##_amo_case_##sz(void *ptr, unsigned long val) = \ > >>>> +{ \ > >>>> + asm volatile ( \ > >>>> + "amo" #amo_insn #sfx " zero, %[val], %[ptr]" \ > >>>> + : [ptr] "+A" (*(u##sz *)ptr) \ > >>>> + : [val] "r" ((u##sz)(val)) \ > >>>> + : "memory"); \ > >>>> +} > >>>> + > >>>> +#define __PERCPU_AMO_RET_OP_CASE(sfx, name, sz, amo_insn) \ > >>>> +static inline u##sz \ > >>>> +__percpu_##name##_return_amo_case_##sz(void *ptr, unsigned long > >>>> val) \ > >>>> +{ \ > >>>> + register u##sz ret; \ > >>>> + \ > >>>> + asm volatile ( \ > >>>> + "amo" #amo_insn #sfx " %[ret], %[val], %[ptr]" \ > >>>> + : [ptr] "+A" (*(u##sz *)ptr), [ret] "=3Dr" (ret) \ > >>>> + : [val] "r" ((u##sz)(val)) \ > >>>> + : "memory"); \ > >>>> + \ > >>>> + return ret + val; \ > >>>> +} > >>>> + > >>>> +#define PERCPU_OP(name, amo_insn) \ > >>>> + __PERCPU_AMO_OP_CASE(.b, name, 8, amo_insn) \ > >>>> + __PERCPU_AMO_OP_CASE(.h, name, 16, amo_insn) \ > >>>> + __PERCPU_AMO_OP_CASE(.w, name, 32, amo_insn) \ > >>>> + __PERCPU_AMO_OP_CASE(.d, name, 64, amo_insn) \ > >>>> + > >>>> +#define PERCPU_RET_OP(name, amo_insn) \ > >>>> + __PERCPU_AMO_RET_OP_CASE(.b, name, 8, amo_insn) \ > >>>> + __PERCPU_AMO_RET_OP_CASE(.h, name, 16, amo_insn) \ > >>>> + __PERCPU_AMO_RET_OP_CASE(.w, name, 32, amo_insn) \ > >>>> + __PERCPU_AMO_RET_OP_CASE(.d, name, 64, amo_insn) > >>>> + > >>>> +PERCPU_RW_OPS(8) > >>>> +PERCPU_RW_OPS(16) > >>>> +PERCPU_RW_OPS(32) > >>>> +PERCPU_RW_OPS(64) > >>>> + > >>>> +PERCPU_OP(add, add) > >>>> +PERCPU_OP(andnot, and) > >>>> +PERCPU_OP(or, or) > >>>> +PERCPU_RET_OP(add, add) > >>>> + > >>>> +#undef PERCPU_RW_OPS > >>>> +#undef __PERCPU_AMO_OP_CASE > >>>> +#undef __PERCPU_AMO_RET_OP_CASE > >>>> +#undef PERCPU_OP > >>>> +#undef PERCPU_RET_OP > >>>> + > >>>> +#define _pcp_protect(op, pcp, ...) \ > >>>> +({ \ > >>>> + preempt_disable_notrace(); \ > >>>> + op(raw_cpu_ptr(&(pcp)), __VA_ARGS__); \ > >>>> + preempt_enable_notrace(); \ > >>>> +}) > >>>> + > >>>> +#define _pcp_protect_return(op, pcp, args...) \ > >>>> +({ \ > >>>> + typeof(pcp) __retval; \ > >>>> + preempt_disable_notrace(); \ > >>>> + __retval =3D (typeof(pcp))op(raw_cpu_ptr(&(pcp)), ##args); \ > >>>> + preempt_enable_notrace(); \ > >>>> + __retval; \ > >>>> +}) > >>>> + > >>>> +#define this_cpu_read_1(pcp) _pcp_protect_return(__percpu_read_8, p= cp) > >>>> +#define this_cpu_read_2(pcp) _pcp_protect_return(__percpu_read_16, = pcp) > >>>> +#define this_cpu_read_4(pcp) _pcp_protect_return(__percpu_read_32, = pcp) > >>>> +#define this_cpu_read_8(pcp) _pcp_protect_return(__percpu_read_64, = pcp) > >>>> + > >>>> +#define this_cpu_write_1(pcp, val) _pcp_protect(__percpu_write_8, > >>>> pcp, (unsigned long)val) > >>>> +#define this_cpu_write_2(pcp, val) _pcp_protect(__percpu_write_16, > >>>> pcp, (unsigned long)val) > >>>> +#define this_cpu_write_4(pcp, val) _pcp_protect(__percpu_write_32, > >>>> pcp, (unsigned long)val) > >>>> +#define this_cpu_write_8(pcp, val) _pcp_protect(__percpu_write_64, > >>>> pcp, (unsigned long)val) > >>>> + > >>>> +#define this_cpu_add_1(pcp, val) > >>>> _pcp_protect(__percpu_add_amo_case_8, pcp, val) > >>>> +#define this_cpu_add_2(pcp, val) > >>>> _pcp_protect(__percpu_add_amo_case_16, pcp, val) > >>>> +#define this_cpu_add_4(pcp, val) > >>>> _pcp_protect(__percpu_add_amo_case_32, pcp, val) > >>>> +#define this_cpu_add_8(pcp, val) > >>>> _pcp_protect(__percpu_add_amo_case_64, pcp, val) > >>>> + > >>>> +#define this_cpu_add_return_1(pcp, val) \ > >>>> +_pcp_protect_return(__percpu_add_return_amo_case_8, pcp, val) > >>>> + > >>>> +#define this_cpu_add_return_2(pcp, val) \ > >>>> +_pcp_protect_return(__percpu_add_return_amo_case_16, pcp, val) > >>>> + > >>>> +#define this_cpu_add_return_4(pcp, val) \ > >>>> +_pcp_protect_return(__percpu_add_return_amo_case_32, pcp, val) > >>>> + > >>>> +#define this_cpu_add_return_8(pcp, val) \ > >>>> +_pcp_protect_return(__percpu_add_return_amo_case_64, pcp, val) > >>>> + > >>>> +#define this_cpu_and_1(pcp, val) > >>>> _pcp_protect(__percpu_andnot_amo_case_8, pcp, ~val) > >>>> +#define this_cpu_and_2(pcp, val) > >>>> _pcp_protect(__percpu_andnot_amo_case_16, pcp, ~val) > >>>> +#define this_cpu_and_4(pcp, val) > >>>> _pcp_protect(__percpu_andnot_amo_case_32, pcp, ~val) > >>>> +#define this_cpu_and_8(pcp, val) > >>>> _pcp_protect(__percpu_andnot_amo_case_64, pcp, ~val) > >>> > >>> Why do we define __percpu_andnot based on amoand, and use > >>> __percpu_andnot with ~val here? Can't we just define __percpu_and? > > > What about that ^? > > > >>> > >>>> + > >>>> +#define this_cpu_or_1(pcp, val) _pcp_protect(__percpu_or_amo_case_8= , > >>>> pcp, val) > >>>> +#define this_cpu_or_2(pcp, val) > >>>> _pcp_protect(__percpu_or_amo_case_16, pcp, val) > >>>> +#define this_cpu_or_4(pcp, val) > >>>> _pcp_protect(__percpu_or_amo_case_32, pcp, val) > >>>> +#define this_cpu_or_8(pcp, val) > >>>> _pcp_protect(__percpu_or_amo_case_64, pcp, val) > >>>> + > >>>> +#define this_cpu_xchg_1(pcp, val) _pcp_protect_return(xchg_relaxed, > >>>> pcp, val) > >>>> +#define this_cpu_xchg_2(pcp, val) _pcp_protect_return(xchg_relaxed, > >>>> pcp, val) > >>>> +#define this_cpu_xchg_4(pcp, val) _pcp_protect_return(xchg_relaxed, > >>>> pcp, val) > >>>> +#define this_cpu_xchg_8(pcp, val) _pcp_protect_return(xchg_relaxed, > >>>> pcp, val) > >>>> + > >>>> +#define this_cpu_cmpxchg_1(pcp, o, n) > >>>> _pcp_protect_return(cmpxchg_relaxed, pcp, o, n) > >>>> +#define this_cpu_cmpxchg_2(pcp, o, n) > >>>> _pcp_protect_return(cmpxchg_relaxed, pcp, o, n) > >>>> +#define this_cpu_cmpxchg_4(pcp, o, n) > >>>> _pcp_protect_return(cmpxchg_relaxed, pcp, o, n) > >>>> +#define this_cpu_cmpxchg_8(pcp, o, n) > >>>> _pcp_protect_return(cmpxchg_relaxed, pcp, o, n) > >>>> + > >>>> +#include > >>>> + > >>>> +#endif /* __ASM_PERCPU_H */ > >>> > >>> It all looks good to me, just one thing, can you also implement > >>> this_cpu_cmpxchg64/128()? > >>> > >> One last thing sorry, can you add a cover letter too? > > Okay. > > > >> Thanks! > >> > >> Alex > >> > >> > >>> And since this is almost a copy/paste from arm64, either mention it a= t > >>> the top of the file or (better) merge both implementations somewhere > >>> to avoid redefining existing code :) But up to you. > > Actually, there's a concern here. We should account for scenarios > > where ZABHA isn't supported. Given that xxx_8() and xxx_16() are > > rarely used in practice, could we initially support only xxx_32() and > > xxx_64()? For xxx_8() and xxx_16(), we could default to the generic > > implementation. > > > Why isn't lr/sc enough? If I'm not mistaken, the current RISC-V does not support lr.bh/sc.bh, is that right? > > > > > > > >>> Reviewed-by: Alexandre Ghiti > >>> > >>> Thanks, > >>> > >>> Alex > >>> > >>> > >>> > > Thanks, > > Yunhui > > > > _______________________________________________ > > linux-riscv mailing list > > linux-riscv@lists.infradead.org > > http://lists.infradead.org/mailman/listinfo/linux-riscv Thanks, Yunhui