diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig
index 7b071a00425d..6e5e96b5738e 100644
--- a/arch/arm64/Kconfig
+++ b/arch/arm64/Kconfig
@@ -258,6 +258,175 @@ config ARM64
 	help
 	  ARM 64-bit (AArch64) Linux support.
 
+config OS_MINIDUMP
+	bool "Enable os minidump module"
+	default n
+	depends on !CRASH_CORE && !SLUB_DEBUG && !SLUB_TINY
+	help
+	  Trigger os minidump when panic. It only dump parts of os core
+	  datas/segments in raw binary format to reduce its size and
+	  speed up dump process. Reasemble a standard elf format file
+	  with dump file and vmlinux, and then parse it with crash tool.
+
+	  For more details see Documentation/admin-guide/osdump.rst
+
+	  If unsure, say N.
+
+config OS_MINIDUMP_DEFLATE_COMPRESS
+	tristate "DEFLATE (ZLIB) compression"
+	depends on OS_MINIDUMP
+	select CRYPTO_DEFLATE
+	help
+	  This option enables DEFLATE (also known as ZLIB) compression
+	  algorithm support for os minidump. Enabling this option will allow
+	  mini dumps to be compressed using DEFLATE, which may reduce the size of
+	  the dump files.
+
+	  If unsure, say N.
+
+config OS_MINIDUMP_LZO_COMPRESS
+	tristate "LZO compression"
+	default y
+	depends on OS_MINIDUMP
+	select CRYPTO_LZO
+	help
+	  This option enables LZO compression algorithm support for os minidump.
+	  Enabling this option will allow mini dumps to be compressed using LZO,
+	  which may reduce the size of the dump files.
+
+	  If unsure, say Y.
+
+config OS_MINIDUMP_LZ4_COMPRESS
+	tristate "LZ4 compression"
+	depends on OS_MINIDUMP
+	select CRYPTO_LZ4
+	help
+	  This option enables LZ4 compression algorithm support for os minidump.
+	  Enabling this option will allow mini dumps to be compressed using LZ4,
+	  which may reduce the size of the dump files.
+
+	  If unsure, say N.
+
+config OS_MINIDUMP_LZ4HC_COMPRESS
+	tristate "LZ4HC compression"
+	depends on OS_MINIDUMP
+	select CRYPTO_LZ4HC
+	help
+	  This option enables LZ4HC (high compression) mode algorithm.
+	  Enabling this option will allow mini dumps to be compressed using LZ4HC,
+	  which may reduce the size of the dump files.
+
+	  If unsure, say N.
+
+config OS_MINIDUMP_842_COMPRESS
+	bool "842 compression"
+	depends on OS_MINIDUMP
+	select CRYPTO_842
+	help
+	  This option enables 842 compression algorithm support for os minidump.
+	  Enabling this option will allow mini dumps to be compressed using 842,
+	  which may reduce the size of the dump files.
+
+	  If unsure, say N.
+
+config OS_MINIDUMP_ZSTD_COMPRESS
+	bool "zstd compression"
+	depends on OS_MINIDUMP
+	select CRYPTO_ZSTD
+	help
+	  This option enables zstd compression algorithm support for os minidump.
+	  Enabling this option will allow mini dumps to be compressed using ZSTD,
+	  which may reduce the size of the dump files.
+
+	  If unsure, say N.
+
+config OS_MINIDUMP_COMPRESS
+	def_bool y
+	depends on OS_MINIDUMP
+	depends on OS_MINIDUMP_DEFLATE_COMPRESS || OS_MINIDUMP_LZO_COMPRESS ||    \
+		   OS_MINIDUMP_LZ4_COMPRESS || OS_MINIDUMP_LZ4HC_COMPRESS ||      \
+		   OS_MINIDUMP_842_COMPRESS || OS_MINIDUMP_ZSTD_COMPRESS
+
+choice
+	prompt "Default osdump.compression algorithm"
+	depends on OS_MINIDUMP_COMPRESS
+	help
+	  This option chooses the default active compression algorithm.
+	  This can be changed at boot with "osdump.compress=..." on
+	  the kernel command line.
+
+	  Currently, osdump.has support for 6 compression algorithms:
+	  deflate, lzo, lz4, lz4hc, 842 and zstd.
+
+	  The default compression algorithm is lzo.
+
+	config OS_MINIDUMP_DEFLATE_COMPRESS_DEFAULT
+		bool "deflate" if OS_MINIDUMP_DEFLATE_COMPRESS
+		help
+		  This option chooses deflate as default compression algorithm,
+		  which reduce the size of the dump files greately.
+
+		  This can be changed at boot with "osdump.compress=..." on
+		  the kernel command line.
+
+	config OS_MINIDUMP_LZO_COMPRESS_DEFAULT
+		bool "lzo" if OS_MINIDUMP_LZO_COMPRESS
+		help
+		  This option chooses lzo as default compression algorithm,
+		  which reduce the size of the dump files greately.
+
+		  This can be changed at boot with "osdump.compress=..." on
+		  the kernel command line.
+
+	config OS_MINIDUMP_LZ4_COMPRESS_DEFAULT
+		bool "lz4" if OS_MINIDUMP_LZ4_COMPRESS
+		help
+		  This option chooses lz4 as default compression algorithm,
+		  which reduce the size of the dump files greately.
+
+		  This can be changed at boot with "osdump.compress=..." on
+		  the kernel command line.
+
+	config OS_MINIDUMP_LZ4HC_COMPRESS_DEFAULT
+		bool "lz4hc" if OS_MINIDUMP_LZ4HC_COMPRESS
+		help
+		  This option chooses lz4hc as default compression algorithm,
+		  which reduce the size of the dump files greately.
+
+		  This can be changed at boot with "osdump.compress=..." on
+		  the kernel command line.
+
+	config OS_MINIDUMP_842_COMPRESS_DEFAULT
+		bool "842" if OS_MINIDUMP_842_COMPRESS
+		help
+		  This option chooses 842 as default compression algorithm,
+		  which reduce the size of the dump files greately.
+
+		  This can be changed at boot with "osdump.compress=..." on
+		  the kernel command line.
+
+	config OS_MINIDUMP_ZSTD_COMPRESS_DEFAULT
+		bool "zstd" if OS_MINIDUMP_ZSTD_COMPRESS
+		help
+		  This option chooses zstd as default compression algorithm,
+		  which reduce the size of the dump files greately.
+
+		  This can be changed at boot with "osdump.compress=..." on
+		  the kernel command line.
+
+endchoice
+
+config OS_MINIDUMP_COMPRESS_DEFAULT
+	string
+	depends on OS_MINIDUMP_COMPRESS
+	default "deflate" if OS_MINIDUMP_DEFLATE_COMPRESS_DEFAULT
+	default "lzo" if OS_MINIDUMP_LZO_COMPRESS_DEFAULT
+	default "lz4" if OS_MINIDUMP_LZ4_COMPRESS_DEFAULT
+	default "lz4hc" if OS_MINIDUMP_LZ4HC_COMPRESS_DEFAULT
+	default "842" if OS_MINIDUMP_842_COMPRESS_DEFAULT
+	default "zstd" if OS_MINIDUMP_ZSTD_COMPRESS_DEFAULT
+
+
 config CLANG_SUPPORTS_DYNAMIC_FTRACE_WITH_ARGS
 	def_bool CC_IS_CLANG
 	# https://github.com/ClangBuiltLinux/linux/issues/1507
