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 9B276C83F27 for ; Wed, 16 Jul 2025 04:29:31 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 1F5306B0092; Wed, 16 Jul 2025 00:29:31 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 1A6336B0093; Wed, 16 Jul 2025 00:29:31 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 0BC186B0095; Wed, 16 Jul 2025 00:29:31 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0015.hostedemail.com [216.40.44.15]) by kanga.kvack.org (Postfix) with ESMTP id F05986B0092 for ; Wed, 16 Jul 2025 00:29:30 -0400 (EDT) Received: from smtpin20.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay03.hostedemail.com (Postfix) with ESMTP id C8122B5796 for ; Wed, 16 Jul 2025 04:29:30 +0000 (UTC) X-FDA: 83668848900.20.0F0401E Received: from mail-pf1-f202.google.com (mail-pf1-f202.google.com [209.85.210.202]) by imf22.hostedemail.com (Postfix) with ESMTP id 18A2DC0003 for ; Wed, 16 Jul 2025 04:29:28 +0000 (UTC) Authentication-Results: imf22.hostedemail.com; dkim=pass header.d=google.com header.s=20230601 header.b="hZvyy/B9"; spf=pass (imf22.hostedemail.com: domain of 3pyp3aAYKCCQKUNIYUGOOGLE.COMLINUX-MMKVACK.ORG@flex--kuniyu.bounces.google.com designates 209.85.210.202 as permitted sender) smtp.mailfrom=3pyp3aAYKCCQKUNIYUGOOGLE.COMLINUX-MMKVACK.ORG@flex--kuniyu.bounces.google.com; dmarc=pass (policy=reject) header.from=google.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1752640169; 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:in-reply-to: references:dkim-signature; bh=gzpEdbFPO1KZ3S4ZZJaCHMMs/9rLduByzWjeJ8GDh/A=; b=WzRml1WA5QL4GGtt3RQQKI2pciWjmfs5HR5jeK5jrtwwiyFBQU3XzIGxQ++QSJywuya2aS FCBFhjDE/x8twXMSILHaVK870h+3WaFxYWicQT9Lt/i2IRFYtBsxMXoQBIpxFL259BZmGK s4bnn9udgO91GDQs9grNZ3rwPgpaqFc= ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1752640169; a=rsa-sha256; cv=none; b=HL5J1tuSS/nu1r49uX7RnmwprMgjmaPJYM1//Br0/6XVF6EkQi8Mlh6mxXjpE8o94olw/r sMkJBR6X3xnQXRjrLG0HDblPe5hJPI1H1K3SW5w7a2EjdmUhPSXiPJS9DmshyUI/eGUQlp lUXTBlP0C3bQacisIiNUpWIbsxmOL+I= ARC-Authentication-Results: i=1; imf22.hostedemail.com; dkim=pass header.d=google.com header.s=20230601 header.b="hZvyy/B9"; spf=pass (imf22.hostedemail.com: domain of 3pyp3aAYKCCQKUNIYUGOOGLE.COMLINUX-MMKVACK.ORG@flex--kuniyu.bounces.google.com designates 209.85.210.202 as permitted sender) smtp.mailfrom=3pyp3aAYKCCQKUNIYUGOOGLE.COMLINUX-MMKVACK.ORG@flex--kuniyu.bounces.google.com; dmarc=pass (policy=reject) header.from=google.com Received: by mail-pf1-f202.google.com with SMTP id d2e1a72fcca58-74913385dd8so8886205b3a.0 for ; Tue, 15 Jul 2025 21:29:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1752640168; x=1753244968; darn=kvack.org; h=cc:to:from:subject:message-id:mime-version:date:from:to:cc:subject :date:message-id:reply-to; bh=gzpEdbFPO1KZ3S4ZZJaCHMMs/9rLduByzWjeJ8GDh/A=; b=hZvyy/B9Ai8U3AunBY625BqSecOg98XriEP1R0uZdQJm7wz3kjhn/6KBfS1/o0MAw9 MOf4YRQpyTImA13VQFILjHfHonIT4t+hy39R5tNshDpQZphNSAgCw15uk8yG7U6qiM7q jX60EH/73QeWBnOUdheVAf/brSoFaZ8gQ5Y2CJwI0mwGn/cqNLdVCKjbx0DIiKTWvfYh g+E+T5dViQ731eltAv47vapdHsKHw+hI5rvgg4W2ZL++SX6WYmw4asNMTqPje7Snk1GB MAdGX/5eJ8snlLcSmQDJXEI+YwZ13zqhh5dw4WmsT1C63W4JON6xQH9et7muZK5UQEq6 AnhA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1752640168; x=1753244968; h=cc:to:from:subject:message-id:mime-version:date:x-gm-message-state :from:to:cc:subject:date:message-id:reply-to; bh=gzpEdbFPO1KZ3S4ZZJaCHMMs/9rLduByzWjeJ8GDh/A=; b=ZJnP6ztLrgdwuyV+DdKTivpirypxBFVBMMJ69pzWTIqfmlXaD15z5CupTz2xk9T/qI KSeRuZ0NPpKpMSz7K8EFd1lm2qQx76LNH17EW1Pd/z6/17qrUWOO2DyR9ea/oLsCpvoy U1064CGzPQCrWtmn7/EI+cmVbrRVaoDj2cgKo85exR05VGptP91tlR+4lmDnZIcRrenV legyNgd3ETSkb4KHWBq1wgYKcgPycAn98f4pWp219dNZQhnTIyC26W4ei3/M7rSWfe3G u5MCEbfTX85RL7cxvkr2+qd3XegXNs+DUeEm8t20+eBu2HxLekE/o++FJXDRFh+zqBKf DrYA== X-Forwarded-Encrypted: i=1; AJvYcCX7BWRkXCKLoFx/NTtWTk6T/QDAZ7haJvC53CA3SoOV9Ffa/f014MJnK/a+OGaZw2X+Xym1h3u1aw==@kvack.org X-Gm-Message-State: AOJu0YzvQ9bBcrunwIbysXahjxZbIVUOgrMiSEt4zN/43nJmgWsABu7l RG41l9O1GCZKc3434rBIRZthEmI36iyVE2ux+HVsnyKq/R2AjHHkzGWG3LsxW+H6BUHFbTtK64B D8LEzyg== X-Google-Smtp-Source: AGHT+IGXQRbtI6XvP4FSEc2AyOnPCwKIwQSxY5WxnqE1OLXciZQO8bHWC/K1JmNhMSF5+CdudSuXBCtOJhw= X-Received: from pfbki23.prod.google.com ([2002:a05:6a00:9497:b0:749:8f7:e14e]) (user=kuniyu job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6a00:3c88:b0:74b:f639:33a6 with SMTP id d2e1a72fcca58-75722773326mr1782614b3a.2.1752640167912; Tue, 15 Jul 2025 21:29:27 -0700 (PDT) Date: Wed, 16 Jul 2025 04:29:12 +0000 Mime-Version: 1.0 X-Mailer: git-send-email 2.50.0.727.gbf7dc18ff4-goog Message-ID: <20250716042925.106239-1-kuniyu@google.com> Subject: [PATCH] memcg: Keep socket_pressure fresh on 32-bit kernel. From: Kuniyuki Iwashima To: Andrew Morton Cc: Johannes Weiner , "David S. Miller" , Vladimir Davydov , Kuniyuki Iwashima , Kuniyuki Iwashima , linux-mm@kvack.org, Neal Cardwell Content-Type: text/plain; charset="UTF-8" X-Rspamd-Queue-Id: 18A2DC0003 X-Rspam-User: X-Rspamd-Server: rspam09 X-Stat-Signature: 9gbj6hq5x61bc9yggmst3uhxp8cb5ke3 X-HE-Tag: 1752640168-56933 X-HE-Meta: U2FsdGVkX1/PQp8t92/mcM1NJkOCcrLa94/ZWO3xdcFTmbSX97lbe4Pr8PKNYcZOWnKzXfE6LeM7uqeo3Fst5+drYLqlGcIPty2OUSFTM5MGtrMqozBZjcf7Ha9mQLY3OX3HJY2lOe0ByjvA/9a7k5spwpNaz6qGK9Oq1XlMuWPPFJAImgZ/b6n/q24C+GxsM+CLqRbV+Ky6nzWGNoHeYKBcwQRQVaCSW3sm6Mz4e+jlj8VMxdZpnUD3318LNIuTGzqk/PtP8sl+U9ezxm0a8IKJfu2j3p6HSAel+0NVxjXZpE2EtsrSeaxcHnLngRCABPFmai6wZrkkdXGmWZpE139lsPAVwj/DDxaRJePb27La0A4/NMBbJ0SoSRF1iGwUZJAnqzyIKdp/Q0jZPkOxXgZWL3d1fa6Yrfv8pZwBVJCE2HoXtTD6vPODz1DSST9YT2Ljb+jltug/4Z9Wz/VhpS2CrJ6Vh0C5xNXn3bvQzbKvCc4ewMs6fSuNj9ldb8xAOus35q+h1KfLL2WsWVWlyWOKUgHX812VqfBkuv8SXr99kI+9ZAie1tWzv96gxarF8Op1NSfzHl2AkU3lvl0FlCNZg37seSX+T7VgnTXGI5fAPn1wcfeohZ5v+/rW5FaKKF2HKCaO13AaecmpCNeRbU40J6Oco1E6cnfKHdWHKnUt5qhfuyN4O5/b/MA4x14VUvuLSfsY/GvqFbN2Tw/RprxYKICWdOGzbgtY2j/2BAA9mbKYDylpXvSJmEt7dsyXuUCA080w13mgKvTsB9u80tmjwYQOmr5cE3tAt3ZR93CgtkZuReREBhPcxI/ulGmh2NMt9z8qXFSfzes3AdCA4hVS4V/Cwuyz3IYEXUPxlGclRCfcF5JkcGmF1N1jyg8mmRqz7eSwb8FCFMIbMzob4dD5uAJH3oII+AIOQcDHBc6QSTU2zaF48TrEF7j4REXbhZiBwDjPjHAMNvxh6T6 aYmg1JIn ElK4+W66IPqV5xSMEeFcPsyTiL20L1HbRm7QHPyFqKkQgTzK250ANE80lMWn39+W1do21nx1NFc+e6ARnDNghDmekVCSvc/ZLFwrs9NTWJUjo1DvEJHNZgNlvdc+noSAXsWKFqDkPMV4eyOXu1auRiK7WFFkXlBqTv27pUcWBCAhDqw4Lt16DwM2dBKVFvHwzyKOIB5Elai3i5rjMNdOZdJS1zaLmHbrQoDOXDuk+IfQn3yQGhlwYq7nW93IxArysuyg/ZdAGL9AlKrLJP6IBXxAWaGkPgEZLAMhWpxE4qRsW2+n7ZKvB1Z5wIv1dzcGOiV8VSP931FFtRW4cBq3Lk3Zh2JmpPMZJyB2S7xNSVeHcZXVIJkEAgODfMHxtaHYwKFp/x6fObEZE0OvGJnh+IV5xPr5A2JoZ0ivsc68GD83VtuJd5kAkmxy/W2GQBUYyf6rRb1R3ZKZ1UKhfx+jLh7EJ/2aW1ddSqRDkykDE0OZM7mqR1CEP4m5wOTUtjbwy1Tf4u//+1fxD+U9qIwg7z182f0z0CHaR/NEhScUstQ5v9iNOKrK8hGrK0wq/L/k8KmYBk6iHe7HhqRWyebtYkCfsNLQQkCoXF6T5szlyfx+zWyseasa2FevWTFeyc4KtNFXQqgbkisByJBFs9uf0PYF7/zZnr2lbHLRoqDqBKXO+BFgd2yShOYlPXMf4sneRam3L 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: memcg->socket_pressure is initialised with jiffies when the memcg is created. Once vmpressure detects that the cgroup is under memory pressure, the field is updated with jiffies + HZ to signal the fact to the socket layer and suppress memory allocation for one second. Otherwise, the field is not updated. mem_cgroup_under_socket_pressure() uses time_before() to check if jiffies is less than memcg->socket_pressure, and this has a bug on 32-bit kernel. if (time_before(jiffies, memcg->socket_pressure)) return true; As time_before() casts the final result to long, the acceptable delta between two timestamps is 2 ^ (BITS_PER_LONG - 1). On 32-bit kernel with CONFIG_HZ=1000, this is about 24 days. >>> (2 ** 31) / 1000 / 60 / 60 / 24 24.855134814814818 Once 24 days have passed since the last update of socket_pressure, mem_cgroup_under_socket_pressure() starts to lie until the next 24 days pass. Thus, we need to update socket_pressure to a recent timestamp periodically on 32-bit kernel. Let's do that every 24 hours, with a variation of about 0 to 4 hours. The variation is to avoid bursting by cgroups created within a small timeframe, like boot-up. The work could be racy but does not take vmpr->sr_lock nor re-evaluate vmpressure_calc_level() under the assumption that socket_pressure will get updated soon if under memory pressure, because it persists only for one second. Note that we don't need to worry about 64-bit machines unless they serve for 300 million years. >>> (2 ** 63) / 1000 / 60 / 60 / 24 / 365 292471208.6775361 Fixes: 8e8ae645249b8 ("mm: memcontrol: hook up vmpressure to socket pressure") Reported-by: Neal Cardwell Signed-off-by: Kuniyuki Iwashima --- include/linux/vmpressure.h | 3 +++ mm/vmpressure.c | 52 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 55 insertions(+) diff --git a/include/linux/vmpressure.h b/include/linux/vmpressure.h index 6a2f51ebbfd35..946c1b284d4d4 100644 --- a/include/linux/vmpressure.h +++ b/include/linux/vmpressure.h @@ -25,6 +25,9 @@ struct vmpressure { struct mutex events_lock; struct work_struct work; +#if BITS_PER_LONG == 32 + struct delayed_work delayed_work; +#endif }; struct mem_cgroup; diff --git a/mm/vmpressure.c b/mm/vmpressure.c index bd5183dfd8791..cd978d580d9a7 100644 --- a/mm/vmpressure.c +++ b/mm/vmpressure.c @@ -215,6 +215,51 @@ static void vmpressure_work_fn(struct work_struct *work) } while ((vmpr = vmpressure_parent(vmpr))); } +#if BITS_PER_LONG == 32 +static void vmpressure_update_socket_pressure(struct vmpressure *vmpr) +{ + struct mem_cgroup *memcg = vmpressure_to_memcg(vmpr); + unsigned long delay, variation; + + /* + * The acceptable delta for time_before() is up to 2 ^ (BITS_PER_LONG - 1), + * which is 24 days with CONFIG_HZ=1000, so once-per-day is enough. + */ + delay = HZ * 60 * 60 * 24; + + /* + * Add variation (0 ~ 4 hours) to avoid bursting by cgourps created + * during boot. + */ + variation = (unsigned long)memcg; + variation ^= variation >> 16; + variation ^= variation >> 8; + variation %= 256; + + delay += HZ * 60 * variation; + + mod_delayed_work(system_unbound_wq, &vmpr->delayed_work, delay); +} + +static void vmpressure_update_socket_pressure_fn(struct work_struct *work) +{ + struct mem_cgroup *memcg; + struct vmpressure *vmpr; + + vmpr = container_of(to_delayed_work(work), struct vmpressure, delayed_work); + memcg = vmpressure_to_memcg(vmpr); + + /* + * Update socket_pressure to a recent timestamp, but don't signal + * false positive to mem_cgroup_under_socket_pressure(), thus -HZ. + */ + if (time_before(READ_ONCE(memcg->socket_pressure), jiffies)) + WRITE_ONCE(memcg->socket_pressure, jiffies - HZ); + + vmpressure_update_socket_pressure(vmpr); +} +#endif + /** * vmpressure() - Account memory pressure through scanned/reclaimed ratio * @gfp: reclaimer's gfp mask @@ -462,6 +507,10 @@ void vmpressure_init(struct vmpressure *vmpr) mutex_init(&vmpr->events_lock); INIT_LIST_HEAD(&vmpr->events); INIT_WORK(&vmpr->work, vmpressure_work_fn); +#if BITS_PER_LONG == 32 + INIT_DELAYED_WORK(&vmpr->delayed_work, vmpressure_update_socket_pressure_fn); + vmpressure_update_socket_pressure(vmpr); +#endif } /** @@ -478,4 +527,7 @@ void vmpressure_cleanup(struct vmpressure *vmpr) * goes away. */ flush_work(&vmpr->work); +#if BITS_PER_LONG == 32 + cancel_delayed_work_sync(&vmpr->delayed_work); +#endif } -- 2.50.0.727.gbf7dc18ff4-goog