mm/balloon_compaction: use a device-independent balloon (list) lock

In order to remove the dependency on the page lock for balloon pages, we
need a lock that is independent of the page.

It's crucial that we can handle the scenario where balloon deflation
(clearing page->private) can race with page isolation (using page->private
to obtain the balloon_dev_info where the lock currently resides).

The current lock in balloon_dev_info is therefore not suitable.

Fortunately, we never really have more than a single balloon device per
VM, so we can just keep it simple and use a static lock to protect all
balloon devices.

Based on this change we will remove the dependency on the page lock next.

Link: https://lkml.kernel.org/r/20260119230133.3551867-9-david@kernel.org
Signed-off-by: David Hildenbrand (Red Hat) <david@kernel.org>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Christophe Leroy <christophe.leroy@csgroup.eu>
Cc: Eugenio Pérez <eperezma@redhat.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Jason Wang <jasowang@redhat.com>
Cc: Jerrin Shaji George <jerrin.shaji-george@broadcom.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Liam Howlett <liam.howlett@oracle.com>
Cc: Lorenzo Stoakes <lorenzo.stoakes@oracle.com>
Cc: Madhavan Srinivasan <maddy@linux.ibm.com>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Mike Rapoport <rppt@kernel.org>
Cc: Nicholas Piggin <npiggin@gmail.com>
Cc: Oscar Salvador <osalvador@suse.de>
Cc: SeongJae Park <sj@kernel.org>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Cc: Zi Yan <ziy@nvidia.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/include/linux/balloon_compaction.h b/include/linux/balloon_compaction.h
index 3109d3c43d3065bebe6fdee28cb3a35bc2594b99..9a8568fcd477d38a1a0afa23d89dbed994cc55f0 100644 (file)
--- a/include/linux/balloon_compaction.h
+++ b/include/linux/balloon_compaction.h
@@ -21,10 +21,10 @@
  *   i. Setting the PG_movable_ops flag and page->private with the following
  *     lock order
  *         +-page_lock(page);
- *           +--spin_lock_irq(&b_dev_info->pages_lock);
+ *           +--spin_lock_irq(&balloon_pages_lock);
  *
  *  ii. isolation or dequeueing procedure must remove the page from balloon