diff --git a/drivers/of/platform.c b/drivers/of/platform.c
index 126d265aa7d8..6622292633f7 100644
--- a/drivers/of/platform.c
+++ b/drivers/of/platform.c
@@ -538,6 +538,7 @@ static const struct of_device_id reserved_mem_matches[] = {
 	{ .compatible = "qcom,cmd-db" },
 	{ .compatible = "qcom,smem" },
 	{ .compatible = "ramoops" },
+	{ .compatible = "osdump" },
 	{ .compatible = "nvmem-rmem" },
 	{ .compatible = "google,open-dice" },
 	{}
diff --git a/include/linux/osdump.h b/include/linux/osdump.h
new file mode 100644
index 000000000000..600d0d4901eb
--- /dev/null
+++ b/include/linux/osdump.h
@@ -0,0 +1,7 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _LINUX_OS_MINIDUMP_H
+#define _LINUX_OS_MINIDUMP_H
+
+extern int osdump(void);
+
+#endif
diff --git a/kernel/Makefile b/kernel/Makefile
index 3947122d618b..dc2b4ba5c953 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -116,6 +116,7 @@ obj-$(CONFIG_HAVE_STATIC_CALL_INLINE) += static_call_inline.o
 obj-$(CONFIG_CFI_CLANG) += cfi.o
 
 obj-$(CONFIG_PERF_EVENTS) += events/
+obj-$(CONFIG_OS_MINIDUMP) += osdump/
 
 obj-$(CONFIG_USER_RETURN_NOTIFIER) += user-return-notifier.o
 obj-$(CONFIG_PADATA) += padata.o
diff --git a/kernel/osdump/Makefile b/kernel/osdump/Makefile
new file mode 100644
index 000000000000..3f9cd6282653
--- /dev/null
+++ b/kernel/osdump/Makefile
@@ -0,0 +1 @@
+obj-y += core.o inode.o compr.o
diff --git a/kernel/osdump/compr.c b/kernel/osdump/compr.c
new file mode 100644
index 000000000000..08aa6b72177c
--- /dev/null
+++ b/kernel/osdump/compr.c
@@ -0,0 +1,252 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * OS Minidump - compression driver interface parts.
+ *
+ */
+
+#if IS_ENABLED(CONFIG_OS_MINIDUMP_LZO_COMPRESS)
+#include <linux/types.h>
+#include <linux/lzo.h>
+#endif
+#if IS_ENABLED(CONFIG_OS_MINIDUMP_LZ4_COMPRESS) || IS_ENABLED(CONFIG_OS_MINIDUMP_LZ4HC_COMPRESS)
+#include <linux/lz4.h>
+#endif
+#if IS_ENABLED(CONFIG_OS_MINIDUMP_ZSTD_COMPRESS)
+#include <linux/zstd.h>
+#endif
+#include <linux/crypto.h>
+#include <linux/string.h>
+
+#include <linux/module.h>
+#include "internal.h"
+
+static char *compress = CONFIG_OS_MINIDUMP_COMPRESS_DEFAULT;
+
+module_param(compress, charp, 0444);
+MODULE_PARM_DESC(compress, "compression to use");
+
+/* Compression parameters */
+static struct crypto_comp *tfm;
+
+struct osdump_zbackend {
+	int (*zbufsize)(size_t size);
+	const char *name;
+};
+
+static void *big_oops_buf;
+size_t big_oops_buf_sz;
+EXPORT_SYMBOL_GPL(big_oops_buf_sz);
+
+#if IS_ENABLED(CONFIG_OS_MINIDUMP_DEFLATE_COMPRESS)
+static int zbufsize_deflate(size_t size)
+{
+	size_t cmpr;
+
+	switch (size) {
+	/* buffer range for efivars */
+	case 1000 ... 2000:
+		cmpr = 56;
+		break;
+	case 2001 ... 3000:
+		cmpr = 54;
+		break;
+	case 3001 ... 3999:
+		cmpr = 52;
+		break;
+		/* buffer range for nvram, erst */
+	case 4000 ... 10000:
+		cmpr = 45;
+		break;
+	default:
+		cmpr = 60;
+		break;
+	}
+
+	return (size * 100) / cmpr;
+}
+#endif
+
+#if IS_ENABLED(CONFIG_OS_MINIDUMP_LZO_COMPRESS)
+static int zbufsize_lzo(size_t size)
+{
+	return lzo1x_worst_compress(size);
+}
+#endif
+
+#if IS_ENABLED(CONFIG_OS_MINIDUMP_LZ4_COMPRESS) || IS_ENABLED(CONFIG_OS_MINIDUMP_LZ4HC_COMPRESS)
+static int zbufsize_lz4(size_t size)
+{
+	return LZ4_compressBound(size);
+}
+#endif
+
+#if IS_ENABLED(CONFIG_OS_MINIDUMP_842_COMPRESS)
+static int zbufsize_842(size_t size)
+{
+	return size;
+}
+#endif
+
+#if IS_ENABLED(CONFIG_OS_MINIDUMP_ZSTD_COMPRESS)
+static int zbufsize_zstd(size_t size)
+{
+	return ZSTD_compressBound(size);
+}
+#endif
+
+static const struct osdump_zbackend *zbackend __ro_after_init;
+
+static const struct osdump_zbackend zbackends[] = {
+#if IS_ENABLED(CONFIG_OS_MINIDUMP_DEFLATE_COMPRESS)
+	{
+		.zbufsize       = zbufsize_deflate,
+		.name           = "deflate",
+	},
+#endif
+#if IS_ENABLED(CONFIG_OS_MINIDUMP_LZO_COMPRESS)
+	{
+		.zbufsize       = zbufsize_lzo,
+		.name           = "lzo",
+	},
+#endif
+#if IS_ENABLED(CONFIG_OS_MINIDUMP_LZ4_COMPRESS)
+	{
+		.zbufsize       = zbufsize_lz4,
+		.name           = "lz4",
+	},
+#endif
+#if IS_ENABLED(CONFIG_OS_MINIDUMP_LZ4HC_COMPRESS)
+	{
+		.zbufsize       = zbufsize_lz4,
+		.name           = "lz4hc",
+	},
+#endif
+#if IS_ENABLED(CONFIG_OS_MINIDUMP_842_COMPRESS)
+	{
+		.zbufsize       = zbufsize_842,
+		.name           = "842",
+	},
+#endif
+#if IS_ENABLED(CONFIG_OS_MINIDUMP_ZSTD_COMPRESS)
+	{
+		.zbufsize       = zbufsize_zstd,
+		.name           = "zstd",
+	},
+#endif
+	{ }
+};
+
+int osdump_compress(const void *in, void *out, unsigned int size, int *left)
+{
+	int ret;
+	unsigned int outlen = size;
+
+	if (!IS_ENABLED(CONFIG_OS_MINIDUMP_COMPRESS))
+		return -EINVAL;
+
+	ret = crypto_comp_compress(tfm, in, size, big_oops_buf, &outlen);
+	if (ret) {
+		pr_err(DUMP_BANNER "crypto_comp_compress failed, ret = %d!\n", ret);
+		return ret;
+	}
+
+	if (outlen <= *left) {
+		memcpy(out, big_oops_buf, outlen);
+		*left -= outlen;
+	} else
+		*left = 0;
+
+	return outlen;
+}
+
+static void allocate_buf_for_compression(void)
+{
+	struct crypto_comp *ctx;
+	int size;
+	char *buf;
+
+	/* Skip if not built-in or compression backend not selected yet. */
+	if (!IS_ENABLED(CONFIG_OS_MINIDUMP_COMPRESS) || !zbackend)
+		return;
+
+	/* Skip if compression init already done. */
+	if (tfm)
+		return;
+
+	if (!crypto_has_comp(zbackend->name, 0, 0)) {
+		pr_err(DUMP_BANNER "Unknown compression: %s\n", zbackend->name);
+		return;
+	}
+
+	size = zbackend->zbufsize(CRYPTO_SIZE);
+	if (size <= 0) {
+		pr_err(DUMP_BANNER "Invalid compression size for %s: %d\n",
+				zbackend->name, size);
+		return;
+	}
+	size = round_down(size, PAGE_SIZE);
+
+	buf = kmalloc(size, GFP_KERNEL);
+	if (!buf)
+		return;
+
+	ctx = crypto_alloc_comp(zbackend->name, 0, 0);
+	if (IS_ERR_OR_NULL(ctx)) {
+		kfree(buf);
+		pr_err(DUMP_BANNER "crypto_alloc_comp('%s') failed: %ld\n", zbackend->name,
+				PTR_ERR(ctx));
+		return;
+	}
+
+	/* A non-NULL big_oops_buf indicates compression is available. */
+	tfm = ctx;
+	big_oops_buf_sz = size;
+	big_oops_buf = buf;
+
+	pr_info(DUMP_BANNER "Using os minidump compression: %s\n", zbackend->name);
+}
+
+static void free_buf_for_compression(void)
+{
+	if (IS_ENABLED(CONFIG_OS_MINIDUMP_COMPRESS) && tfm) {
+		crypto_free_comp(tfm);
+		tfm = NULL;
+	}
+	kfree(big_oops_buf);
+	big_oops_buf = NULL;
+	big_oops_buf_sz = 0;
+}
+
+static void __init osdump_choose_compression(void)
+{
+	const struct osdump_zbackend *step;
+
+	if (!compress)
+		return;
+
+	for (step = zbackends; step->name; step++) {
+		if (!strcmp(compress, step->name)) {
+			zbackend = step;
+			return;
+		}
+	}
+}
+
+static int __init compr_init(void)
+{
+	osdump_choose_compression();
+
+	allocate_buf_for_compression();
+
+	return 0;
+}
+late_initcall(compr_init);
+
+static void __exit compr_exit(void)
+{
+	free_buf_for_compression();
+}
+module_exit(compr_exit);
+
+MODULE_AUTHOR("qiruipeng");
+MODULE_LICENSE("GPL");
diff --git a/kernel/osdump/core.c b/kernel/osdump/core.c
new file mode 100644
index 000000000000..0da8c2ac3fc7
--- /dev/null
+++ b/kernel/osdump/core.c
@@ -0,0 +1,608 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * OS Minidump - core implement parts.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/seq_file.h>
+#include <linux/proc_fs.h>
+#include <linux/mm.h>
+#include <linux/platform_device.h>
+#include <linux/of_device.h>
+#include <linux/io.h>
+#include <linux/device.h>
+#include "internal.h"
+#include <linux/slab.h>
+#include "../../mm/slab.h"
+#include <linux/nmi.h>
+#include <linux/sched.h>
+#include <linux/byteorder/generic.h>
+#include <asm/kernel-pgtable.h>
+#include <linux/osdump.h>
+#include <linux/cpu.h>
+#include "extern.h"
+
+#define OS_DUMP		"osdump"
+
+struct osdump_variables osdump_var;
+EXPORT_SYMBOL_GPL(osdump_var);
+
+static inline u64 htonll(u64 val)
+{
+	return (((u64) htonl(val)) << 32) + htonl(val >> 32);
+}
+
+static inline u64 ntohll(u64 val)
+{
+	return (((u64) ntohl(val)) << 32) + ntohl(val >> 32);
+}
+
+static int common_store(void *src, phys_addr_t phys_addr, int src_size,
+			struct osdump_variables *osdump_var, int *sum)
+{
+	void *addr = osdump_var->mem_address;
+	int size, tmp, cnt = 0;
+
+	while (src_size > 0) {
+		size  = src_size > big_oops_buf_sz ? big_oops_buf_sz : src_size;
+		tmp = size;
+		size = osdump_compress(src, osdump_var->dst, size, &osdump_var->rem);
+
+		*sum += tmp;
+		(osdump_var->meta)->start = htonl(osdump_var->dst - addr);
+		(osdump_var->meta)->size = htonl(size);
+		(osdump_var->meta)->src = htonll(phys_addr);
+		(osdump_var->dst) += size;
+		(osdump_var->meta)++;
+		cnt++;
+		src += tmp;
+		phys_addr += tmp;
+		src_size -= tmp;
+
+		if (osdump_var->meta > osdump_var->meta_end)
+			osdump_var->rem = 0;
+	}
+
+	return cnt;
+}
+
+static int stack_dump(struct osdump_variables *osdump_var)
+{
+	int cnt = 0;
+	int sum = 0;
+
+	struct task_struct *tsk;
+	struct vm_struct *area;
+	int i;
+
+	tsk = current;
+	area = tsk->stack_vm_area;
+
+	for (i = 0; i < area->nr_pages; i++) {
+		cnt += common_store(area->addr + i * PAGE_SIZE, page_to_phys(area->pages[i]),
+					PAGE_SIZE, osdump_var, &sum);
+		if (osdump_var->rem <= 0)
+			break;
+	}
+
+
+	return cnt;
+}
+
+#if CONFIG_PGTABLE_LEVELS >= 2
+static int process_pmd(pmd_t *pmd, struct osdump_variables *osdump_var, int *sum)
+{
+	int i, cnt = 0;
+	struct page *page;
+
+	for (i = 0; i < PTRS_PER_PMD; i++) {
+
+		if (!pmd_none(*pmd)) {
+			page = pmd_page(*pmd);
+			if ((pmd_val(*pmd) & PMD_ATTRINDX_MASK) >> 2 == MT_NORMAL) {
+				if ((pmd_val(*pmd) & PMD_TYPE_MASK)  == PMD_TYPE_TABLE) {
+					cnt += common_store(page_to_virt(page), page_to_phys(page),
+								PAGE_SIZE, osdump_var, sum);
+
+				// save struct page here
+				} else if ((pmd_val(*pmd) & PMD_TYPE_MASK)  == PMD_TYPE_SECT
+						&& !(pmd_val(*pmd) & (PMD_SECT_RDONLY))) {
+					cnt += common_store(page_to_virt(page), page_to_phys(page),
+								PMD_SIZE, osdump_var, sum);
+
+				}
+				if (osdump_var->rem <= 0)
+					break;
+			}
+		}
+
+		pmd++;
+	}
+	return cnt;
+}
+#endif
+
+#if CONFIG_PGTABLE_LEVELS >= 3
+static int process_pud(pud_t *pud, struct osdump_variables *osdump_var, int *sum)
+{
+	int i, cnt = 0;
+	struct page *page;
+
+	for (i = 0; i < PTRS_PER_PUD; i++) {
+		if ((pud_val(*pud))) {
+			page = pud_page(*pud);
+
+			cnt += common_store(page_to_virt(page), page_to_phys(page),
+						PAGE_SIZE, osdump_var, sum);
+			if (osdump_var->rem <= 0)
+				break;
+
+			cnt += process_pmd(pud_pgtable(*pud), osdump_var, sum);
+			if (osdump_var->rem <= 0)
+				break;
+
+		}
+
+		pud++;
+	}
+
+	return cnt;
+}
+#endif
+
+#if CONFIG_PGTABLE_LEVELS >= 4
+static int process_p4d(p4d_t *p4d, struct osdump_variables *osdump_var, int *sum)
+{
+	int i, cnt = 0;
+	struct page *page;
+
+	for (i = 0; i < PTRS_PER_P4D; i++) {
+		if ((p4d_val(*p4d))) {
+			page = p4d_page(*p4d);
+
+			cnt += common_store(page_to_virt(page), page_to_phys(page),
+						PAGE_SIZE, osdump_var, sum);
+			if (osdump_var->rem <= 0)
+				break;
+
+			cnt += process_pud(p4d_pgtable(*p4d), osdump_var, sum);
+			if (osdump_var->rem <= 0)
+				break;
+
+		}
+
+		p4d++;
+	}
+
+	return cnt;
+}
+#endif
+
+#if CONFIG_PGTABLE_LEVELS == 5
+static int process_pgd(pgd_t *pgd, struct osdump_variables *osdump_var, int *sum)
+{
+	int i, cnt = 0;
+	struct page *page;
+
+	for (i = 0; i < PTRS_PER_PGD; i++) {
+		if ((pgd_val(*pgd))) {
+			page = pgd_page(*pgd);
+
+			cnt += common_store(page_to_virt(page), page_to_phys(page),
+						PAGE_SIZE, osdump_var, sum);
+			if (osdump_var->rem <= 0)
+				break;
+
+			cnt += process_p4d(pgd_pgtable(*pgd), osdump_var, sum);
+			if (osdump_var->rem <= 0)
+				break;
+
+		}
+
+		pgd++;
+	}
+
+	return cnt;
+}
+#endif
+
+static int ptl_dump(struct osdump_variables *osdump_var)
+{
+	int cnt = 0, sum = 0;
+
+	struct mm_struct *mm = &init_mm;
+	pgd_t *pgd = mm->pgd;
+
+	cnt += common_store(pgd, virt_to_phys(pgd), PAGE_SIZE, osdump_var, &sum);
+	if (osdump_var->rem <= 0)
+		return cnt;
+
+#if CONFIG_PGTABLE_LEVELS == 5
+	cnt += process_pgd(pgd, osdump_var, &sum);
+#elif CONFIG_PGTABLE_LEVELS == 4
+	cnt += process_p4d((p4d_t *) pgd, osdump_var, &sum);
+#elif CONFIG_PGTABLE_LEVELS == 3
+	cnt += process_pud((pud_t *) pgd, osdump_var, &sum);
+#elif CONFIG_PGTABLE_LEVELS == 2
+	cnt += process_pmd((pmd_t *) pgd, osdump_var, &sum);
+#endif
+
+	return cnt;
+}
+
+static int other_dump(struct osdump_variables *osdump_var)
+{
+	int cpu, len, sum = 0, cnt = 0;
+	void *rq;
+
+	cnt += common_store(_sdata, virt_to_phys(_sdata), _edata - _sdata, osdump_var, &sum);
+	if (osdump_var->rem <= 0)
+		return cnt;
+
+	cnt += common_store(__bss_start, virt_to_phys(__bss_start),
+				__bss_stop - __bss_start, osdump_var, &sum);
+	if (osdump_var->rem <= 0)
+		return cnt;
+
+	cnt += common_store(mem_section, virt_to_phys(mem_section), PAGE_SIZE<<1, osdump_var, &sum);
+	if (osdump_var->rem <= 0)
+		return cnt;
+
+	for_each_online_cpu(cpu) {
+		len = get_rq(cpu, &rq);
+
+		cnt += common_store(rq, virt_to_phys(rq), len, osdump_var, &sum);
+		if (osdump_var->rem <= 0)
+			return cnt;
+
+	}
+
+	return cnt;
+}
+
+static int note_dump(struct osdump_variables *osdump_var)
+{
+	int cnt = 0;
+	int sum = 0;
+
+	cnt += common_store(vmcoreinfo_note, virt_to_phys(vmcoreinfo_note),
+				get_note_size(), osdump_var, &sum);
+
+	return cnt;
+}
+
+
+struct unrecord_struct {
+	const char *name;
+	struct kmem_cache *s;
+};
+
+/*
+ * In certain scenarios, some slab objects may experience abnormally high growth,
+ * which can lead to an excessive increase in memory dump size. or some objects
+ * are unlikely to cause issues, they can be excluded from memory dumps.
+ * This exclusion helps to reduce the overall size of the dump, making crash
+ * analysis more manageable and efficient.
+ */
+static struct unrecord_struct unrecord_slab[] = {
+	[0] = {
+		.name = "dentry",
+	},
+	[1] = {
+		.name = "inode_cache",
+	},
+	[2] = {
+		.name = "ext4_inode_cache",
+	},
+	[3] = {
+		.name = "proc_inode_cache",
+	},
+	[4] = {
+		.name = "kernfs_node_cache",
+	},
+
+	[5] = {
+		.name = "UDP",
+	},
+	[6] = {
+		.name = "TCP",
+	},
+	[7] = {
+		.name = "fs_cache",
+	},
+};
+
+static int slab_dump(struct osdump_variables *osdump_var)
+{
+	int sum = 0, i;
+
+	unsigned long flags;
+	struct kmem_cache *s;
+	struct page *page;
+	struct kmem_cache_node *node;
+	struct list_head *head;
+	struct kmem_cache_cpu *c;
+	struct slab *slab;
+
+	int cnt = 0, cpu;
+	pg_data_t *pgdat;
+
+	if (!mutex_trylock(&slab_mutex)) {
+		pr_err(DUMP_BANNER "can't acquire slab_mutex, just skip dump slab!\n");
+		return 0;
+	}
+
+	list_for_each_entry(s, &slab_caches, list) {
+		for (i = 0; i < ARRAY_SIZE(unrecord_slab); i++) {
+			if (!strcmp(unrecord_slab[i].name, s->name)) {
+				unrecord_slab[i].s = s;
+				break;
+			}
+		}
+
+		if (i != ARRAY_SIZE(unrecord_slab))
+			continue;
+
+		touch_nmi_watchdog();
+		touch_all_softlockup_watchdogs();
+
+		for_each_possible_cpu(cpu) {
+			local_irq_save(flags);
+			c = per_cpu_ptr(s->cpu_slab, cpu);
+
+			slab = READ_ONCE(c->slab);
+			if (!slab) {
+				local_irq_restore(flags);
+				continue;
+			}
+
+			page = slab_page(slab);
+			cnt += common_store(page_to_virt(page), page_to_phys(page),
+					PAGE_SIZE << compound_order(page), osdump_var, &sum);
+			if (osdump_var->rem <= 0) {
+				local_irq_restore(flags);
+				goto out_ret;
+			}
+
+
+#ifdef CONFIG_SLUB_CPU_PARTIAL
+			slab = slub_percpu_partial_read_once(c);
+			while (slab) {
+				page = slab_page(slab);
+				cnt += common_store(page_to_virt(page), page_to_phys(page),
+					PAGE_SIZE << compound_order(page), osdump_var, &sum);
+				if (osdump_var->rem <= 0) {
+					local_irq_restore(flags);
+					goto out_ret;
+				}
+
+				slab = slab->next;
+			}
+#endif
+			local_irq_restore(flags);
+		}
+
+		for_each_online_pgdat(pgdat) {
+			node = s->node[pgdat->node_id];
+
+#ifdef CONFIG_SLAB
+
+			head = &node->slabs_full;
+			list_for_each_entry(slab, head, slab_list) {
+				page = slab_page(slab);
+				cnt += common_store(page_to_virt(page), page_to_phys(page),
+					PAGE_SIZE << compound_order(page), osdump_var, &sum);
+				if (osdump_var->rem <= 0)
+					goto out_ret;
+
+			}
+
+			head = &node->slabs_partial;
+			list_for_each_entry(slab, head, slab_list) {
+				page = slab_page(slab);
+				cnt += common_store(page_to_virt(page), page_to_phys(page),
+					PAGE_SIZE << compound_order(page), osdump_var, &sum);
+				if (osdump_var->rem <= 0)
+					goto out_ret;
+
+			}
+
+#elif CONFIG_SLUB
+			spin_lock_irqsave(&node->list_lock, flags);
+			head = &node->full;
+
+
+			list_for_each_entry(slab, head, slab_list) {
+				page = slab_page(slab);
+				cnt += common_store(page_to_virt(page), page_to_phys(page),
+					PAGE_SIZE << compound_order(page), osdump_var, &sum);
+				if (osdump_var->rem <= 0) {
+					spin_unlock_irqrestore(&node->list_lock, flags);
+					goto out_ret;
+				}
+			}
+
+			spin_unlock_irqrestore(&node->list_lock, flags);
+
+			spin_lock_irqsave(&node->list_lock, flags);
+			head = &node->partial;
+
+			list_for_each_entry(slab, head, slab_list) {
+				page = slab_page(slab);
+				cnt += common_store(page_to_virt(page), page_to_phys(page),
+					PAGE_SIZE << compound_order(page), osdump_var, &sum);
+				if (osdump_var->rem <= 0) {
+					spin_unlock_irqrestore(&node->list_lock, flags);
+					goto out_ret;
+				}
+			}
+
+
+			spin_unlock_irqrestore(&node->list_lock, flags);
+#endif
+
+		}
+
+	}
+
+out_ret:
+	mutex_unlock(&slab_mutex);
+
+	return cnt;
+}
+
+static int dump_mem(struct osdump_variables *osdump_var)
+{
+	int cnt = 0;
+	struct table_hdr *hdr = (struct table_hdr *)(osdump_var->mem_address);
+
+	memset(hdr, 0, sizeof(struct table_hdr));
+
+	osdump_var->rem = osdump_var->mem_size - MDUMP_HDR_SIZE;
+	osdump_var->dst = (void *)osdump_var->mem_address + MDUMP_HDR_SIZE;
+	osdump_var->meta_end = (void *)osdump_var->mem_address + MDUMP_HDR_SIZE -
+				sizeof(struct table_entry);
+	osdump_var->meta = (void *)osdump_var->mem_address + sizeof(struct table_hdr);
+
+
+	if (osdump_var->rem <= 0)
+		goto out;
+
+	cnt += note_dump(osdump_var);
+	if (osdump_var->rem <= 0)
+		goto out;
+
+	cnt += other_dump(osdump_var);
+	if (osdump_var->rem <= 0)
+		goto out;
+
+	cnt += stack_dump(osdump_var);
+	if (osdump_var->rem <= 0)
+		goto out;
+
+	cnt += slab_dump(osdump_var);
+	if (osdump_var->rem <= 0)
+		goto out;
+
+	cnt += ptl_dump(osdump_var);
+
+out:
+	hdr->count = htonl(cnt);
+	hdr->size = htonl(osdump_var->dst - (void *)osdump_var->mem_address);
+	strscpy(hdr->magic, MDUMP_MAGIC, strlen(MDUMP_MAGIC));
+	hdr->checksum = cal_checksum(hdr);
+
+	return cnt;
+}
+
+int osdump(void)
+{
+	int ret = 0;
+
+	ret = dump_mem(&osdump_var);
+	if (ret < 0) {
+		pr_err(DUMP_BANNER "dump mem failed!\n");
+		return -1;
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(osdump);
+
+static void *persistent_ram_vmap(phys_addr_t start, size_t size,
+		unsigned int memtype)
+{
+	struct page **pages;
+	phys_addr_t page_start;
+	unsigned int page_count;
+	pgprot_t prot;
+	unsigned int i;
+	void *vaddr;
+
+	page_start = start - offset_in_page(start);
+	page_count = DIV_ROUND_UP(size + offset_in_page(start), PAGE_SIZE);
+
+	if (memtype)
+		prot = pgprot_noncached(PAGE_KERNEL);
+	else
+		prot = pgprot_writecombine(PAGE_KERNEL);
+
+	pages = kmalloc_array(page_count, sizeof(struct page *), GFP_KERNEL);
+	if (!pages)
+		return NULL;
+
+	for (i = 0; i < page_count; i++) {
+		phys_addr_t addr = page_start + i * PAGE_SIZE;
+
+		pages[i] = pfn_to_page(addr >> PAGE_SHIFT);
+	}
+	vaddr = vmap(pages, page_count, VM_MAP, prot);
+	kfree(pages);
+
+	/*
+	 * Since vmap() uses page granularity, we must add the offset
+	 * into the page here, to get the byte granularity address
+	 * into the mapping to represent the actual "start" location.
+	 */
+	return vaddr + offset_in_page(start);
+}
+
+static int osdump_parse_dt(struct platform_device *pdev, struct osdump_variables *pdata)
+{
+	struct resource *res;
+
+	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	if (!res) {
+		pr_err(DUMP_BANNER "failed to locate DT /reserved-memory resource!\n");
+		return -EINVAL;
+	}
+
+	pdata->mem_address = persistent_ram_vmap(res->start, resource_size(res), 0);
+	pdata->mem_size = resource_size(res);
+
+	return 0;
+}
+
+static int osdump_probe(struct platform_device *pdev)
+{
+	struct device *dev;
+
+	dev = &pdev->dev;
+	dev->platform_data = &osdump_var;
+
+	if (dev_of_node(dev))
+		osdump_parse_dt(pdev, &osdump_var);
+
+	return 0;
+}
+
+static int osdump_remove(struct platform_device *pdev)
+{
+	return 0;
+}
+
+
+static const struct of_device_id osdump_of_match[] = {
+	{ .compatible = "osdump", },
+	{}
+};
+
+static struct platform_driver osdump_driver = {
+	.probe = osdump_probe,
+	.remove = osdump_remove,
+	.driver = {
+		.name = OS_DUMP,
+		.of_match_table = osdump_of_match,
+	},
+};
+
+static int __init osdump_init(void)
+{
+	return platform_driver_register(&osdump_driver);
+}
+postcore_initcall(osdump_init);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("os minidump driver");
+MODULE_AUTHOR("qiruipeng");
diff --git a/kernel/osdump/extern.h b/kernel/osdump/extern.h
new file mode 100644
index 000000000000..da0d25ef4662
--- /dev/null
+++ b/kernel/osdump/extern.h
@@ -0,0 +1,13 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#ifndef _LINUX_OS_MINIDUMP_EXTERN_H
+#define _LINUX_OS_MINIDUMP_EXTERN_H
+
+extern struct kmem_cache *task_struct_cachep;
+extern size_t big_oops_buf_sz;
+extern int osdump_compress(const void *in, void *out, int size, int *left);
+extern int get_rq(int cpu, void **rq);
+extern u32 *vmcoreinfo_note;
+extern int get_note_size(void);
+
+#endif
diff --git a/kernel/osdump/inode.c b/kernel/osdump/inode.c
new file mode 100644
index 000000000000..9356c4b8795f
--- /dev/null
+++ b/kernel/osdump/inode.c
@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Interface for accessing the crash dump from the system's previous life.
+ */
+#include <linux/module.h>
+#include <linux/proc_fs.h>
+#include <linux/fs.h>
+#include <linux/slab.h>
+#include "internal.h"
+
+struct inode_priv {
+	void *addr;
+	size_t size;
+	struct proc_dir_entry *proc_osdump;
+};
+static struct inode_priv *inode_priv;
+
+static ssize_t osdump_read(struct file *file, char __user *buf,
+		size_t count, loff_t *ppos)
+{
+	if (!inode_priv)
+		return 0;
+
+	return simple_read_from_buffer(buf, count, ppos, inode_priv->addr, inode_priv->size);
+}
+
+static const struct proc_ops osdump_proc_ops = {
+	.proc_read = osdump_read,
+	.proc_lseek = default_llseek,
+};
+
+static int __init osdump_init_fs(void)
+{
+	int ret = 0;
+	struct table_hdr *hdr;
+
+	inode_priv = kzalloc(sizeof(struct inode_priv), GFP_KERNEL);
+	if (!inode_priv)
+		return -ENOMEM;
+
+	hdr = (struct table_hdr *)osdump_var.mem_address;
+	if (!hdr_valid(hdr))
+		goto err;
+
+	inode_priv->addr = hdr;
+	inode_priv->size = ntohl(hdr->size);
+
+	inode_priv->proc_osdump = proc_create("osdump", 0400, NULL, &osdump_proc_ops);
+	if (!inode_priv->proc_osdump) {
+		ret = -ENOENT;
+		pr_err(DUMP_BANNER "osdump create inode failed!\n");
+		goto err;
+	}
+
+	return 0;
+
+err:
+	kfree(inode_priv);
+	inode_priv = NULL;
+
+	return ret;
+}
+fs_initcall(osdump_init_fs);
+
+void osdump_cleanup_fs(void)
+{
+	if (inode_priv && inode_priv->proc_osdump) {
+		proc_remove(inode_priv->proc_osdump);
+		inode_priv->proc_osdump = NULL;
+	}
+
+	kfree(inode_priv);
+	inode_priv = NULL;
+}
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("qiruipeng");
diff --git a/kernel/osdump/internal.h b/kernel/osdump/internal.h
new file mode 100644
index 000000000000..5dc09fe37295
--- /dev/null
+++ b/kernel/osdump/internal.h
@@ -0,0 +1,95 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#ifndef	_LINUX_OS_MINIDUMP_INTERNAL_H
+#define	_LINUX_OS_MINIDUMP_INTERNAL_H
+
+/*
+ * We only dump the data we are interested in, each of which represents
+ * a continuous region - this could be a structure or pages of data. These
+ * data are compressed first and then stored into one or several entries,
+ * each with a maximum size of 32K.
+ *
+ * We use reserved memory to store these dump data, referred to as
+ * 'dump region'. This region consists of two parts: The first part records
+ * the meta info and is thus, known as the 'meta region' and the second part
+ * stores the raw data in sequence and is known as the 'data region'.
+ *
+ * At the beginning of the meta region lies a header that records the total
+ * size and count of entries. Following the header, there's a table which
+ * holds metadata for each entry. This metadata records the physical address
+ * of the dumped data in memory, in addition to the offset and size of the
+ * data stored in the dump region.
+ *
+ * The second part of the dump region stores compressed data for each entry
+ * in an orderly manner.
+ */
+
+// fixed size for meta region.
+#define MDUMP_HDR_SIZE		(192*1024)
+#define MDUMP_MAGIC		"osdump"
+#define DUMP_BANNER		"osdump: "
+
+#define CRYPTO_SIZE		(PAGE_SIZE << 3)
+
+struct table_hdr {
+	/* entries count */
+	unsigned int count;
+	/* total size */
+	unsigned int size;
+	/* for aligned */
+	union {
+		int reserve[2];
+		struct {
+			char magic[7];
+			unsigned char  checksum;
+		};
+	};
+};
+
+struct table_entry {
+	/*  offset in dump region */
+	unsigned int start;
+	unsigned int size;
+	/* physical addr in memory */
+	unsigned long long src;
+};
+
+/*
+ * Runtime information: this struct save the runtime information used for
+ * os minidump.
+ */
+struct osdump_variables {
+	/* virtual addr for dump region */
+	void           *mem_address;
+	/* total size for dump data */
+	unsigned long   mem_size;
+	/* curr entry's metadata */
+	struct table_entry *meta;
+	/* last metadata */
+	struct table_entry *meta_end;
+	/* remain size for dump data */
+	int             rem;
+	/* addr stored  in dump region */
+	void            *dst;
+};
+
+
+extern struct osdump_variables osdump_var;
+
+static inline unsigned char cal_checksum(struct table_hdr *hdr)
+{
+	int i, len = sizeof(struct table_hdr) - 1;
+	unsigned char ch = 0, *ptr = (unsigned char *)hdr;
+
+	for (i = 0; i < len; i++)
+		ch += ptr[i];
+
+	return ch;
+}
+
+static inline bool hdr_valid(struct table_hdr *hdr)
+{
+	return !strncmp(MDUMP_MAGIC, hdr->magic, strlen(MDUMP_MAGIC)) &&
+						hdr->checksum == cal_checksum(hdr);
+}
+#endif
