mm-balloon_compaction-remove-dependency-on-page-lock.patch removed from -mm tree
The quilt patch titled
Subject: mm/balloon_compaction: remove dependency on page lock
has been removed from the -mm tree. Its filename was
mm-balloon_compaction-remove-dependency-on-page-lock.patch
This patch was dropped because it was merged into the mm-stable branch of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm
------------------------------------------------------
From: "David Hildenbrand (Red Hat)" <[email protected]>
Subject: mm/balloon_compaction: remove dependency on page lock
Date: Tue, 20 Jan 2026 00:01:17 +0100
Let's stop using the page lock in balloon code and instead use only the balloon_device_lock.
As soon as we set the PG_movable_ops flag, we might now get isolation callbacks for that page as we are no longer holding the page lock. In there, we'll simply synchronize using the balloon_device_lock.
So in balloon_page_isolate() lookup the balloon_dev_info through page->private under balloon_device_lock.
It's crucial that we update page->private under the balloon_device_lock, so the isolation callback can properly deal with concurrent deflation.
Consequently, make sure that balloon_page_finalize() is called under balloon_device_lock as we remove a page from the list and clear page->private. balloon_page_insert() is already called with the balloon_device_lock held.
Note that the core will still lock the pages, for example in isolate_movable_ops_page(). The lock is there still relevant for handling the PageMovableOpsIsolated flag, but that can be later changed to use an atomic test-and-set instead, or moved into the movable_ops backends.
---
include/linux/balloon_compaction.h | 25 +++++++++-------- mm/balloon_compaction.c | 38 ++++++++------------------- 2 files changed, 25 insertions(+), 38 deletions(-)
include/linux/balloon_compaction.h renamed from include/linux/balloon_compaction.h~mm-balloon_compaction-remove-dependency-on-page-lock +13 -12
@@ -12,25 +12,27 @@* is derived from the page type (PageOffline()) combined with the * PG_movable_ops flag (PageMovableOps()). * +* Once the page type and the PG_movable_ops are set, migration code +* can initiate page isolation by invoking the +* movable_operations()->isolate_page() callback +* +* As long as page->private is set, the page is either on the balloon list +* or isolated for migration. If page->private is not set, the page is +* either still getting inflated, or was deflated to be freed by the balloon +* driver soon. Isolation is impossible in both cases. +* * As the page isolation scanning step a compaction thread does is a lockless * procedure (from a page standpoint), it might bring some racy situations while * performing balloon page compaction. In order to sort out these racy scenarios * and safely perform balloon's page compaction and migration we must, always, * ensure following these simple rules: * -* i. Setting the PG_movable_ops flag and page->private with the following -* lock order -* +-page_lock(page); -* +--spin_lock_irq(&balloon_pages_lock); +* i. Inflation/deflation must set/clear page->private under the +* balloon_pages_lock * * ii. isolation or dequeueing procedure must remove the page from balloon * device page list under balloon_pages_lock * -* The functions provided by this interface are placed to help on coping with -* the aforementioned balloon page corner case, as well as to ensure the simple -* set of exposed rules are satisfied while we are dealing with balloon pages -* compaction / migration. -* * Copyright (C) 2012, Red Hat, Inc. Rafael Aquini <[email protected]> */ #ifndef _LINUX_BALLOON_COMPACTION_H
@@ -93,8 +95,7 @@ static inline struct balloon_dev_info *b* @balloon : pointer to balloon device * @page : page to be assigned as a 'balloon page' * -* Caller must ensure the page is locked and the spin_lock protecting balloon -* pages list is held before inserting a page into the balloon device. +* Caller must ensure the balloon_pages_lock is held. */ static inline void balloon_page_insert (struct balloon_dev_info *balloon,struct page *page)
@@ -119,7 +120,7 @@ static inline gfp_t balloon_mapping_gfp_* balloon list for release to the page allocator * @page: page to be released to the page allocator * -* Caller must ensure that the page is locked. +* Caller must ensure the balloon_pages_lock is held. */ static inline void balloon_page_finalize (struct page *page) {
mm/balloon_compaction.c renamed from mm/balloon_compaction.c~mm-balloon_compaction-remove-dependency-on-page-lock +12 -26
@@ -20,15 +20,7 @@ static DEFINE_SPINLOCK(balloon_pages_locstatic void balloon_page_enqueue_one (struct balloon_dev_info *b_dev_info,struct page *page) { -/* -* Block others from accessing the 'page' when we get around to -* establishing additional references. We should be the only one -* holding a reference to the 'page' at this point. If we are not, then -* memory corruption is possible and we should stop execution. -*/ -BUG_ON (!trylock_page (page));balloon_page_insert (b_dev_info, page); -unlock_page (page);if (b_dev_info->adjust_managed_page_count)adjust_managed_page_count (page,-1 );__count_vm_event (BALLOON_INFLATE );
@@ -93,22 +85,12 @@ size_t balloon_page_list_dequeue(structlist_for_each_entry_safe (page, tmp, &b_dev_info->pages, lru) {if (n_pages == n_req_pages)break ; - -/* -* Block others from accessing the 'page' while we get around to -* establishing additional references and preparing the 'page' -* to be released by the balloon driver. -*/ -if (!trylock_page (page)) -continue ; -list_del (&page->lru);if (b_dev_info->adjust_managed_page_count)adjust_managed_page_count (page,1 );balloon_page_finalize (page);__count_vm_event (BALLOON_DEFLATE );list_add (&page->lru, pages); -unlock_page (page);dec_node_page_state (page,NR_BALLOON_PAGES ); n_pages++; }
@@ -213,13 +195,19 @@ EXPORT_SYMBOL_GPL(balloon_page_dequeue);static bool balloon_page_isolate (struct page *page,isolate_mode_t mode) { -struct balloon_dev_info *b_dev_info =balloon_page_device (page); +struct balloon_dev_info *b_dev_info;unsigned long flags; -if (!b_dev_info) -return false; -spin_lock_irqsave (&balloon_pages_lock, flags); + b_dev_info =balloon_page_device (page); +if (!b_dev_info) { +/* +* The page already got deflated and removed from the +* balloon list. +*/ +spin_unlock_irqrestore (&balloon_pages_lock, flags); +return false; + }list_del (&page->lru); b_dev_info->isolated_pages++;spin_unlock_irqrestore (&balloon_pages_lock, flags);
@@ -253,9 +241,6 @@ static int balloon_page_migrate(struct punsigned long flags;int rc; -VM_BUG_ON_PAGE (!PageLocked (page), page); -VM_BUG_ON_PAGE (!PageLocked (newpage), newpage); -/* * When we isolated the page, the page was still inflated in a balloon * device. As isolated balloon pages cannot get deflated, we still have
@@ -293,10 +278,11 @@ static int balloon_page_migrate(struct p } b_dev_info->isolated_pages--; -spin_unlock_irqrestore (&balloon_pages_lock, flags);/* Free the now-deflated page we isolated in balloon_page_isolate(). */ balloon_page_finalize (page); +spin_unlock_irqrestore (&balloon_pages_lock, flags); +put_page (page);return 0 ;
_
Patches currently in -mm which might be from [email protected] are
mm-move-pte-table-reclaim-code-to-memoryc.patch mm-memory-handle-non-split-locks-correctly-in-zap_empty_pte_table.patch