From patchwork Tue Apr 1 00:51:34 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alexei Starovoitov X-Patchwork-Id: 14034243 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 CA242C3600C for ; Tue, 1 Apr 2025 00:51:42 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 37893280002; Mon, 31 Mar 2025 20:51:41 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 327C3280001; Mon, 31 Mar 2025 20:51:41 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 1CA4C280002; Mon, 31 Mar 2025 20:51:41 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0016.hostedemail.com [216.40.44.16]) by kanga.kvack.org (Postfix) with ESMTP id ECC6F280001 for ; Mon, 31 Mar 2025 20:51:40 -0400 (EDT) Received: from smtpin17.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay04.hostedemail.com (Postfix) with ESMTP id 783A31A09A0 for ; Tue, 1 Apr 2025 00:51:41 +0000 (UTC) X-FDA: 83283647202.17.7F66D39 Received: from mail-pl1-f176.google.com (mail-pl1-f176.google.com [209.85.214.176]) by imf11.hostedemail.com (Postfix) with ESMTP id A379A4000B for ; Tue, 1 Apr 2025 00:51:39 +0000 (UTC) Authentication-Results: imf11.hostedemail.com; dkim=pass header.d=gmail.com header.s=20230601 header.b=iE7emAA2; dmarc=pass (policy=none) header.from=gmail.com; spf=pass (imf11.hostedemail.com: domain of alexei.starovoitov@gmail.com designates 209.85.214.176 as permitted sender) smtp.mailfrom=alexei.starovoitov@gmail.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1743468699; 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-transfer-encoding:content-transfer-encoding: in-reply-to:references:dkim-signature; bh=hoPlnUj9VYVfTn2EhY6mZPQ4JMBrtPu8Y1smqMHSsw8=; b=yI3yOqq76ZYk6bO/4dzuSdZVu/FJhdi/FdZQ417x9uiwgsmmCQgAUMWgI1uHWdrKGi7Rrq btuGKDBGaa6g7Eu/SMv4kGuRo4ywrhvvh77W6/HyDDTGMW1kfDZZfcRXxFMnt5jkJ4YDV6 qu6rinS+krvdX0EB6kWi0pBJbYl1U1Q= ARC-Authentication-Results: i=1; imf11.hostedemail.com; dkim=pass header.d=gmail.com header.s=20230601 header.b=iE7emAA2; dmarc=pass (policy=none) header.from=gmail.com; spf=pass (imf11.hostedemail.com: domain of alexei.starovoitov@gmail.com designates 209.85.214.176 as permitted sender) smtp.mailfrom=alexei.starovoitov@gmail.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1743468699; a=rsa-sha256; cv=none; b=0p4208a9sFTjPFSSQt8WceSbxKxQ3Wi4PKzKyDi/67n/RkjkGecXIgzWsmuVO1wiW5rCpz q2m+IqPP0+9xf8mPrd2tJXSUDSiNkfwICuxeTOmN6krWbOLDJmN4WhdEmj5Eh/6XGv70m4 7oVmMMG6KLkHbzhlIkPfnLbNhIvzyQE= Received: by mail-pl1-f176.google.com with SMTP id d9443c01a7336-22409077c06so136209765ad.1 for ; Mon, 31 Mar 2025 17:51:39 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1743468698; x=1744073498; darn=kvack.org; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:from:to:cc:subject:date:message-id:reply-to; bh=hoPlnUj9VYVfTn2EhY6mZPQ4JMBrtPu8Y1smqMHSsw8=; b=iE7emAA23fn1WU4WIcF1JKyVDN2/qcQXjD/y84iw01inJz0A/NXehz2TC+xEYQYZYV i6Fo+Kf6VRquXBVNA00S1xtFvOJdveSy5cAJDZcOhSLqT1BRS7is3nT0BHBLSF9Y/y3R ew0uHPpNh0seej2wnzkwmQ9m4M5ASVgMdB16qaHIaoqtuBd7DiOcgraMigQWP/aEBRSs DsvaiiBByVr80UWAwzzMMiNTgRwRmWno0Szb7vXtPAve/2pWbmkr1KYIg4YVT4qEkWCR 6sypacHwRthf+CWdiNBbeDo2+LfocWzM4U26Vz6T/V8s6WT6ztsdAVwxNEeSEA0sO1GE KEjw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1743468698; x=1744073498; h=content-transfer-encoding:mime-version:message-id:date:subject:cc :to:from:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=hoPlnUj9VYVfTn2EhY6mZPQ4JMBrtPu8Y1smqMHSsw8=; b=X8LM1yuEujAP1WA3SHsMtP2VlesPr/RL+5PA+ChptMe8X0LHC04ZFPfn6Ss63iOdAv u/n5z4xaF/ZN60yrQs261+zaqwuxuj7WikJ4sj/B6aC/6HR/63PZ42l8QV0eouAM3/lj H9KttEOgVqR3lHCVPskGuf0rMyaarCls+fmLJ204sxr4jKpng286/d0snrTl8Qx63gu3 FNoQXzOQ0fyNf8LdJVgPiDzEby96/bD9Ve8aPoArG/HfhS+cLdf9xSsT5nKUWvuSTAyr r7+sYVzjqQngygsKmYIj8dlwGJUtvnS8EAAMd1rI8szBpNVuhPM1Is13k+4TXfkwbK/f shtQ== X-Forwarded-Encrypted: i=1; AJvYcCWmq5JHAZOp/+gSA2X0hJr8io6hT+ApCky58LpdYRFHiYpzLdhNEGRyqRbyE27gL6+u9anNUrUv3g==@kvack.org X-Gm-Message-State: AOJu0Yx09huoSNmp5PFKUZH/uPcuPJn7KdOYIuqfj72SsxTAUsh5v2l2 ST+vFkCrH0AyVVSiHV2EBlWzLebkAcMISE6iMQGCwuz8iyzU1Qe/ X-Gm-Gg: ASbGncu9QQ6ysHSKl9wKKefn4l8fJ6qz7W9iJw/ZHrWGTNJbHbBMIHKBX0fIaVTfp47 Wvg3U4v7lsogXQTJ6Yq/bL2L7b+7yc0aajzojLBP96Gdun7FdQGN62yjUcJHf8CCtkQGJpEEUmF EdrX8eg21twOz1n2NXdLQYw7uiG5UUCeNO/o4a+cRSxzwToON5OB8cGtJa2hKPa0kqHIgM//wi/ AfvG1yNrba5QioNTTREtrH2A4HPxiMZfxtFy05odsKoXfNaBw6HGDhed/UsLy7H5+GNUrPCxMap S95bKU6DdMEjIqpmCifzoOzDqxPzp7gXT5s9xNv96LNeJj1gzkb6g7UpMDYH6i8qsStQ5Zii X-Google-Smtp-Source: AGHT+IG2uoTtYHsOhKY+bOe2Z5kTaeHHDlNe/QpMvVEuyUW5/7EPmwSTDq3bK38ywiIuj7Us/Ekklw== X-Received: by 2002:a17:902:ce8b:b0:224:179a:3b8f with SMTP id d9443c01a7336-2292f979cb9mr169297455ad.23.1743468698320; Mon, 31 Mar 2025 17:51:38 -0700 (PDT) Received: from localhost.localdomain ([2620:10d:c090:400::5:22d1]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-2291f1cdd43sm76025095ad.133.2025.03.31.17.51.36 (version=TLS1_3 cipher=TLS_CHACHA20_POLY1305_SHA256 bits=256/256); Mon, 31 Mar 2025 17:51:37 -0700 (PDT) From: Alexei Starovoitov To: Linus Torvalds Cc: bpf@vger.kernel.org, daniel@iogearbox.net, andrii@kernel.org, martin.lau@kernel.org, akpm@linux-foundation.org, peterz@infradead.org, vbabka@suse.cz, bigeasy@linutronix.de, rostedt@goodmis.org, shakeel.butt@linux.dev, mhocko@suse.com, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: [PATCH] locking/local_lock, mm: Replace localtry_ helpers with local_trylock_t type Date: Mon, 31 Mar 2025 17:51:34 -0700 Message-Id: <20250401005134.14433-1-alexei.starovoitov@gmail.com> X-Mailer: git-send-email 2.39.5 (Apple Git-154) MIME-Version: 1.0 X-Rspamd-Server: rspam11 X-Rspamd-Queue-Id: A379A4000B X-Stat-Signature: j6w67fr6fwnhuh5g4zdji7p5ugq1mifc X-Rspam-User: X-HE-Tag: 1743468699-230943 X-HE-Meta: U2FsdGVkX182g00atYfZuDLmyEi8VjwB8aDxE6iuqem3KBQsnv0oyU6M5aG+OIdYhrT1CH8paF10AvrlSU8Zg37faNBh6rbr27jkLYEnNnUH1t7AGc89ZK7IXbLx2inSV+OaPyaX3JGDQBwG47o7df3ZX4dLc1VIrpwehiHxaVlp3UmQLvRb8sqzB7zj0C/C3+AVaPCxUvAbTaJDRV2M9PW1A1/C6TzR82IGoNjGfkawfIicGbd4F/MdbHapIJHkU7UFK//GMw7a8a0LtgUA4jee9xjiAacFdlU0CEEDNGoZBJZHzh3MU916sP4LUdWTCXH/ADOOocQ4Af+CiqvQII4hhTUYpjsJcp0JqqQfhLBWLwJfxBmBgrONV5PHe2uHey2Xfkh/zEalItXJBZH2LPozLYFnMgz4C6nVSKb4mAdjlsSdWt8g6yy2TgMDkmWSw8hlp9EJV0N4C867rAVIS6NMr2Pimy/ao7SMKU6LC/uhoSq3UGLhLQw5xOnyIHf5BardjKS4ODvmRlKxAkwqkJooXqKrp6+a/mvQr6VlR4vzYuSskwqKOnJejcDpRMuZSIt8qIPjtptwuoOykaxwAka81lpEvmYPRQfbNZJVgFpVCkZqdIzyUW18LXz5HEQadNTMg1Fck/31rAWtNRao7fc9FgyJ6Jm9AylHvY1Rwy0i3YY3zb5u0F7we+fA4l4QOZkobab8mql9YFOypcp88QgOGYfZeR14Y77UR49JPBJsKZ27ebPtfRgDVxCcO8cmWIhZuQrp/C81IZJ9pfdXiNxr6180UZkNGddo2NmjUrXYx2AkVMgshiVt9zV5Qv3zw/pbj81arkLEpUECpZpcrlKGALHK8OPc5zofBXoRyGdDgegA2cZcDuEpYieTuAi7KOV9K3r943Z1AKqBADWdY1g2S6kpe4thdf4MKf/clpKqRvc5D3J1VxgfMk0RdC/QVAlhqqDYUjHiNwkfupH Y+30ASye 1ndLJ16n65T/VQO9DwxBN76pqZzkOCe5LgY8UucrvTeD9pK3LPPqlo/2OacmiGutKU7I2FDQQRR74S7DVtp8LSTQZrjLuUY7kTLrOMtnSib0DF7FDPDUTXHpfLTPR5wNeynsGZ3F4eoxAih+FgDWhvVl14Z8jhc4JwxdvaTEGM5Zz82DWYAsGyEJqJTgEbcd3txaUmwF4QMJeF1+ibUnvOgHxZaUWutIQ4aJFMluRspaPkGuCDac+MMUB3tzg3MDuDQYxkbLAnNpMoC4m8kHzXaOEzwpSjYNy19CFW4wjAhsKfdYU8doArEKOeJbpnH0Pa/u1kOjpuVIj+uihpjop0tyFdjgXZ2CrP0MvUOfECk++UiSAkCA1ZNkp8ffMCGq9C+RPV5jpJdcTxUq7nVOXRvMvh9tWPXeMSQbaCF0y1jAMG6gKiV0FRmHE67fB5MQjT85KbWu68z0TEFdh8GxyrUxtANa2/1uGjiErmIvQC102G/0Dnbm9+kpXBg== 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: From: Alexei Starovoitov Partially revert commit 0aaddfb06882 ("locking/local_lock: Introduce localtry_lock_t"). Remove localtry_*() helpers, since localtry_lock() name might be misinterpreted as "try lock". Introduce local_trylock_irqsave() helper that only works with newly introduced local_trylock_t type. Note that attempt to use local_trylock_irqsave() with local_lock_t will cause compilation failure. Usage and behavior in !PREEMPT_RT: local_lock_t lock; // sizeof(lock) == 0 local_lock_irqsave(&lock, ...); // irq save if (local_trylock_irqsave(&lock, ...)) // compilation error local_trylock_t lock; // sizeof(lock) == 4 local_lock_irqsave(&lock, ...); // irq save and acquired = 1 if (local_trylock_irqsave(&lock, ...)) // if (!acquired) irq save The existing local_lock_*() macros can be used either with local_lock_t or local_trylock_t. With local_trylock_t they set acquired = 1 while local_unlock_*() clears it. In !PREEMPT_RT local_lock_irqsave(local_lock_t *) disables interrupts to protect critical section, but it doesn't prevent NMI, so the fully reentrant code cannot use local_lock_irqsave(local_lock_t *) for exclusive access. The local_lock_irqsave(local_trylock_t *) helper disables interrupts and sets acquired=1, so local_trylock_irqsave(local_trylock_t *) from NMI attempting to acquire the same lock will return false. In PREEMPT_RT local_lock_irqsave() maps to preemptible spin_lock(). Map local_trylock_irqsave() to preemptible spin_trylock(). When in hard IRQ or NMI return false right away, since spin_trylock() is not safe due to explicit locking in the underneath rt_spin_trylock() implementation. Removing this explicit locking and attempting only "trylock" is undesired due to PI implications. Note there is no need to use local_inc for acquired variable, since it's a percpu variable with strict nesting scopes. Signed-off-by: Alexei Starovoitov Acked-by: Vlastimil Babka Acked-by: Sebastian Andrzej Siewior --- include/linux/local_lock.h | 58 +-------- include/linux/local_lock_internal.h | 193 ++++++++++------------------ mm/memcontrol.c | 39 +++--- 3 files changed, 95 insertions(+), 195 deletions(-) diff --git a/include/linux/local_lock.h b/include/linux/local_lock.h index 1a0bc35839e3..9262109cca51 100644 --- a/include/linux/local_lock.h +++ b/include/linux/local_lock.h @@ -52,44 +52,19 @@ __local_unlock_irqrestore(lock, flags) /** - * localtry_lock_init - Runtime initialize a lock instance - */ -#define localtry_lock_init(lock) __localtry_lock_init(lock) - -/** - * localtry_lock - Acquire a per CPU local lock - * @lock: The lock variable - */ -#define localtry_lock(lock) __localtry_lock(lock) - -/** - * localtry_lock_irq - Acquire a per CPU local lock and disable interrupts - * @lock: The lock variable - */ -#define localtry_lock_irq(lock) __localtry_lock_irq(lock) - -/** - * localtry_lock_irqsave - Acquire a per CPU local lock, save and disable - * interrupts + * local_trylock_irqsave - Try to acquire a per CPU local lock * @lock: The lock variable * @flags: Storage for interrupt flags - */ -#define localtry_lock_irqsave(lock, flags) \ - __localtry_lock_irqsave(lock, flags) - -/** - * localtry_trylock - Try to acquire a per CPU local lock. - * @lock: The lock variable * * The function can be used in any context such as NMI or HARDIRQ. Due to * locking constrains it will _always_ fail to acquire the lock in NMI or * HARDIRQ context on PREEMPT_RT. */ -#define localtry_trylock(lock) __localtry_trylock(lock) +#define local_trylock(lock, flags) __local_trylock(lock, flags) /** - * localtry_trylock_irqsave - Try to acquire a per CPU local lock, save and disable - * interrupts if acquired + * local_trylock_irqsave - Try to acquire a per CPU local lock, save and disable + * interrupts if acquired * @lock: The lock variable * @flags: Storage for interrupt flags * @@ -97,29 +72,8 @@ * locking constrains it will _always_ fail to acquire the lock in NMI or * HARDIRQ context on PREEMPT_RT. */ -#define localtry_trylock_irqsave(lock, flags) \ - __localtry_trylock_irqsave(lock, flags) - -/** - * local_unlock - Release a per CPU local lock - * @lock: The lock variable - */ -#define localtry_unlock(lock) __localtry_unlock(lock) - -/** - * local_unlock_irq - Release a per CPU local lock and enable interrupts - * @lock: The lock variable - */ -#define localtry_unlock_irq(lock) __localtry_unlock_irq(lock) - -/** - * localtry_unlock_irqrestore - Release a per CPU local lock and restore - * interrupt flags - * @lock: The lock variable - * @flags: Interrupt flags to restore - */ -#define localtry_unlock_irqrestore(lock, flags) \ - __localtry_unlock_irqrestore(lock, flags) +#define local_trylock_irqsave(lock, flags) \ + __local_trylock_irqsave(lock, flags) DEFINE_GUARD(local_lock, local_lock_t __percpu*, local_lock(_T), diff --git a/include/linux/local_lock_internal.h b/include/linux/local_lock_internal.h index 67bd13d142fa..cc79854206df 100644 --- a/include/linux/local_lock_internal.h +++ b/include/linux/local_lock_internal.h @@ -15,10 +15,18 @@ typedef struct { #endif } local_lock_t; +/* local_trylock() and local_trylock_irqsave() only work with local_trylock_t */ typedef struct { - local_lock_t llock; - unsigned int acquired; -} localtry_lock_t; +#ifdef CONFIG_DEBUG_LOCK_ALLOC + struct lockdep_map dep_map; + struct task_struct *owner; +#endif + /* + * Same layout as local_lock_t with 'acquired' field at the end. + * (local_trylock_t *) will be casted to (local_lock_t *). + */ + int acquired; +} local_trylock_t; #ifdef CONFIG_DEBUG_LOCK_ALLOC # define LOCAL_LOCK_DEBUG_INIT(lockname) \ @@ -63,7 +71,6 @@ static inline void local_lock_debug_init(local_lock_t *l) { } #endif /* !CONFIG_DEBUG_LOCK_ALLOC */ #define INIT_LOCAL_LOCK(lockname) { LOCAL_LOCK_DEBUG_INIT(lockname) } -#define INIT_LOCALTRY_LOCK(lockname) { .llock = { LOCAL_LOCK_DEBUG_INIT(lockname.llock) }} #define __local_lock_init(lock) \ do { \ @@ -87,39 +94,88 @@ do { \ local_lock_debug_init(lock); \ } while (0) +#define __local_lock_acquire(lock) \ + do { \ + local_trylock_t *tl; \ + local_lock_t *l; \ + \ + l = (local_lock_t *)this_cpu_ptr(lock); \ + tl = (local_trylock_t *)l; \ + _Generic((lock), \ + local_trylock_t *: ({ \ + lockdep_assert(tl->acquired == 0); \ + WRITE_ONCE(tl->acquired, 1); \ + }), \ + default:(void)0); \ + local_lock_acquire(l); \ + } while (0) + #define __local_lock(lock) \ do { \ preempt_disable(); \ - local_lock_acquire(this_cpu_ptr(lock)); \ + __local_lock_acquire(lock); \ } while (0) #define __local_lock_irq(lock) \ do { \ local_irq_disable(); \ - local_lock_acquire(this_cpu_ptr(lock)); \ + __local_lock_acquire(lock); \ } while (0) #define __local_lock_irqsave(lock, flags) \ do { \ local_irq_save(flags); \ - local_lock_acquire(this_cpu_ptr(lock)); \ + __local_lock_acquire(lock); \ + } while (0) + +#define __local_trylock_irqsave(lock, flags) \ + ({ \ + local_trylock_t *tl; \ + \ + local_irq_save(flags); \ + tl = this_cpu_ptr(lock); \ + if (READ_ONCE(tl->acquired) == 1) { \ + local_irq_restore(flags); \ + tl = NULL; \ + } else { \ + WRITE_ONCE(tl->acquired, 1); \ + local_trylock_acquire( \ + (local_lock_t *)tl); \ + } \ + !!tl; \ + }) + +#define __local_lock_release(lock) \ + do { \ + local_trylock_t *tl; \ + local_lock_t *l; \ + \ + l = (local_lock_t *)this_cpu_ptr(lock); \ + tl = (local_trylock_t *)l; \ + _Generic((lock), \ + local_trylock_t *: ({ \ + lockdep_assert(tl->acquired == 1); \ + WRITE_ONCE(tl->acquired, 0); \ + }), \ + default:(void)0); \ + local_lock_release(l); \ } while (0) #define __local_unlock(lock) \ do { \ - local_lock_release(this_cpu_ptr(lock)); \ + __local_lock_release(lock); \ preempt_enable(); \ } while (0) #define __local_unlock_irq(lock) \ do { \ - local_lock_release(this_cpu_ptr(lock)); \ + __local_lock_release(lock); \ local_irq_enable(); \ } while (0) #define __local_unlock_irqrestore(lock, flags) \ do { \ - local_lock_release(this_cpu_ptr(lock)); \ + __local_lock_release(lock); \ local_irq_restore(flags); \ } while (0) @@ -132,104 +188,6 @@ do { \ #define __local_unlock_nested_bh(lock) \ local_lock_release(this_cpu_ptr(lock)) -/* localtry_lock_t variants */ - -#define __localtry_lock_init(lock) \ -do { \ - __local_lock_init(&(lock)->llock); \ - WRITE_ONCE((lock)->acquired, 0); \ -} while (0) - -#define __localtry_lock(lock) \ - do { \ - localtry_lock_t *lt; \ - preempt_disable(); \ - lt = this_cpu_ptr(lock); \ - local_lock_acquire(<->llock); \ - WRITE_ONCE(lt->acquired, 1); \ - } while (0) - -#define __localtry_lock_irq(lock) \ - do { \ - localtry_lock_t *lt; \ - local_irq_disable(); \ - lt = this_cpu_ptr(lock); \ - local_lock_acquire(<->llock); \ - WRITE_ONCE(lt->acquired, 1); \ - } while (0) - -#define __localtry_lock_irqsave(lock, flags) \ - do { \ - localtry_lock_t *lt; \ - local_irq_save(flags); \ - lt = this_cpu_ptr(lock); \ - local_lock_acquire(<->llock); \ - WRITE_ONCE(lt->acquired, 1); \ - } while (0) - -#define __localtry_trylock(lock) \ - ({ \ - localtry_lock_t *lt; \ - bool _ret; \ - \ - preempt_disable(); \ - lt = this_cpu_ptr(lock); \ - if (!READ_ONCE(lt->acquired)) { \ - WRITE_ONCE(lt->acquired, 1); \ - local_trylock_acquire(<->llock); \ - _ret = true; \ - } else { \ - _ret = false; \ - preempt_enable(); \ - } \ - _ret; \ - }) - -#define __localtry_trylock_irqsave(lock, flags) \ - ({ \ - localtry_lock_t *lt; \ - bool _ret; \ - \ - local_irq_save(flags); \ - lt = this_cpu_ptr(lock); \ - if (!READ_ONCE(lt->acquired)) { \ - WRITE_ONCE(lt->acquired, 1); \ - local_trylock_acquire(<->llock); \ - _ret = true; \ - } else { \ - _ret = false; \ - local_irq_restore(flags); \ - } \ - _ret; \ - }) - -#define __localtry_unlock(lock) \ - do { \ - localtry_lock_t *lt; \ - lt = this_cpu_ptr(lock); \ - WRITE_ONCE(lt->acquired, 0); \ - local_lock_release(<->llock); \ - preempt_enable(); \ - } while (0) - -#define __localtry_unlock_irq(lock) \ - do { \ - localtry_lock_t *lt; \ - lt = this_cpu_ptr(lock); \ - WRITE_ONCE(lt->acquired, 0); \ - local_lock_release(<->llock); \ - local_irq_enable(); \ - } while (0) - -#define __localtry_unlock_irqrestore(lock, flags) \ - do { \ - localtry_lock_t *lt; \ - lt = this_cpu_ptr(lock); \ - WRITE_ONCE(lt->acquired, 0); \ - local_lock_release(<->llock); \ - local_irq_restore(flags); \ - } while (0) - #else /* !CONFIG_PREEMPT_RT */ /* @@ -237,10 +195,9 @@ do { \ * critical section while staying preemptible. */ typedef spinlock_t local_lock_t; -typedef spinlock_t localtry_lock_t; +typedef spinlock_t local_trylock_t; #define INIT_LOCAL_LOCK(lockname) __LOCAL_SPIN_LOCK_UNLOCKED((lockname)) -#define INIT_LOCALTRY_LOCK(lockname) INIT_LOCAL_LOCK(lockname) #define __local_lock_init(l) \ do { \ @@ -283,17 +240,7 @@ do { \ spin_unlock(this_cpu_ptr((lock))); \ } while (0) -/* localtry_lock_t variants */ - -#define __localtry_lock_init(lock) __local_lock_init(lock) -#define __localtry_lock(lock) __local_lock(lock) -#define __localtry_lock_irq(lock) __local_lock(lock) -#define __localtry_lock_irqsave(lock, flags) __local_lock_irqsave(lock, flags) -#define __localtry_unlock(lock) __local_unlock(lock) -#define __localtry_unlock_irq(lock) __local_unlock(lock) -#define __localtry_unlock_irqrestore(lock, flags) __local_unlock_irqrestore(lock, flags) - -#define __localtry_trylock(lock) \ +#define __local_trylock(lock) \ ({ \ int __locked; \ \ @@ -308,11 +255,11 @@ do { \ __locked; \ }) -#define __localtry_trylock_irqsave(lock, flags) \ +#define __local_trylock_irqsave(lock, flags) \ ({ \ typecheck(unsigned long, flags); \ flags = 0; \ - __localtry_trylock(lock); \ + __local_trylock(lock); \ }) #endif /* CONFIG_PREEMPT_RT */ diff --git a/mm/memcontrol.c b/mm/memcontrol.c index 83c2df73e4b6..bca86961754e 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -1739,7 +1739,7 @@ void mem_cgroup_print_oom_group(struct mem_cgroup *memcg) } struct memcg_stock_pcp { - localtry_lock_t stock_lock; + local_trylock_t stock_lock; struct mem_cgroup *cached; /* this never be root cgroup */ unsigned int nr_pages; @@ -1754,7 +1754,7 @@ struct memcg_stock_pcp { #define FLUSHING_CACHED_CHARGE 0 }; static DEFINE_PER_CPU(struct memcg_stock_pcp, memcg_stock) = { - .stock_lock = INIT_LOCALTRY_LOCK(stock_lock), + .stock_lock = INIT_LOCAL_LOCK(stock_lock), }; static DEFINE_MUTEX(percpu_charge_mutex); @@ -1785,11 +1785,10 @@ static bool consume_stock(struct mem_cgroup *memcg, unsigned int nr_pages, if (nr_pages > MEMCG_CHARGE_BATCH) return ret; - if (!localtry_trylock_irqsave(&memcg_stock.stock_lock, flags)) { - if (!gfpflags_allow_spinning(gfp_mask)) - return ret; - localtry_lock_irqsave(&memcg_stock.stock_lock, flags); - } + if (gfpflags_allow_spinning(gfp_mask)) + local_lock_irqsave(&memcg_stock.stock_lock, flags); + else if (!local_trylock_irqsave(&memcg_stock.stock_lock, flags)) + return ret; stock = this_cpu_ptr(&memcg_stock); stock_pages = READ_ONCE(stock->nr_pages); @@ -1798,7 +1797,7 @@ static bool consume_stock(struct mem_cgroup *memcg, unsigned int nr_pages, ret = true; } - localtry_unlock_irqrestore(&memcg_stock.stock_lock, flags); + local_unlock_irqrestore(&memcg_stock.stock_lock, flags); return ret; } @@ -1837,14 +1836,14 @@ static void drain_local_stock(struct work_struct *dummy) * drain_stock races is that we always operate on local CPU stock * here with IRQ disabled */ - localtry_lock_irqsave(&memcg_stock.stock_lock, flags); + local_lock_irqsave(&memcg_stock.stock_lock, flags); stock = this_cpu_ptr(&memcg_stock); old = drain_obj_stock(stock); drain_stock(stock); clear_bit(FLUSHING_CACHED_CHARGE, &stock->flags); - localtry_unlock_irqrestore(&memcg_stock.stock_lock, flags); + local_unlock_irqrestore(&memcg_stock.stock_lock, flags); obj_cgroup_put(old); } @@ -1874,7 +1873,7 @@ static void refill_stock(struct mem_cgroup *memcg, unsigned int nr_pages) { unsigned long flags; - if (!localtry_trylock_irqsave(&memcg_stock.stock_lock, flags)) { + if (!local_trylock_irqsave(&memcg_stock.stock_lock, flags)) { /* * In case of unlikely failure to lock percpu stock_lock * uncharge memcg directly. @@ -1887,7 +1886,7 @@ static void refill_stock(struct mem_cgroup *memcg, unsigned int nr_pages) return; } __refill_stock(memcg, nr_pages); - localtry_unlock_irqrestore(&memcg_stock.stock_lock, flags); + local_unlock_irqrestore(&memcg_stock.stock_lock, flags); } /* @@ -1944,9 +1943,9 @@ static int memcg_hotplug_cpu_dead(unsigned int cpu) stock = &per_cpu(memcg_stock, cpu); /* drain_obj_stock requires stock_lock */ - localtry_lock_irqsave(&memcg_stock.stock_lock, flags); + local_lock_irqsave(&memcg_stock.stock_lock, flags); old = drain_obj_stock(stock); - localtry_unlock_irqrestore(&memcg_stock.stock_lock, flags); + local_unlock_irqrestore(&memcg_stock.stock_lock, flags); drain_stock(stock); obj_cgroup_put(old); @@ -2729,7 +2728,7 @@ static void mod_objcg_state(struct obj_cgroup *objcg, struct pglist_data *pgdat, unsigned long flags; int *bytes; - localtry_lock_irqsave(&memcg_stock.stock_lock, flags); + local_lock_irqsave(&memcg_stock.stock_lock, flags); stock = this_cpu_ptr(&memcg_stock); /* @@ -2782,7 +2781,7 @@ static void mod_objcg_state(struct obj_cgroup *objcg, struct pglist_data *pgdat, if (nr) __mod_objcg_mlstate(objcg, pgdat, idx, nr); - localtry_unlock_irqrestore(&memcg_stock.stock_lock, flags); + local_unlock_irqrestore(&memcg_stock.stock_lock, flags); obj_cgroup_put(old); } @@ -2792,7 +2791,7 @@ static bool consume_obj_stock(struct obj_cgroup *objcg, unsigned int nr_bytes) unsigned long flags; bool ret = false; - localtry_lock_irqsave(&memcg_stock.stock_lock, flags); + local_lock_irqsave(&memcg_stock.stock_lock, flags); stock = this_cpu_ptr(&memcg_stock); if (objcg == READ_ONCE(stock->cached_objcg) && stock->nr_bytes >= nr_bytes) { @@ -2800,7 +2799,7 @@ static bool consume_obj_stock(struct obj_cgroup *objcg, unsigned int nr_bytes) ret = true; } - localtry_unlock_irqrestore(&memcg_stock.stock_lock, flags); + local_unlock_irqrestore(&memcg_stock.stock_lock, flags); return ret; } @@ -2892,7 +2891,7 @@ static void refill_obj_stock(struct obj_cgroup *objcg, unsigned int nr_bytes, unsigned long flags; unsigned int nr_pages = 0; - localtry_lock_irqsave(&memcg_stock.stock_lock, flags); + local_lock_irqsave(&memcg_stock.stock_lock, flags); stock = this_cpu_ptr(&memcg_stock); if (READ_ONCE(stock->cached_objcg) != objcg) { /* reset if necessary */ @@ -2910,7 +2909,7 @@ static void refill_obj_stock(struct obj_cgroup *objcg, unsigned int nr_bytes, stock->nr_bytes &= (PAGE_SIZE - 1); } - localtry_unlock_irqrestore(&memcg_stock.stock_lock, flags); + local_unlock_irqrestore(&memcg_stock.stock_lock, flags); obj_cgroup_put(old); if (nr_pages)