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 993C5C3064D for ; Tue, 25 Jun 2024 12:42:01 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 25B606B0159; Tue, 25 Jun 2024 08:42:01 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 1E7626B0169; Tue, 25 Jun 2024 08:42:01 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 05D7C6B0159; Tue, 25 Jun 2024 08:42:01 -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 DDFDB6B0156 for ; Tue, 25 Jun 2024 08:42:00 -0400 (EDT) Received: from smtpin04.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay10.hostedemail.com (Postfix) with ESMTP id A00CFC1662 for ; Tue, 25 Jun 2024 12:42:00 +0000 (UTC) X-FDA: 82269373200.04.9E48AD2 Received: from mail-ej1-f54.google.com (mail-ej1-f54.google.com [209.85.218.54]) by imf28.hostedemail.com (Postfix) with ESMTP id 5AAC8C0015 for ; Tue, 25 Jun 2024 12:41:58 +0000 (UTC) Authentication-Results: imf28.hostedemail.com; dkim=pass header.d=gmail.com header.s=20230601 header.b=Ys8YeXTI; spf=pass (imf28.hostedemail.com: domain of urezki@gmail.com designates 209.85.218.54 as permitted sender) smtp.mailfrom=urezki@gmail.com; dmarc=pass (policy=none) header.from=gmail.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1719319307; 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:in-reply-to:references:references:dkim-signature; bh=yBzuofG6T7lvGEuAx25osRPS6h4Ox6IqcEZGgGnza9Y=; b=APRhij+7kFDjH6zNvCUeIpU8gvROl6+g5XZfFXZWOwYqImGMfYcFo/bG/00/MnFZmUqokM wkheJvssjmWBhI4BTuN7nEcblyYnszBNj7uVWfTb7/OVAtOHHZHtV9up/1hwFkUO3f/oUt UKfy4QjERy15b+zdtWrFe/DEvRC1ZRo= ARC-Authentication-Results: i=1; imf28.hostedemail.com; dkim=pass header.d=gmail.com header.s=20230601 header.b=Ys8YeXTI; spf=pass (imf28.hostedemail.com: domain of urezki@gmail.com designates 209.85.218.54 as permitted sender) smtp.mailfrom=urezki@gmail.com; dmarc=pass (policy=none) header.from=gmail.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1719319307; a=rsa-sha256; cv=none; b=jBo5uuH7msNImv/cgkbNgV4J01xn+uhNh1FXzeAkybKlJk7KHAjF1dXs7r805me33PT312 CzBau9YVICOwtaCc62nboI85m8LA0SQcUph7cb34ZS0EOdkVvtmvGt+dGHd4Dml+hPTWOt hL/B6Zn4/p8rtxubhnVPbyrYwmleiPM= Received: by mail-ej1-f54.google.com with SMTP id a640c23a62f3a-a6265d3ba8fso608663266b.0 for ; Tue, 25 Jun 2024 05:41:58 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1719319317; x=1719924117; darn=kvack.org; h=in-reply-to:content-disposition:mime-version:references:message-id :subject:cc:to:date:from:from:to:cc:subject:date:message-id:reply-to; bh=yBzuofG6T7lvGEuAx25osRPS6h4Ox6IqcEZGgGnza9Y=; b=Ys8YeXTI8EYd7OBLGq/hecivE8oslkpTE/6x1OtKi8fhv/O/3DTrjX5QdwsPiPitvZ YZw2Ph9UtVQYU2N+L2exImL1JKnXgA+T8BwggbLc/aOjO1+qCnSk984E8fJahRIEh9RS jYZqzJmZA1/39ZKUItx4arQsbVdfc5oTLrskecCqDvLz7Cgta6DdLy11G/i6UTxUQbC9 67/TvNVF08K/rG4bGa0Ctrmm2GMZMalZsMGoidk29F+7Ibb/7sT0MQtwLpMwJm6S+kdN SvzPeZmZZ/53uCEfEU2Q3nlalzfvH5Mr9g0GU0r66njfgQcEkg8vAUGuvVR2P8nvGCMp Tqpw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1719319317; x=1719924117; h=in-reply-to:content-disposition:mime-version:references:message-id :subject:cc:to:date:from:x-gm-message-state:from:to:cc:subject:date :message-id:reply-to; bh=yBzuofG6T7lvGEuAx25osRPS6h4Ox6IqcEZGgGnza9Y=; b=HsUBwSqjCDJ7AEfwIXvOgYJ7V/Q1odxNb79OYsZDcEoycemISdC/ykB0zxvqKnmqH+ 8MMPbJru+N7kwwcuVleLac/hxVhc2+kRTKxk3hxrbx2wBT1Nk5CFFF5hXcmPUXjXRNlQ ATZE3AMRN6YOITkkdNNP2mEVa9QvmSES1j0xpq+ZPAmE5cCNkuZIenEVdZreh7/Bqhiy G+TJB5Qm4Ek/pla+TPH0hQPJNPBXz3YgKCy7Xs7nmUtuCFL56sUg64/Z2NcdNiCZAuAd SEcYCx+mk1Ji93/gN2hAEw0t99RdQfj08dNdOnbNMPFiJ6nyQOl5sY0/3nLLR2oBNVYv PtJA== X-Forwarded-Encrypted: i=1; AJvYcCUJCM+XqgBvgc1fGB0W5BzU2YBSgL6yzsYTrTuif+8wyxX8hSy9kzMGh9FW2MIZCjcT1Q/oWvbT3Teiq7iS1Dq8ipU= X-Gm-Message-State: AOJu0YwAZPEwvgD+HS/qV0Be9HK2wlplR9hdhmFAn+q4rhMRTcKQmTNw CpYOr8U+xL7QPdceI3sZ9dyVYLAqyRSIUlGSZbmv5XhXanhS4IQg X-Google-Smtp-Source: AGHT+IHBTTZyGAjFLKKGRDnrtRxXSLYDLYujtC0zC79VRvwIGx29Betppcd4H0MdIE0BeqapvW25yQ== X-Received: by 2002:a17:906:52d2:b0:a6e:f7ee:b1fa with SMTP id a640c23a62f3a-a7242e13207mr406032166b.72.1719319316725; Tue, 25 Jun 2024 05:41:56 -0700 (PDT) Received: from pc638.lan (host-185-121-47-193.sydskane.nu. [185.121.47.193]) by smtp.gmail.com with ESMTPSA id a640c23a62f3a-a7251ace5besm234139266b.179.2024.06.25.05.41.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 25 Jun 2024 05:41:56 -0700 (PDT) From: Uladzislau Rezki X-Google-Original-From: Uladzislau Rezki Date: Tue, 25 Jun 2024 14:41:54 +0200 To: Baoquan He Cc: Uladzislau Rezki , Nick Bowler , Hailong Liu , linux-kernel@vger.kernel.org, Linux regressions mailing list , linux-mm@kvack.org, sparclinux@vger.kernel.org, Andrew Morton Subject: Re: PROBLEM: kernel crashes when running xfsdump since ~6.4 Message-ID: References: <75e17b57-1178-4288-b792-4ae68b19915e@draconx.ca> <00d74f24-c49c-460e-871c-d5af64701306@draconx.ca> <20240621033005.6mccm7waduelb4m5@oppo.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: X-Stat-Signature: q8hmpbs38bxhz7r7pqhhze113i8g515x X-Rspam-User: X-Rspamd-Queue-Id: 5AAC8C0015 X-Rspamd-Server: rspam02 X-HE-Tag: 1719319318-26911 X-HE-Meta: U2FsdGVkX1/QViRSwHLlqu3hhSLgcnsJPy1G0esEtppYRuBTJXdpcUp69f7BfbfxDGl+8zfXIfv88r+peiADZ1gABNDzr52iVZaNFNA8/DLuLxhkTe+mGoYBuOloseKJB/QrXSsdVQ+hHYh5eYN26Ynp+7EpRWuug0OpmcqigRWtra786uRLnDTixyD6e65DyjpFF8Sia66DCnqPCvJE8GsugtadKdaqAKBLiAqGGkCyZ0TKEG2qz9x+eptCsybWtHx8j1qt8Za4caSzrSYpUKg/NnDghvRZKF7G4vhn9eBxrlGW8/81LJhnvY9HU6MS6R8PqjSYf4szUNG1ft9GXpLmNDAeVbCAD3CkOGBPJO7H8wDJMGnrEgCTTeS2AVXcu+zpYTMsRu1tqFeQDjD0qjJ45fXsoG5cR/VIn71gisNFvq5f9+d7NpKWMD5WgpkxOxlfq+ybrnD+0idAdRmRJLHr0o8HnsDioAS2DOLbZ6O8S1+xMulTdBMv9OyHM2kWuzxOETJ8BUpjE/EXr9RSYRd2/Ta0hGUIkv74ICiXmcXiZDm9wkNnzPBD4EIOChT6xSOdjPY4LNOYmS550C0trn8XS7U5c4bilYjJBCrfKcVhMzuDSaBT3fo/FW9BxXA+vlmHfqxjyavr4B8QwHlujs+4D0Miqz2j41m2Tq9haLs9u6GCqdEJQew0zgpTybHPIqhyBkXxCvX+a2YIXRLu/9h1P/oTZ7RgIxTgmCZQ+09yiog+xS1827VUfgVSVsCfne64ix0z+B9avq9t/PEx5ninv8bPAmuWVYYxVGQYQOHDZ+PTrBSC5emudEG4SjhxVnKio8XOjlAt8FIGyd5Kg0ZQOkYfr/NMM/o8cpyfs2sj9Kw/RhdX4sBV4VbxXG6NBpqctQZIFy/Gn9MNZ36f2rxRwTivgbBKtscvSEWROzYG+2NxPuaV3Ek06gVqgDp2ZjBY5eL8GUVlW40b5y0 YN8asrK3 eslms+UJDpbJiTbEURm91/5MhRwoiApx7iyyZqkb/cgGNAA+T1zGRCVqTbKcBGoITxLxMxD+QuTxkHD0DFlZTU3vHkO8/RPGgrDnWrR1SB9Ib9wwTR4s1YtiEmDMyw1iDvoBMTr7uALGqcs/v5Dfor3A7p74OXeTkMmV/nQ3cTj2knBbBSoQYY/yZDKW7elG5dcvftgniB+ACux6omIDbDUf5lSki/fiTUS1wRPiCO/Zd5IUbNiEMVRhoDuCs5dkDBIbyqEDQ6da29Nz3TA8oPMguOLdn9MspYG2YOEOXl2CF5ZjD9EJYkQ63ZTN/MQ//EvvdLr5/0kipLtA= 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: On Tue, Jun 25, 2024 at 11:30:33AM +0800, Baoquan He wrote: > On 06/24/24 at 02:16pm, Uladzislau Rezki wrote: > > On Fri, Jun 21, 2024 at 10:02:50PM +0800, Baoquan He wrote: > > > On 06/21/24 at 11:44am, Uladzislau Rezki wrote: > > > > On Fri, Jun 21, 2024 at 03:07:16PM +0800, Baoquan He wrote: > > > > > On 06/21/24 at 11:30am, Hailong Liu wrote: > > > > > > On Thu, 20. Jun 14:02, Nick Bowler wrote: > > > > > > > On 2024-06-20 02:19, Nick Bowler wrote: > > > ...... > > > > > diff --git a/mm/vmalloc.c b/mm/vmalloc.c > > > > > index be2dd281ea76..18e87cafbaf2 100644 > > > > > --- a/mm/vmalloc.c > > > > > +++ b/mm/vmalloc.c > > > > > @@ -2542,7 +2542,7 @@ static DEFINE_PER_CPU(struct vmap_block_queue, vmap_block_queue); > > > > > static struct xarray * > > > > > addr_to_vb_xa(unsigned long addr) > > > > > { > > > > > - int index = (addr / VMAP_BLOCK_SIZE) % num_possible_cpus(); > > > > > + int index = (addr / VMAP_BLOCK_SIZE) % nr_cpu_ids; > > > > > > > > > > return &per_cpu(vmap_block_queue, index).vmap_blocks; > > > > > } > > > > > > > > > The problem i see is about not-initializing of the: > > > > > > > > for_each_possible_cpu(i) { > > > > struct vmap_block_queue *vbq; > > > > struct vfree_deferred *p; > > > > > > > > vbq = &per_cpu(vmap_block_queue, i); > > > > spin_lock_init(&vbq->lock); > > > > INIT_LIST_HEAD(&vbq->free); > > > > p = &per_cpu(vfree_deferred, i); > > > > init_llist_head(&p->list); > > > > INIT_WORK(&p->wq, delayed_vfree_work); > > > > xa_init(&vbq->vmap_blocks); > > > > } > > > > > > > > > > > > correctly or fully. It is my bad i did not think that CPUs in a possible mask > > > > can be non sequential :-/ > > > > > > > > nr_cpu_ids - is not the max possible CPU. For example, in Nick case, > > > > when he has two CPUs, num_possible_cpus() and nr_cpu_ids are the same. > > > > > > I checked the generic version of setup_nr_cpu_ids(), from codes, they > > > are different with my understanding. > > > > > > kernel/smp.c > > > void __init setup_nr_cpu_ids(void) > > > { > > > set_nr_cpu_ids(find_last_bit(cpumask_bits(cpu_possible_mask), NR_CPUS) + 1); > > > } > > > > > I see that it is not a weak function, so it is generic, thus the > > behavior can not be overwritten, which is great. This does what we > > need. > > > > Thank you for checking this you are right! > > Thanks for confirming this. > > > > > Then it is just a matter of proper initialization of the hash: > > > > > > diff --git a/mm/vmalloc.c b/mm/vmalloc.c > > index 5d3aa2dc88a8..1733946f7a12 100644 > > --- a/mm/vmalloc.c > > +++ b/mm/vmalloc.c > > @@ -5087,7 +5087,13 @@ void __init vmalloc_init(void) > > */ > > vmap_area_cachep = KMEM_CACHE(vmap_area, SLAB_PANIC); > > > > - for_each_possible_cpu(i) { > > + /* > > + * We use "nr_cpu_ids" here because some architectures > > + * may have "gaps" in cpu-possible-mask. It is OK for > > + * per-cpu approaches but is not OK for cases where it > > + * can be used as hashes also. > > + */ > > + for (i = 0; i < nr_cpu_ids; i++) { > > I was wrong about earlier comments. Percpu variables are only available > on possible CPUs. For those nonexistent possible CPUs of static percpu > variable vmap_block_queue, there isn't memory allocated and mapped for > them. So accessing into them will cause problem. > > In Nick's case, there are only CPU0, CPU2. If you access > &per_cpu(vmap_block_queue, 1), problem occurs. So I think we may need to > change to take other way for vbq. E.g: > 1) Storing the vb in the nearest neighbouring vbq on possible CPU as > below draft patch; > 2) create an normal array to store vbq of size nr_cpu_ids, then we can > store/fetch each vbq on non-possible CPU? > See below how the patch look like if we switch to hash array: diff --git a/mm/vmalloc.c b/mm/vmalloc.c index 45e1506d58c3..a8bcd9ceec2d 100644 --- a/mm/vmalloc.c +++ b/mm/vmalloc.c @@ -2501,7 +2501,8 @@ struct vmap_block { }; /* Queue of free and dirty vmap blocks, for allocation and flushing purposes */ -static DEFINE_PER_CPU(struct vmap_block_queue, vmap_block_queue); +static struct vmap_block_queue *vmap_block_queue; +static bool vmap_block_queue_initialized; /* * In order to fast access to any "vmap_block" associated with a @@ -2542,9 +2543,9 @@ static DEFINE_PER_CPU(struct vmap_block_queue, vmap_block_queue); static struct xarray * addr_to_vb_xa(unsigned long addr) { - int index = (addr / VMAP_BLOCK_SIZE) % num_possible_cpus(); + int index = (addr / VMAP_BLOCK_SIZE) % nr_cpu_ids; - return &per_cpu(vmap_block_queue, index).vmap_blocks; + return &vmap_block_queue[index].vmap_blocks; } /* @@ -2626,7 +2627,7 @@ static void *new_vmap_block(unsigned int order, gfp_t gfp_mask) return ERR_PTR(err); } - vbq = raw_cpu_ptr(&vmap_block_queue); + vbq = &vmap_block_queue[raw_smp_processor_id()]; spin_lock(&vbq->lock); list_add_tail_rcu(&vb->free_list, &vbq->free); spin_unlock(&vbq->lock); @@ -2657,6 +2658,9 @@ static bool purge_fragmented_block(struct vmap_block *vb, struct vmap_block_queue *vbq, struct list_head *purge_list, bool force_purge) { + if (!vmap_block_queue_initialized) + return false; + if (vb->free + vb->dirty != VMAP_BBMAP_BITS || vb->dirty == VMAP_BBMAP_BITS) return false; @@ -2692,7 +2696,12 @@ static void purge_fragmented_blocks(int cpu) { LIST_HEAD(purge); struct vmap_block *vb; - struct vmap_block_queue *vbq = &per_cpu(vmap_block_queue, cpu); + struct vmap_block_queue *vbq; + + if (!vmap_block_queue_initialized) + return; + + vbq = &vmap_block_queue[cpu]; rcu_read_lock(); list_for_each_entry_rcu(vb, &vbq->free, free_list) { @@ -2715,7 +2724,7 @@ static void purge_fragmented_blocks_allcpus(void) { int cpu; - for_each_possible_cpu(cpu) + for (cpu = 0; cpu < nr_cpu_ids; cpu++) purge_fragmented_blocks(cpu); } @@ -2739,7 +2748,7 @@ static void *vb_alloc(unsigned long size, gfp_t gfp_mask) order = get_order(size); rcu_read_lock(); - vbq = raw_cpu_ptr(&vmap_block_queue); + vbq = &vmap_block_queue[raw_smp_processor_id()]; list_for_each_entry_rcu(vb, &vbq->free, free_list) { unsigned long pages_off; @@ -2822,13 +2831,13 @@ static void _vm_unmap_aliases(unsigned long start, unsigned long end, int flush) LIST_HEAD(purge_list); int cpu; - if (unlikely(!vmap_initialized)) + if (unlikely(!vmap_initialized || !vmap_block_queue_initialized)) return; mutex_lock(&vmap_purge_lock); - for_each_possible_cpu(cpu) { - struct vmap_block_queue *vbq = &per_cpu(vmap_block_queue, cpu); + for (cpu = 0; cpu < nr_cpu_ids; cpu++) { + struct vmap_block_queue *vbq = &vmap_block_queue[cpu]; struct vmap_block *vb; unsigned long idx; @@ -2910,7 +2919,7 @@ void vm_unmap_ram(const void *mem, unsigned int count) kasan_poison_vmalloc(mem, size); - if (likely(count <= VMAP_MAX_ALLOC)) { + if (likely(count <= VMAP_MAX_ALLOC) && vmap_block_queue_initialized) { debug_check_no_locks_freed(mem, size); vb_free(addr, size); return; @@ -2946,7 +2955,7 @@ void *vm_map_ram(struct page **pages, unsigned int count, int node) unsigned long addr; void *mem; - if (likely(count <= VMAP_MAX_ALLOC)) { + if (likely(count <= VMAP_MAX_ALLOC && vmap_block_queue_initialized)) { mem = vb_alloc(size, GFP_KERNEL); if (IS_ERR(mem)) return NULL; @@ -5087,17 +5096,28 @@ void __init vmalloc_init(void) */ vmap_area_cachep = KMEM_CACHE(vmap_area, SLAB_PANIC); + vmap_block_queue = kmalloc_array( + nr_cpu_ids, sizeof(struct vmap_block_queue), GFP_NOWAIT); + + if (vmap_block_queue) { + for (i = 0; i < nr_cpu_ids; i++) { + struct vmap_block_queue *vbq = + &vmap_block_queue[i]; + + spin_lock_init(&vbq->lock); + INIT_LIST_HEAD(&vbq->free); + xa_init(&vbq->vmap_blocks); + } + } else { + pr_err("Failed to allocate vmap_block_queue array, use fallback path!\n"); + } + for_each_possible_cpu(i) { - struct vmap_block_queue *vbq; - struct vfree_deferred *p; + struct vfree_deferred *p = + &per_cpu(vfree_deferred, i); - vbq = &per_cpu(vmap_block_queue, i); - spin_lock_init(&vbq->lock); - INIT_LIST_HEAD(&vbq->free); - p = &per_cpu(vfree_deferred, i); init_llist_head(&p->list); INIT_WORK(&p->wq, delayed_vfree_work); - xa_init(&vbq->vmap_blocks); } /* @@ -5125,6 +5145,9 @@ void __init vmalloc_init(void) vmap_init_free_space(); vmap_initialized = true; + if (vmap_block_queue) + vmap_block_queue_initialized = true; + vmap_node_shrinker = shrinker_alloc(0, "vmap-node"); if (!vmap_node_shrinker) { pr_err("Failed to allocate vmap-node shrinker!\n"); Any thoughts? -- Uladzislau Rezki