- *      device page list under b_dev_info->pages_lock.
+ *      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
@@ -52,7 +52,6 @@
  */
 struct balloon_dev_info {
        unsigned long isolated_pages;   /* # of isolated pages for migration */
-       spinlock_t pages_lock;          /* Protection to pages list */
        struct list_head pages;         /* Pages enqueued & handled to Host */
        int (*migratepage)(struct balloon_dev_info *, struct page *newpage,
                        struct page *page, enum migrate_mode mode);
@@ -71,7 +70,6 @@ extern size_t balloon_page_list_dequeue(struct balloon_dev_info *b_dev_info,
 static inline void balloon_devinfo_init(struct balloon_dev_info *balloon)
 {
        balloon->isolated_pages = 0;
-       spin_lock_init(&balloon->pages_lock);
        INIT_LIST_HEAD(&balloon->pages);
        balloon->migratepage = NULL;
        balloon->adjust_managed_page_count = false;

diff --git a/mm/balloon_compaction.c b/mm/balloon_compaction.c
index 4fe2a0cff69ec3b65525dfa12f51a1f76ce556a9..a0fd779bbd0120a26aaa51859904125a2ed32ec0 100644 (file)
--- a/mm/balloon_compaction.c
+++ b/mm/balloon_compaction.c
@@ -11,6 +11,12 @@
 #include <linux/export.h>
 #include <linux/balloon_compaction.h>
 
+/*
+ * Lock protecting the balloon_dev_info of all devices. We don't really
+ * expect more than one device.
+ */
+static DEFINE_SPINLOCK(balloon_pages_lock);
+
 static void balloon_page_enqueue_one(struct balloon_dev_info *b_dev_info,
                                     struct page *page)
 {
@@ -47,13 +53,13 @@ size_t balloon_page_list_enqueue(struct balloon_dev_info *b_dev_info,
        unsigned long flags;
        size_t n_pages = 0;
 
-       spin_lock_irqsave(&b_dev_info->pages_lock, flags);
+       spin_lock_irqsave(&balloon_pages_lock, flags);
        list_for_each_entry_safe(page, tmp, pages, lru) {
                list_del(&page->lru);
                balloon_page_enqueue_one(b_dev_info, page);
                n_pages++;
        }
-       spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
+       spin_unlock_irqrestore(&balloon_pages_lock, flags);
        return n_pages;
 }
 EXPORT_SYMBOL_GPL(balloon_page_list_enqueue);
@@ -83,7 +89,7 @@ size_t balloon_page_list_dequeue(struct balloon_dev_info *b_dev_info,
        unsigned long flags;
        size_t n_pages = 0;
 
-       spin_lock_irqsave(&b_dev_info->pages_lock, flags);
+       spin_lock_irqsave(&balloon_pages_lock, flags);
        list_for_each_entry_safe(page, tmp, &b_dev_info->pages, lru) {
                if (n_pages == n_req_pages)
                        break;
@@ -106,7 +112,7 @@ size_t balloon_page_list_dequeue(struct balloon_dev_info *b_dev_info,
                dec_node_page_state(page, NR_BALLOON_PAGES);
                n_pages++;
        }
-       spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
+       spin_unlock_irqrestore(&balloon_pages_lock, flags);
 
        return n_pages;
 }
@@ -149,9 +155,9 @@ void balloon_page_enqueue(struct balloon_dev_info *b_dev_info,
 {
        unsigned long flags;
 
-       spin_lock_irqsave(&b_dev_info->pages_lock, flags);
+       spin_lock_irqsave(&balloon_pages_lock, flags);
        balloon_page_enqueue_one(b_dev_info, page);
-       spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
+       spin_unlock_irqrestore(&balloon_pages_lock, flags);
 }
 EXPORT_SYMBOL_GPL(balloon_page_enqueue);
 
@@ -191,11 +197,11 @@ struct page *balloon_page_dequeue(struct balloon_dev_info *b_dev_info)
                 * BUG() here, otherwise the balloon driver may get stuck in
                 * an infinite loop while attempting to release all its pages.
                 */
-               spin_lock_irqsave(&b_dev_info->pages_lock, flags);
+               spin_lock_irqsave(&balloon_pages_lock, flags);
                if (unlikely(list_empty(&b_dev_info->pages) &&
                             !b_dev_info->isolated_pages))
                        BUG();
-               spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
+               spin_unlock_irqrestore(&balloon_pages_lock, flags);
                return NULL;
        }
        return list_first_entry(&pages, struct page, lru);
@@ -213,10 +219,10 @@ static bool balloon_page_isolate(struct page *page, isolate_mode_t mode)
        if (!b_dev_info)
                return false;
 
-       spin_lock_irqsave(&b_dev_info->pages_lock, flags);
+       spin_lock_irqsave(&balloon_pages_lock, flags);
        list_del(&page->lru);
        b_dev_info->isolated_pages++;
-       spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
+       spin_unlock_irqrestore(&balloon_pages_lock, flags);
 
        return true;
 }
@@ -234,10 +240,10 @@ static void balloon_page_putback(struct page *page)
        if (WARN_ON_ONCE(!b_dev_info))
                return;
 
-       spin_lock_irqsave(&b_dev_info->pages_lock, flags);
+       spin_lock_irqsave(&balloon_pages_lock, flags);
        list_add(&page->lru, &b_dev_info->pages);
        b_dev_info->isolated_pages--;
-       spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
+       spin_unlock_irqrestore(&balloon_pages_lock, flags);
 }
 
 static int balloon_page_migrate(struct page *newpage, struct page *page,
@@ -262,7 +268,7 @@ static int balloon_page_migrate(struct page *newpage, struct page *page,
        if (rc < 0 && rc != -ENOENT)
                return rc;
 
-       spin_lock_irqsave(&b_dev_info->pages_lock, flags);
+       spin_lock_irqsave(&balloon_pages_lock, flags);
        if (!rc) {
                /* Insert the new page into the balloon list. */
                get_page(newpage);
@@ -287,7 +293,7 @@ static int balloon_page_migrate(struct page *newpage, struct page *page,
        }
 
        b_dev_info->isolated_pages--;
-       spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
+       spin_unlock_irqrestore(&balloon_pages_lock, flags);
 
        /* Free the now-deflated page we isolated in balloon_page_isolate(). */
        balloon_page_finalize(page);