diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 665f06675c834e45f9624b1a990d658f91eb99f3..7050f139cf24f91dab7f399d018589d64d9548e9 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -15,6 +15,8 @@ struct vm_area_struct;
 
 static inline int gfp_migratetype(const gfp_t gfp_flags)
 {
+    unsigned int ret_mt = 0;
+
 	VM_WARN_ON((gfp_flags & GFP_MOVABLE_MASK) == GFP_MOVABLE_MASK);
 	BUILD_BUG_ON((1UL << GFP_MOVABLE_SHIFT) != ___GFP_MOVABLE);
 	BUILD_BUG_ON((___GFP_MOVABLE >> GFP_MOVABLE_SHIFT) != MIGRATE_MOVABLE);
@@ -26,7 +28,14 @@ static inline int gfp_migratetype(const gfp_t gfp_flags)
 		return MIGRATE_UNMOVABLE;
 
 	/* Group based on mobility */
-	return (__force unsigned long)(gfp_flags & GFP_MOVABLE_MASK) >> GFP_MOVABLE_SHIFT;
+    ret_mt = (gfp_flags & GFP_MOVABLE_MASK) >> GFP_MOVABLE_SHIFT;
+
+#ifdef CONFIG_CMA_REUSE
+	if (ret_mt == MIGRATE_MOVABLE && (gfp_flags & __GFP_CMA))
+        return MIGRATE_CMA;
+#endif
+
+	return ret_mt;
 }
 #undef GFP_MOVABLE_MASK
 #undef GFP_MOVABLE_SHIFT
diff --git a/include/linux/gfp_types.h b/include/linux/gfp_types.h
index 6583a58670c571050ad410e0dcf0718b6477292b..4bc68a46b97bf477ea38b7a458b70463a648e666 100644
--- a/include/linux/gfp_types.h
+++ b/include/linux/gfp_types.h
@@ -53,8 +53,9 @@ typedef unsigned int __bitwise gfp_t;
 #define ___GFP_SKIP_ZERO	0
 #define ___GFP_SKIP_KASAN	0
 #endif
+#define ___GFP_CMA		0x4000000u
 #ifdef CONFIG_LOCKDEP
-#define ___GFP_NOLOCKDEP	0x4000000u
+#define ___GFP_NOLOCKDEP	0x8000000u
 #else
 #define ___GFP_NOLOCKDEP	0
 #endif
@@ -71,6 +72,7 @@ typedef unsigned int __bitwise gfp_t;
 #define __GFP_HIGHMEM	((__force gfp_t)___GFP_HIGHMEM)
 #define __GFP_DMA32	((__force gfp_t)___GFP_DMA32)
 #define __GFP_MOVABLE	((__force gfp_t)___GFP_MOVABLE)  /* ZONE_MOVABLE allowed */
+#define __GFP_CMA	((__force gfp_t)___GFP_CMA)
 #define GFP_ZONEMASK	(__GFP_DMA|__GFP_HIGHMEM|__GFP_DMA32|__GFP_MOVABLE)
 
 /**
@@ -249,7 +251,7 @@ typedef unsigned int __bitwise gfp_t;
 #define __GFP_NOLOCKDEP ((__force gfp_t)___GFP_NOLOCKDEP)
 
 /* Room for N __GFP_FOO bits */
-#define __GFP_BITS_SHIFT (26 + IS_ENABLED(CONFIG_LOCKDEP))
+#define __GFP_BITS_SHIFT (27 + IS_ENABLED(CONFIG_LOCKDEP))
 #define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1))
 
 /**
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index 75607d4ba26cb7b75802522445aba6cbb8d2b681..ccef475c0d444a481dd321d91e05bc87700c5d1d 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -226,7 +226,7 @@ struct folio *vma_alloc_zeroed_movable_folio(struct vm_area_struct *vma,
 {
 	struct folio *folio;
 
-	folio = vma_alloc_folio(GFP_HIGHUSER_MOVABLE, 0, vma, vaddr, false);
+	folio = vma_alloc_folio(GFP_HIGHUSER_MOVABLE | __GFP_CMA, 0, vma, vaddr, false);
 	if (folio)
 		clear_user_highpage(&folio->page, vaddr);
 
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 0f62786269d0c1e789d4266ecf6d7d866fd546db..890b01ea6fea302ace0120946cd8afd19c9c974a 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -47,8 +47,11 @@ enum migratetype {
 	MIGRATE_MOVABLE,
 	MIGRATE_RECLAIMABLE,
 	MIGRATE_PCPTYPES,	/* the number of types on the pcp lists */
+#ifdef CONFIG_CMA_REUSE
+    MIGRATE_CMA,
+#endif
 	MIGRATE_HIGHATOMIC = MIGRATE_PCPTYPES,
-#ifdef CONFIG_CMA
+#if defined(CONFIG_CMA) && !defined(CONFIG_CMA_REUSE)
 	/*
 	 * MIGRATE_CMA migration type is designed to mimic the way
 	 * ZONE_MOVABLE works.  Only movable pages can be allocated
@@ -59,7 +62,7 @@ enum migratetype {
 	 * pageblocks to MIGRATE_CMA which can be done by
 	 * __free_pageblock_cma() function.
 	 */
-	MIGRATE_CMA,
+    MIGRATE_CMA,
 #endif
 #ifdef CONFIG_MEMORY_ISOLATION
 	MIGRATE_ISOLATE,	/* can't allocate from here */
