Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=209.85.218.54 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1792690110; b=lmva7OOGu+S1pPAncoJdE5IDX94XKQu8ut/FE2lKwrbbo8353q+JwU/j5f12ApmDeYJ2 jYNfmKRILP0M77HsPHMWf2sTb8sgdNU+F8R9ksH2mfwM5U469Dyugk3LdGFDvbj3GzHjm dT/Z0BpOB3yTGMdhXS32qUwGl/PL5Dn4JCSswaoTqakMMuVBsxEGop/DCPekHjVaVA1Ft UJKVeqwYmB3m+5R1qy6nZJzqQ7TggLcM0F4XTqaHn8iPL3jVy/VfZLUAI0B17km+h4M5P F38zZViNXdzxFnrCfJILNRnU2gKM4f7e+z3f08RxOnZIUBCg0Myq0xNdhn2reE2da2g== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1792690110; h=DMARC-Filter:Received:DKIM-Signature:X-Google-DKIM-Signature: X-Forwarded-Encrypted:X-Gm-Message-State:X-Gm-Gg:X-Received:Received: From:X-Google-Original-From:Date:To:Cc:Subject:Message-ID:References: MIME-Version:Content-Type:Content-Disposition: Content-Transfer-Encoding:In-Reply-To; bh=cLrnGhTI6RKzB8rOxMsMpPnclKeIkJqIQd4I4ioIEaw=; b=V7wCq0PqrpMjHOwXZmwd19THQ6N49uZQT8sigxEfDnSWfE+7oSBvRx9Pu0YVqpzYhsXN pXXkbq4YiBO38hQcM7g56VGBPCnWGmrjfFD1rwOmWxsubbfzBDae0eXu9vxgZ6TG+8ffF IW9MMI8ML6k8vQc4ywHGbf+taWh2n6wl263H+G60W0Dhi3N1TUYtwvw8wHUPVQtuJghkp cGLcntrJkEv4gYJ5aj3JMHFh20rBx97JmPWPKfyKBBc+sE4kW5Hg2spckwi3w0QoEaejl tCDphqgEMyvbm3bw+WlQIK9+bWyaoiISAAQ6qe3//cIO446MyLK4Cd9Q2aMCwk9HpPQ== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20251104 header.b=XGvpdmJh; arc=none smtp.remote-ip=209.85.218.54 Received: from mail-ej1-f54.google.com (mail-ej1-f54.google.com [209.85.218.54]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id CE794606A31B for ; Thu, 22 Oct 2026 17:28:29 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.2 smtp.subspace.kernel.org CE794606A31B Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key, unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20251104 header.b=XGvpdmJh Received: by mail-ej1-f54.google.com with SMTP id a640c23a62f3a-c43373ae89aso6315666b.3 for ; Thu, 22 Oct 2026 10:28:29 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1792690108; x=1793294908; darn=lists.linux.dev; h=in-reply-to:content-transfer-encoding:content-disposition :content-type:mime-version:references:message-id:subject:cc:to:date :from:from:to:cc:subject:date:message-id:reply-to:content-type; bh=cLrnGhTI6RKzB8rOxMsMpPnclKeIkJqIQd4I4ioIEaw=; b=XGvpdmJh/QOx57uRUlTRrGdX9coi/BpUdSmQbxoM3CzoRi4FW4NNidj9E7Sa8JLUsl 99PQdGnaJTKYPNjAU0JQKMg4Oi7gkMKR5jtlxdbQEI0SCsCUzuX5f1Go3TE3x6LSGPZd ze/5A5RPCKWrieirlwB6f01F5KjeTLELBtJxsSQPAHVzJVsGJdCx9MxhoonW5biUp4Qg fPscrUlhRocLvllvSILsH9Sa0KgVa4LVN+ImrqtNNjCRoIwXRmRz0/5itT/uo0BxOhQ6 hK3Vgv/nl8ATlfT/mmjGgblWWqAQ9MrF1zzW7290ft1wFXGdms199zz3KHjoX5/xjdeo 2OEg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1792690108; x=1793294908; h=in-reply-to:content-transfer-encoding:content-disposition :content-type:mime-version:references:message-id:subject:cc:to:date :from:x-gm-gg:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to:content-type; bh=cLrnGhTI6RKzB8rOxMsMpPnclKeIkJqIQd4I4ioIEaw=; b=Qsn4MkwuJIbqAzTsxm+IKjMkMT9tL80ALFipBNY8M14peaLP4dtIMmpkgjCS7Y8BKI FuxRX4VcMWUSP8kHr/0+dBvKyhwfZbQao/IdqQl8z7PFGZHC/M5u0cVSgV7kGATj7Fst IBEqCp0O4kXCx9vhJH2QJs2AylzBxFJJr0FxtTEDDrDa7WDtZU+Yflp8MVcqeg52aFJL h67vIp1Sfs6eIdg3iFRbV3s9Hva9Q/GyiEjuZ2dT2vpyn8kcZ4LNbvXASze84kNFBTEB lCgGe+wCiEoS6zIurS1UPudRc7S/BhGb7WfJSNKr5G1tm7HNIgz4hs5b2HUFXbuwbzHQ RhXw== X-Forwarded-Encrypted: i=1; AKwUvBykj0rtZrWpExH7vV+Fn3zVD18hPVq9a9m1wjRkXx46XbUFOfie10LaFbqIahxPymlcO6RXn3e1/8Ro36NSp/I=@lists.linux.dev X-Gm-Message-State: AFq9FYL6Sra2qC3H21BN0lS+dZwHANpjfaBLJKkSBH7lCaGYK/EmMnR/ jBWThUXKu5naEin+VEcKEcrE5INw5VBfIZijwsZ1g+6qnfxiaLMhwiFr X-Gm-Gg: AYBFou2q7o1NY4EfnGmtvIjH6fwa5J/rWmXI0UflazSnvmf7tzSJ70UHAm6KiUqA/j4 fcN5EfaAObDvLU5Eqp6BGbNh97VzRmOYd8O1OwPbwoGLY50S0qKdz64nnAvVhrbYMpY2Tbafs7n 55k6q5mOMIRA4Y8aC2sttfRJpXmwAYxIEgj+vvp/lGGtE/+RQVhmQXzAeu4b9od0/qFcQaEmXlZ KnQrYKq/8NH6sgcrIWBlDm4n8NyY1B7FqLDsR0WmK+VhFdd6S8bEzhA3EH7wloAr3SZZFYDuvNQ fT25D6pLv3Yesy0U1JV7uvelVpa+UzRe6cMvFb2S0c5BjorUbqrtUy5NSMnmNWxxjzDIRR1L9f1 rThXeUG1aDe/gK9eEelfzFejY9pssPBmQeRFNJIvCRr3blpmjkFnbpMH8pJLM0MtiFN1Q52/tRR 9xvB9R6wgzaoo3t5EcBr57FS8HgK2NzpYAkgLTaAP/8OcLhF8z6glrtoRBCER1qe+iNcLnpPndJ hlSjmkZF/0cvs4VilufAe8c+JKckaI9oIUju1uSBw== X-Received: by 2002:a17:906:dc93:b0:c46:645f:cedc with SMTP id a640c23a62f3a-c46799d0f16mr618756166b.46.1792690107814; Thu, 22 Oct 2026 10:28:27 -0700 (PDT) Received: from milan ([2001:9b1:d5a0:a500::24b]) by smtp.gmail.com with ESMTPSA id a640c23a62f3a-c46a5cfa594sm10149166b.80.2026.10.22.10.28.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 22 Oct 2026 10:28:27 -0700 (PDT) From: Uladzislau Rezki X-Google-Original-From: Uladzislau Rezki Date: Thu, 22 Oct 2026 19:28:25 +0200 To: Hao Ge Cc: Uladzislau Rezki , Suren Baghdasaryan , kasan-dev@googlegroups.com, linux-mm@kvack.org, sashiko-reviews@lists.linux.dev, Madhavan Srinivasan , Michael Ellerman , Nicholas Piggin , "Ritesh Harjani (IBM)" , "Christophe Leroy (CS GROUP)" , Shrikanth Hegde , Alexander Potapenko , Marco Elver , Dmitry Vyukov , Andrew Morton , Dennis Zhou , Tejun Heo , Christoph Lameter Subject: Re: [PATCH v2 3/5] mm/vmalloc: undo partial mappings inside the mapping functions Message-ID: References: <20261019054531.87652-1-hao.ge@linux.dev> <20261019054531.87652-4-hao.ge@linux.dev> <2b83dfaa-424b-4464-830e-a7714a816d5c@linux.dev> X-Mailing-List: sashiko-reviews@lists.linux.dev List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: On Thu, Oct 22, 2026 at 09:33:19PM +0800, Hao Ge wrote: > Hi Uladzislau and Suren > > On 2026/10/20 23:08, Uladzislau Rezki wrote: > > On Tue, Oct 20, 2026 at 09:27:14PM +0800, Hao Ge wrote: > >> > >> On 10/20/26 18:03, Hao Ge wrote: > >>> Hi Suren and Ulad > >>> > >>> Sashiko reported several issues, and they all look real. > >>> I have some ideas for fixing the first few; > >>> of course, please correct me if I get anything wrong. > >>> > >>> I'd like to discuss the last issue with you all. > >>> > >>> > >>> On 2026/10/20 13:45, sashiko-bot@kernel.org wrote: > >>>> Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider: > >>>> - [High] mm/vmalloc: infinite loop in vunmap_pte_range() on unaligned error rollback > >>>> - [High] mm/vmalloc: __vmap_pages_range_noflush() calls cond_resched() in atomic context > >>>> - [Medium] mm/vmalloc: vmap_page_range() calls flush_cache_vmap() before error rollback > >>>> -- > >>>> > >>>> commit 043026437ba63b051df5d14470fe69ce8fa8825c > >>>> Author: Hao Ge > >>>> > >>>> mm/vmalloc: undo partial mappings inside the mapping functions > >>>> > >>>> This commit adds rollback logic using __vunmap_range_noflush() and > >>>> kmsan_vunmap_range_noflush() into vmap_page_range(), > >>>> __vmap_pages_range_noflush(), and vmap_pages_range_noflush() when page > >>>> table installation or KMSAN metadata setup fails. It also adds range and > >>>> page_shift validation in __vmap_pages_range_noflush(). > >>>> > >>>>> diff --git a/mm/vmalloc.c b/mm/vmalloc.c > >>>>> index 44e0eb32708f1..75aa5acf55660 100644 > >>>>> --- a/mm/vmalloc.c > >>>>> +++ b/mm/vmalloc.c > >>>>> @@ -363,6 +363,9 @@ int vmap_page_range(unsigned long addr, unsigned long end, > >>>>> if (!err) > >>>>> err = kmsan_ioremap_page_range(addr, end, phys_addr, prot, > >>>>> ioremap_max_page_shift); > >>>>> + if (err) > >>>>> + __vunmap_range_noflush(addr, end); > >>>>> + > >>>>> return err; > >>>>> } > >>>> [Severity: High] > >>>> What happens here when vmap_range_noflush() returns -EINVAL for a range > >>>> where end - addr is not PAGE_SIZE-aligned? > >>>> > >>>> In vmap_pte_range(), commit a739e6b557af09 added a check to bail out on > >>>> unaligned ranges specifically to avoid an infinite loop: > >>>> > >>>> mm/vmalloc.c:vmap_pte_range() { > >>>> ... > >>>> if (WARN_ON_ONCE(!PAGE_ALIGNED(end - addr))) > >>>> return -EINVAL; > >>>> } > >>>> > >>>> This can be reached on 64KB page kernels via pci_remap_iospace() -> > >>>> vmap_page_range() with 16KB/32KB/48KB PCI I/O ranges (for example via > >>>> loongson_pci_probe() or acpi_pci_root_remap_iospace()). > >>>> > >>>> When vmap_pte_range() returns -EINVAL, vmap_page_range() now calls > >>>> __vunmap_range_noflush(addr, end) with the unaligned range. Whenever a PMD > >>>> in [addr, end) is already populated with a PTE table (such as the > >>>> PCI_IOBASE PMD populated during early boot by reserve_pio_range(), or an > >>>> earlier PMD mapped in the same call), __vunmap_range_noflush() descends > >>>> into vunmap_pte_range(), which has no alignment check: > >>>> > >>>> mm/vmalloc.c:vunmap_pte_range() { > >>>> ... > >>>> do { > >>>> ... > >>>> ptent = ptep_get_and_clear(&init_mm, addr, pte); > >>>> WARN_ON(!pte_none(ptent) && !pte_present(ptent)); > >>>> } while (pte += (size >> PAGE_SHIFT), addr += size, addr != end); > >>>> } > >>>> > >>>> Because end - addr is not a multiple of PAGE_SIZE, won't addr step past end > >>>> and loop infinitely, clearing unrelated kernel PTEs and corrupting memory > >>>> past the PTE table? > >>>> > >>> That sounds reasonable. I will add a separate patch in the next version to fix > >>> this problem. > >>> > >>>> [Severity: Medium] > >>>> Also in vmap_page_range(), flush_cache_vmap(addr, end) is called > >>>> unconditionally before checking err and before rolling back with > >>>> __vunmap_range_noflush(addr, end): > >>>> > >>>> mm/vmalloc.c:vmap_page_range() { > >>>> err = vmap_range_noflush(addr, end, phys_addr, pgprot_nx(prot), > >>>> ioremap_max_page_shift); > >>>> flush_cache_vmap(addr, end); > >>>> if (!err) > >>>> err = kmsan_ioremap_page_range(addr, end, phys_addr, prot, > >>>> ioremap_max_page_shift); > >>>> if (err) > >>>> __vunmap_range_noflush(addr, end); > >>>> > >>>> return err; > >>>> } > >>>> > >>>> On UML, flush_cache_vmap is defined as flush_tlb_kernel_range: > >>>> > >>>> arch/um/include/asm/cacheflush.h: > >>>> #define flush_cache_vmap flush_tlb_kernel_range > >>>> > >>>> When vmap_range_noflush() fails partway through or > >>>> kmsan_ioremap_page_range() fails, flush_cache_vmap() runs while the > >>>> partially installed PTEs are still pte_present(), causing > >>>> update_pte_range() in arch/um/kernel/tlb.c to map them into the host OS via > >>>> ops->mmap() and clear _PAGE_NEEDSYNC: > >>>> > >>>> arch/um/kernel/tlb.c:update_pte_range() { > >>>> ... > >>>> if (pte_present(*pte)) { > >>>> ... > >>>> ret = ops->mmap(ops->mm_idp, addr, PAGE_SIZE, > >>>> prot, fd, offset); > >>>> } else > >>>> ret = ops->unmap(ops->mm_idp, addr, PAGE_SIZE); > >>>> > >>>> *pte = pte_mkuptodate(*pte); > >>>> } > >>>> > >>>> When __vunmap_range_noflush(addr, end) then clears the software PTEs > >>>> without a subsequent TLB flush or unmap notification, won't those host OS > >>>> mmap mappings be left behind? Should flush_cache_vmap(addr, end) only be > >>>> called after both vmap_range_noflush() and kmsan_ioremap_page_range() > >>>> succeed? > >>>> > >>> That sounds reasonable. I will add this logic in the next version. > >>> > >>>>> @@ -683,27 +686,35 @@ int __vmap_pages_range_noflush(unsigned long addr, unsigned long end, > >>>>> pgprot_t prot, struct page **pages, unsigned int page_shift) > >>>>> { > >>>>> unsigned int i, nr = (end - addr) >> PAGE_SHIFT; > >>>>> + unsigned long start = addr; > >>>>> + int err = 0; > >>>>> + > >>>>> + if (WARN_ON_ONCE(addr >= end)) > >>>>> + return -EINVAL; > >>>>> if (WARN_ON_ONCE(page_shift < PAGE_SHIFT)) > >>>>> return -EINVAL; > >>>>> if (!IS_ENABLED(CONFIG_HAVE_ARCH_HUGE_VMALLOC) || > >>>>> - page_shift == PAGE_SHIFT) > >>>>> - return vmap_small_pages_range_noflush(addr, end, prot, pages); > >>>>> - > >>>>> - for (i = 0; i < nr; i += 1U << (page_shift - PAGE_SHIFT)) { > >>>>> - int err; > >>>>> - > >>>>> - err = vmap_range_noflush(addr, addr + (1UL << page_shift), > >>>>> + page_shift == PAGE_SHIFT) { > >>>>> + err = vmap_small_pages_range_noflush(addr, end, prot, pages); > >>>>> + } else { > >>>>> + for (i = 0; i < nr; i += 1U << (page_shift - PAGE_SHIFT)) { > >>>>> + err = vmap_range_noflush(addr, addr + (1UL << page_shift), > >>>>> page_to_phys(pages[i]), prot, > >>>>> page_shift); > >>>>> - if (err) > >>>>> - return err; > >>>>> + if (err) > >>>>> + break; > >>>>> - addr += 1UL << page_shift; > >>>>> + addr += 1UL << page_shift; > >>>>> + } > >>>>> } > >>>>> - return 0; > >>>>> + /* Undo the PTEs installed before the failure. */ > >>>>> + if (err) > >>>>> + __vunmap_range_noflush(start, end); > >>>>> + > >>>>> + return err; > >>>>> } > >>>> [Severity: High] > >>>> Similarly here, __vmap_pages_range_noflush() checks addr >= end, but does > >>>> not check PAGE_ALIGNED(addr) or PAGE_ALIGNED(end). > >>>> > >>>> If a caller passes a sub-page or unaligned range (for example, 0 < end - > >>>> addr < PAGE_SIZE), nr = (end - addr) >> PAGE_SHIFT evaluates to 0, so the > >>>> huge-page path still maps nothing and returns 0, while the small-page path > >>>> loops infinitely in vmap_pages_pte_range(). And if the huge-page path fails > >>>> on an unaligned range, __vunmap_range_noflush(start, end) will hit the same > >>>> infinite loop in vunmap_pte_range(). > >>>> > >>>> Should both vmap_page_range() and __vmap_pages_range_noflush() validate > >>>> PAGE_ALIGNED(addr) && PAGE_ALIGNED(end) upfront before attempting to map or > >>>> unmap? > >>>> > >>> I think We need to check both PAGE_ALIGNED(addr) and PAGE_ALIGNED(end). > >>> As an example: if addr is PAGE-aligned, end is not, and end - addr < PAGE_SIZE, > >>> then nr becomes zero. On the huge page path, we simply return 0 with no work performed. > >>> > >>> At the same time, vmap_pages_pte_range() needs the same guard as commit > >>> a739e6b557af ("mm: vmalloc: WARN_ON if mapping size is not PAGE_SIZE aligned"), > >>> to protect against unaligned ranges. > >>> > >>> So will do next version. > >>> > >>>>> int vmap_pages_range_noflush(unsigned long addr, unsigned long end, > >>>>> @@ -715,7 +726,16 @@ int vmap_pages_range_noflush(unsigned long addr, unsigned long end, > >>>>> if (ret) > >>>>> return ret; > >>>>> - return __vmap_pages_range_noflush(addr, end, prot, pages, page_shift); > >>>>> + > >>>>> + ret = __vmap_pages_range_noflush(addr, end, prot, pages, page_shift); > >>>>> + /* > >>>>> + * The page tables undo themselves on failure. Tear down the > >>>>> + * metadata that was fully set up before the mapping failed. > >>>>> + */ > >>>>> + if (ret) > >>>>> + kmsan_vunmap_range_noflush(addr, end); > >>>>> + > >>>>> + return ret; > >>>>> } > >>>> [Severity: High] > >>>> Can calling __vunmap_range_noflush() and kmsan_vunmap_range_noflush() here > >>>> trigger a sleeping-in-atomic-context bug when __vmalloc() or kvmalloc() is > >>>> called with GFP_ATOMIC or GFP_NOWAIT? > >>>> > >>>> __vmalloc_area_node() supports non-blocking allocations by wrapping > >>>> __vmap_pages_range() in memalloc_apply_gfp_scope(gfp_mask): > >>>> > >>>> mm/vmalloc.c:__vmalloc_area_node() { > >>>> ... > >>>> flags = memalloc_apply_gfp_scope(gfp_mask); > >>>> do { > >>>> ret = __vmap_pages_range(addr, addr + size, prot, area->pages, > >>>> page_shift, nested_gfp); > >>>> } while ((gfp_mask & __GFP_NOFAIL) && (ret < 0)); > >>>> memalloc_restore_gfp_scope(flags); > >>>> } > >>>> > >>>> When a GFP_ATOMIC or GFP_NOWAIT allocation runs in atomic context (such as > >>>> under a spinlock, preempt_disable(), or rcu_read_lock()) and page table > >>>> allocation fails in vmap_small_pages_range_noflush() after at least one PMD > >>>> in [start, end) is populated (or after kmsan_vmap_pages_range_noflush() > >>>> populated the KMSAN shadow/origin ranges), __vmap_pages_range_noflush() and > >>>> kmsan_vunmap_range_noflush() synchronously call __vunmap_range_noflush(). > >>>> > >>>> __vunmap_range_noflush() walks the populated PMDs via vunmap_pmd_range(), > >>>> which unconditionally calls cond_resched(): > >>>> > >>>> mm/vmalloc.c:vunmap_pmd_range() { > >>>> ... > >>>> do { > >>>> next = pmd_addr_end(addr, end); > >>>> if (pmd_none_or_clear_bad(pmd)) > >>>> continue; > >>>> vunmap_pte_range(pmd, addr, next, mask); > >>>> > >>>> cond_resched(); > >>>> } while (pmd++, addr = next, addr != end); > >>>> } > >>>> > >>>> Commit 9c47753167a6 ("mm/vmalloc: defer freeing partly initialized > >>>> vm_struct") deferred error-path cleanup in __vmalloc_area_node() to a > >>>> workqueue specifically because unmapping on failure can sleep. Doesn't > >>>> calling __vunmap_range_noflush() synchronously inside > >>>> __vmap_pages_range_noflush() and vmap_pages_range_noflush() reintroduce > >>>> cond_resched() in atomic context? > >>>> > >>> This issue also appears real. One possible approach is to plumb the caller's gfp_mask into vunmap_pmd_range() > >>> to conditionally skip cond_resched(). > >>> Suren, Ulad, do you have any preferred or cleaner way to handle this? > >> > >> > >> Alternatively, we can follow the approach from commit 9c47753167a6 > >> ("mm/vmalloc: defer freeing partly initialized vm_struct"): > >> > >> defer the cleanup to a workqueue when |gfp_mask| has GFP_ATOMIC or > >> GFP_NOWAIT,and perform cleanup synchronously > >> > >> if we are already in process context. Anyway, I will look into this further > >> tomorrow. > >> > > I will check the AI concern. > > > > Thank you very much for the quick reply and for offering to check > the AI concern. Much appreciated! > > Here is a summary of what I have found over the last few days. > I went through the history first. The cond_resched() in vunmap_pmd_range() > was added by commit e47110e90584 ("mm/vunmap: add cond_resched() in vunmap_pmd_range"), > modeled after zap_pte_range(). It fixed a real soft lockup: on a non-preemptible > kernel, unmapping a large persistent-memory namespace (hence a large I/O map region) > kept a CPU busy for 23 seconds inside the walk: > > watchdog: BUG: soft lockup - CPU#49 stuck for 23s! [ndctl:50777] > > Then I looked at how vfree() handles atomic contexts: it defers the > whole free to a workqueue from interrupt context (vfree_atomic()), > and 9c47753167a6 does the same for a partly initialized vm_struct. > > Unfortunately I do not think deferral works for this rollback case. > A deferred rollback returns with the PTEs still installed, and if > that range is mapped again before the workqueue runs, the mapping > hits the leftovers: a warning and -EBUSY on the small-page path, a > BUG() on the huge path. > > So I kept it simple: plumb the caller's gfp_mask down to the unmap > walk and call cond_resched() conditionally, like > commit 660654f90e7f ("mm/vmalloc.c: add a schedule point to vmalloc()") > did: > if (gfp_mask & __GFP_WAIT) > cond_resched(); > Sounds good to me. But we have the helper: gfpflags_allow_blocking(gfp_mask)) Another option is probably we can remove cond_resched(); from unmap path? -- Uladzsislau Rezki