diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index 74c25228aec4e63f22a44659061ecc4980695567..ad50e4ebef68718cbaca007f4a0902ad41de703f 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -1564,6 +1564,13 @@
 			hugepages using the cma allocator. If enabled, the
 			boot-time allocation of gigantic hugepages is skipped.
 
+	hugepage_prohibit_sz=
+			[HW] HugeTLB pages should not alloc when the rest of
+			the normal pages less than hugepage_prohibit_sz. This
+			setting is to make sure a system can start even when
+			part of physical memory is broken, admin users can
+			adjust this according to typical environment.
+
 	hugepages=	[HW] Number of HugeTLB pages to allocate at boot.
 			If this follows hugepagesz (below), it specifies
 			the number of pages of hugepagesz to be allocated.
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index 34f3dfba5e82b3e052a3c2fcb7d8b9870f51efce..a8c815386ecc59a9a962acfaa9b0547bf4cb98b3 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -1784,6 +1784,33 @@ pgoff_t hugetlb_basepage_index(struct page *page)
 	return (index << compound_order(page_head)) + compound_idx;
 }
 
+#define HUGE_PAGE_BOOTMEM_ALLOC		0
+#define HUGE_PAGE_FRESH_ALLOC		1
+
+static u64 normal_page_reserve_sz;
+
+static int __init early_normal_page_reserve(char *p)
+{
+	unsigned long long size;
+
+	if (!p)
+		return 1;
+
+	size = memparse(p, &p);
+	if (*p) {
+		pr_warn("HugeTLB: Invalid normal page reserved size\n");
+		return 1;
+	}
+
+	normal_page_reserve_sz = size & PAGE_MASK;
+
+	pr_info("HugeTLB: Normal page reserved %lldMB\n",
+		normal_page_reserve_sz >> 20);
+
+	return 0;
+}
+early_param("hugepage_prohibit_sz", early_normal_page_reserve);
+
 static struct page *alloc_buddy_huge_page(struct hstate *h,
 		gfp_t gfp_mask, int nid, nodemask_t *nmask,
 		nodemask_t *node_alloc_noretry)
@@ -1831,6 +1858,45 @@ static struct page *alloc_buddy_huge_page(struct hstate *h,
 	return page;
 }
 
+static bool __ref huge_page_limit_check(int type, size_t hsize, int nid)
+{
+	u64 mem_usable = 0;
+	char *str = NULL;
+	char buf[32];
+
+	if (!normal_page_reserve_sz)
+		return true;
+
+	if (system_state > SYSTEM_SCHEDULING)
+		return true;
+
+	if (normal_page_reserve_sz >= memblock_phys_mem_size()) {
+		mem_usable = memblock_phys_mem_size();
+		str = "physical memory";
+		goto out;
+	}
+
+	if (type == HUGE_PAGE_BOOTMEM_ALLOC) {
+		mem_usable = memblock_phys_mem_size() - memblock_reserved_size();
+		str = "memblock usable";
+	} else if (type == HUGE_PAGE_FRESH_ALLOC) {
+		mem_usable = nr_free_pages() << PAGE_SHIFT;
+		str = "free page";
+	}
+
+	if (mem_usable < normal_page_reserve_sz + hsize)
+		goto out;
+
+	return true;
+out:
+	string_get_size(hsize, 1, STRING_UNITS_2, buf, 32);
+	pr_info("HugeTLB: allocating(%s) + Normal pages reserved(%lldMB) node%d exceed %s size(%lldMB)\n",
+		buf, normal_page_reserve_sz >> 20,
+		nid, str, mem_usable >> 20);
+
+	return false;
+}
+
 /*
  * Common helper to allocate a fresh hugetlb page. All specific allocators
  * should use this function to get new hugetlb pages
@@ -1843,6 +1909,9 @@ static struct page *alloc_fresh_huge_page(struct hstate *h,
 	bool retry = false;
 
 retry:
+	if (!huge_page_limit_check(HUGE_PAGE_FRESH_ALLOC, huge_page_size(h), nid))
+		return NULL;
+
 	if (hstate_is_gigantic(h))
 		page = alloc_gigantic_page(h, gfp_mask, nid, nmask);
 	else
@@ -2637,6 +2706,10 @@ int __alloc_bootmem_huge_page(struct hstate *h, int nid)
 
 	if (nid != NUMA_NO_NODE && nid >= nr_online_nodes)
 		return 0;
+
+	if (!huge_page_limit_check(HUGE_PAGE_BOOTMEM_ALLOC, huge_page_size(h), nid))
+		return 0;
+
 	/* do node specific alloc */
 	if (nid != NUMA_NO_NODE) {
 		m = memblock_alloc_try_nid_raw(huge_page_size(h), huge_page_size(h),