@@ -78,6 +81,12 @@ extern const char * const migratetype_names[MIGRATE_TYPES];
 #  define is_migrate_cma_page(_page) false
 #endif
 
+#ifdef CONFIG_CMA_REUSE
+#  define get_cma_migratetype() MIGRATE_CMA
+#else
+#  define get_cma_migratetype() MIGRATE_MOVABLE
+#endif
+
 static inline bool is_migrate_movable(int mt)
 {
 	return is_migrate_cma(mt) || mt == MIGRATE_MOVABLE;
diff --git a/mm/Kconfig b/mm/Kconfig
index 264a2df5ecf5b91a2883e4594bd7707219ca309c..414d96ee780cf843c695e6248f4b0ca57f81016f 100644
--- a/mm/Kconfig
+++ b/mm/Kconfig
@@ -941,6 +941,16 @@ config CMA_AREAS
 
 	  If unsure, leave the default value "7" in UMA and "19" in NUMA.
 
+config CMA_REUSE
+	bool "CMA reuse feature"
+	depends on CMA
+	help
+	  If enabled, it will add MIGRATE_CMA to pcp lists and movable
+	  allocations with __GFP_CMA flag will use cma areas prior to
+	  movable areas.
+
+	  It improves the utilization ratio of cma areas.
+
 config MEM_SOFT_DIRTY
 	bool "Track memory changes"
 	depends on CHECKPOINT_RESTORE && HAVE_ARCH_SOFT_DIRTY && PROC_FS
diff --git a/mm/compaction.c b/mm/compaction.c
index 38c8d216c6a3bffd9d75fd430981558c66614750..080aaf0f80a7bae9c5525a2aa3337d5127e2ec14 100644
--- a/mm/compaction.c
+++ b/mm/compaction.c
@@ -2235,7 +2235,7 @@ static enum compact_result __compact_finished(struct compact_control *cc)
 
 #ifdef CONFIG_CMA
 		/* MIGRATE_MOVABLE can fallback on MIGRATE_CMA */
-		if (migratetype == MIGRATE_MOVABLE &&
+		if (migratetype == get_cma_migratetype() &&
 			!free_area_empty(area, MIGRATE_CMA))
 			return COMPACT_SUCCESS;
 #endif
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index afed33fd876128ac3b53db3e8da303b353c4c991..d5f881f72308b3aeab701929b55ab06864a99666 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -275,8 +275,11 @@ const char * const migratetype_names[MIGRATE_TYPES] = {
 	"Unmovable",
 	"Movable",
 	"Reclaimable",
+#ifdef CONFIG_CMA_REUSE
+	"CMA",
+#endif
 	"HighAtomic",
-#ifdef CONFIG_CMA
+#if defined(CONFIG_CMA) && !defined(CONFIG_CMA_REUSE)
 	"CMA",
 #endif
 #ifdef CONFIG_MEMORY_ISOLATION
@@ -2078,6 +2081,27 @@ __rmqueue_fallback(struct zone *zone, int order, int start_migratetype,
 
 }
 
+static __always_inline struct page *
+__rmqueue_with_cma_reuse(struct zone *zone, unsigned int order,
+					int migratetype, unsigned int alloc_flags)
+{
+    struct page *page = NULL;
+retry:
+	page = __rmqueue_smallest(zone, order, migratetype);
+
+    if (unlikely(!page) && is_migrate_cma(migratetype)) {
+        migratetype = MIGRATE_MOVABLE;
+        alloc_flags &= ~ALLOC_CMA;
+        page = __rmqueue_smallest(zone, order, migratetype);
+    }
+
+    if (unlikely(!page) &&
+		__rmqueue_fallback(zone, order, migratetype, alloc_flags))
+        goto retry;
+
+    return page;
+}
+
 /*
  * Do the hard work of removing an element from the buddy allocator.
  * Call me with the zone->lock already held.
@@ -2088,6 +2112,11 @@ __rmqueue(struct zone *zone, unsigned int order, int migratetype,
 {
 	struct page *page;
 
+#ifdef CONFIG_CMA_REUSE
+    page = __rmqueue_with_cma_reuse(zone, order, migratetype, alloc_flags);
+    goto out;
+#endif
+
 	if (IS_ENABLED(CONFIG_CMA)) {
 		/*
 		 * Balance movable allocations between regular and CMA areas by
@@ -2112,6 +2141,9 @@ __rmqueue(struct zone *zone, unsigned int order, int migratetype,
 								alloc_flags))
 			goto retry;
 	}
+out:
+	if (page)
+        trace_mm_page_alloc_zone_locked(page, order, migratetype, migratetype == MIGRATE_MOVABLE);
 	return page;
 }
 
@@ -3034,7 +3066,8 @@ static inline unsigned int gfp_to_alloc_flags_cma(gfp_t gfp_mask,
 						  unsigned int alloc_flags)
 {
 #ifdef CONFIG_CMA
-	if (gfp_migratetype(gfp_mask) == MIGRATE_MOVABLE)
+	unsigned int pflags = current->flags;
+	if (!(pflags & PF_MEMALLOC_PIN) && gfp_migratetype(gfp_mask) == get_cma_migratetype())
 		alloc_flags |= ALLOC_CMA;
 #endif
 	return alloc_flags;