3 files changed, 21 insertions, 14 deletions

diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index 47566bb0b4b1..9f1c853f67b5 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -1479,22 +1479,20 @@ static int free_pool_huge_page(struct hstate *h, nodemask_t *nodes_allowed,
 /*
  * Dissolve a given free hugepage into free buddy pages. This function does
  * nothing for in-use (including surplus) hugepages. Returns -EBUSY if the
- * number of free hugepages would be reduced below the number of reserved
- * hugepages.
+ * dissolution fails because a give page is not a free hugepage, or because
+ * free hugepages are fully reserved.
  */
 int dissolve_free_huge_page(struct page *page)
 {
-        int rc = 0;
+        int rc = -EBUSY;
 
         spin_lock(&hugetlb_lock);
         if (PageHuge(page) && !page_count(page)) {
                 struct page *head = compound_head(page);
                 struct hstate *h = page_hstate(head);
                 int nid = page_to_nid(head);
-                if (h->free_huge_pages - h->resv_huge_pages == 0) {
-                        rc = -EBUSY;
+                if (h->free_huge_pages - h->resv_huge_pages == 0)
                         goto out;
-                }
                 /*
                  * Move PageHWPoison flag from head page to the raw error page,
                  * which makes any subpages rather than the error page reusable.
@@ -1508,6 +1506,7 @@ int dissolve_free_huge_page(struct page *page)
                 h->free_huge_pages_node[nid]--;
                 h->max_huge_pages--;
                 update_and_free_page(h, head);
+                rc = 0;
         }
 out:
         spin_unlock(&hugetlb_lock);
diff --git a/mm/memory-failure.c b/mm/memory-failure.c
index c83a1746812f..49dc32c61137 100644
--- a/mm/memory-failure.c
+++ b/mm/memory-failure.c
@@ -1598,8 +1598,18 @@ static int soft_offline_huge_page(struct page *page, int flags)
                 if (ret > 0)
                         ret = -EIO;
         } else {
-                if (PageHuge(page))
-                        dissolve_free_huge_page(page);
+                /*
+                 * We set PG_hwpoison only when the migration source hugepage
+                 * was successfully dissolved, because otherwise hwpoisoned
+                 * hugepage remains on free hugepage list, then userspace will
+                 * find it as SIGBUS by allocation failure. That's not expected
+                 * in soft-offlining.
+                 */
+                ret = dissolve_free_huge_page(page);
+                if (!ret) {
+                        if (set_hwpoison_free_buddy_page(page))
+                                num_poisoned_pages_inc();
+                }
         }
         return ret;
 }
@@ -1715,13 +1725,13 @@ static int soft_offline_in_use_page(struct page *page, int flags)
 
 static void soft_offline_free_page(struct page *page)
 {
+        int rc = 0;
         struct page *head = compound_head(page);
 
-        if (!TestSetPageHWPoison(head)) {
+        if (PageHuge(head))
+                rc = dissolve_free_huge_page(page);
+        if (!rc && !TestSetPageHWPoison(page))
                 num_poisoned_pages_inc();
-                if (PageHuge(head))
-                        dissolve_free_huge_page(page);
-        }
 }
 
 /**
diff --git a/mm/migrate.c b/mm/migrate.c
index c27e97b5b69d..91a99457127c 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -1331,8 +1331,6 @@ put_anon:
 out:
         if (rc != -EAGAIN)
                 putback_active_hugepage(hpage);
-        if (reason == MR_MEMORY_FAILURE && !test_set_page_hwpoison(hpage))
-                num_poisoned_pages_inc();
 
         /*
          * If migration was not successful and there's a freeing callback, use