From: Chen Wandun chenwandun@huawei.com

hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/I4HOXK

------------------------------------------

Add 3 proc interface to control page cache limit behavior: 1. switch of the this feature 2. control the page cache limit 3. control the ratio to reclaim when page cache beyond page cache limit

Signed-off-by: Chen Wandun chenwandun@huawei.com Reviewed-by: Kefeng Wang wangkefeng.wang@huawei.com Signed-off-by: Zheng Zengkai zhengzengkai@huawei.com --- include/linux/page_cache_limit.h | 14 +++++++++ kernel/sysctl.c | 32 ++++++++++++++++++++ mm/Kconfig | 12 ++++++++ mm/Makefile | 1 + mm/page_cache_limit.c | 51 ++++++++++++++++++++++++++++++++ 5 files changed, 110 insertions(+) create mode 100644 include/linux/page_cache_limit.h create mode 100644 mm/page_cache_limit.c

diff --git a/include/linux/page_cache_limit.h b/include/linux/page_cache_limit.h new file mode 100644 index 000000000000..98f12734114b --- /dev/null +++ b/include/linux/page_cache_limit.h @@ -0,0 +1,14 @@ +#ifndef _PAGECACHE_H +#define _PAGECACHE_H + +#ifdef CONFIG_SHRINK_PAGECACHE +extern int pagecache_reclaim_enable; +extern int pagecache_limit_ratio; +extern int pagecache_reclaim_ratio; + +int proc_page_cache_limit(struct ctl_table *table, int write, + void __user *buffer, size_t *lenp, loff_t *ppos); +#else +#endif + +#endif diff --git a/kernel/sysctl.c b/kernel/sysctl.c index 3ab6ea7853ba..b3ee0deaa8dd 100644 --- a/kernel/sysctl.c +++ b/kernel/sysctl.c @@ -103,6 +103,9 @@ #ifdef CONFIG_LOCKUP_DETECTOR #include <linux/nmi.h> #endif +#ifdef CONFIG_SHRINK_PAGECACHE +#include <linux/page_cache_limit.h> +#endif

#if defined(CONFIG_SYSCTL)

@@ -3192,6 +3195,35 @@ static struct ctl_table vm_table[] = { .extra1 = SYSCTL_ZERO, .extra2 = SYSCTL_ONE, }, +#endif +#ifdef CONFIG_SHRINK_PAGECACHE + { + .procname = "cache_reclaim_enable", + .data = &pagecache_reclaim_enable, + .maxlen = sizeof(pagecache_reclaim_enable), + .mode = 0600, + .proc_handler = proc_dointvec_minmax, + .extra1 = SYSCTL_ZERO, + .extra2 = SYSCTL_ONE, + }, + { + .procname = "cache_limit_ratio", + .data = &pagecache_limit_ratio, + .maxlen = sizeof(pagecache_limit_ratio), + .mode = 0600, + .proc_handler = proc_page_cache_limit, + .extra1 = SYSCTL_ZERO, + .extra2 = (void *)&one_hundred, + }, + { + .procname = "cache_reclaim_ratio", + .data = &pagecache_reclaim_ratio, + .maxlen = sizeof(pagecache_reclaim_ratio), + .mode = 0600, + .proc_handler = proc_dointvec_minmax, + .extra1 = SYSCTL_ZERO, + .extra2 = (void *)&one_hundred, + }, #endif { } }; diff --git a/mm/Kconfig b/mm/Kconfig index 59fdace319fd..f565fc82c200 100644 --- a/mm/Kconfig +++ b/mm/Kconfig @@ -486,6 +486,18 @@ config FRONTSWAP

If unsure, say Y to enable frontswap.

+config SHRINK_PAGECACHE + bool "Enable shrinking the page cache" + depends on MMU + default n + help + SHRINK_PAGECACHE means that we do not want to keep the large number + of page cache in the system, even though page cache can greatly improve + the performance of the machine. Large number of page cache may result + in short of memory, which will result OOM at the same time, so in order + to keep page cache in a reasonable range, the number of page cache + should be limited, and that is what SHRINK_PAGECACHE does. + config MEMCG_QOS bool "Enable Memory Cgroup Priority" depends on MEMCG diff --git a/mm/Makefile b/mm/Makefile index 4d07adb60619..c14522bd17ed 100644 --- a/mm/Makefile +++ b/mm/Makefile @@ -125,3 +125,4 @@ obj-$(CONFIG_PTDUMP_CORE) += ptdump.o obj-$(CONFIG_PAGE_REPORTING) += page_reporting.o obj-$(CONFIG_HAVE_BOOTMEM_INFO_NODE) += bootmem_info.o obj-$(CONFIG_PIN_MEMORY) += pin_mem.o +obj-$(CONFIG_SHRINK_PAGECACHE) += page_cache_limit.o diff --git a/mm/page_cache_limit.c b/mm/page_cache_limit.c new file mode 100644 index 000000000000..55fdea087804 --- /dev/null +++ b/mm/page_cache_limit.c @@ -0,0 +1,51 @@ +#include <linux/mm.h> +#include <linux/sysctl.h> + +int pagecache_reclaim_enable; +int pagecache_limit_ratio; +int pagecache_reclaim_ratio; + +static unsigned long pagecache_limit_pages; +static unsigned long node_pagecache_limit_pages[MAX_NUMNODES]; + +static unsigned long get_node_total_pages(int nid) +{ + int zone_type; + unsigned long managed_pages = 0; + pg_data_t *pgdat = NODE_DATA(nid); + + if (!pgdat) + return 0; + + for (zone_type = 0; zone_type < MAX_NR_ZONES; zone_type++) + managed_pages += zone_managed_pages(&pgdat->node_zones[zone_type]); + + return managed_pages; +} + +static void setup_pagecache_limit(void) +{ + int i; + unsigned long node_total_pages; + + pagecache_limit_pages = pagecache_limit_ratio * totalram_pages() / 100; + + for (i = 0; i < MAX_NUMNODES; i++) { + node_total_pages = get_node_total_pages(i); + node_pagecache_limit_pages[i] = node_total_pages * + pagecache_limit_ratio / 100; + } +} + +int proc_page_cache_limit(struct ctl_table *table, int write, + void __user *buffer, size_t *lenp, loff_t *ppos) +{ + int ret; + + ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos); + + if (write && !ret) + setup_pagecache_limit(); + + return ret; +}

From: Chen Wandun chenwandun@huawei.com

hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/I4HOXK

------------------------------------------

In NUMA system, each node may have different pages, so pages that to reclaim should be calculated separately when the number of page cache beyond page cache limit.

Signed-off-by: Chen Wandun chenwandun@huawei.com Reviewed-by: Kefeng Wang wangkefeng.wang@huawei.com Signed-off-by: Zheng Zengkai zhengzengkai@huawei.com --- mm/page_cache_limit.c | 52 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 51 insertions(+), 1 deletion(-)

diff --git a/mm/page_cache_limit.c b/mm/page_cache_limit.c index 4afc08373a35..33164e19cfa2 100644 --- a/mm/page_cache_limit.c +++ b/mm/page_cache_limit.c @@ -104,10 +104,60 @@ void wakeup_all_kpagecache_limitd(void) wakeup_kpagecache_limitd(nid); }

+static unsigned long node_nr_page_cache(int nid) +{ + struct pglist_data *pgdat; + unsigned long num = 0; + + pgdat = NODE_DATA(nid); + if (!pgdat) + return 0; + + num = node_page_state(pgdat, NR_FILE_PAGES); + num -= node_page_state(pgdat, NR_SHMEM); + + return num; +} + +static unsigned long node_nr_page_reclaim(int nid) +{ + unsigned long nr_page_cache; + unsigned long nr_to_reclaim; + unsigned long total_pages; + + if (!node_pagecache_limit_pages[nid]) + return 0; + + nr_page_cache = node_nr_page_cache(nid); + if (!nr_page_cache) + return 0; + + if (nr_page_cache < node_pagecache_limit_pages[nid]) + return 0; + + total_pages = get_node_total_pages(nid); + nr_to_reclaim = nr_page_cache - node_pagecache_limit_pages[nid]; + nr_to_reclaim += total_pages * pagecache_reclaim_ratio / 100; + + return nr_to_reclaim; +} + +static void shrink_node_page_cache(int nid) +{ + unsigned long nr_to_reclaim; + + nr_to_reclaim = node_nr_page_reclaim(nid); +} + static void shrink_page_cache(void) { - if (!pagecache_overlimit()) + int nid; + + if (!pagecache_reclaim_enable || !pagecache_overlimit()) return; + + for_each_node_state(nid, N_MEMORY) + shrink_node_page_cache(nid); }

static DECLARE_COMPLETION(setup_done);

From: Chen Wandun chenwandun@huawei.com

hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/I4HOXK

------------------------------------------

kthread and page cache limit should be reconfigured when memory hot plug and hot unplug.

Signed-off-by: Chen Wandun chenwandun@huawei.com Reviewed-by: Kefeng Wang wangkefeng.wang@huawei.com Signed-off-by: Zheng Zengkai zhengzengkai@huawei.com --- include/linux/page_cache_limit.h | 4 +++ mm/memory_hotplug.c | 3 +++ mm/page_cache_limit.c | 45 +++++++++++++++++++++++++------- 3 files changed, 43 insertions(+), 9 deletions(-)

diff --git a/include/linux/page_cache_limit.h b/include/linux/page_cache_limit.h index e4ef5919cb92..7906b12af947 100644 --- a/include/linux/page_cache_limit.h +++ b/include/linux/page_cache_limit.h @@ -17,7 +17,11 @@ int proc_page_cache_limit(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos); unsigned long __shrink_node_page_cache(int nid, gfp_t mask, unsigned long nr_to_reclaim, enum page_cache_reclaim_flag flag); +void kpagecache_limitd_stop(int nid); +int kpagecache_limitd_run(int nid); #else +static inline void kpagecache_limitd_stop(int nid) {} +static inline int kpagecache_limitd_run(int nid) { return 0; } #endif

#endif diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c index a009b6395b02..a8f0d804a758 100644 --- a/mm/memory_hotplug.c +++ b/mm/memory_hotplug.c @@ -38,6 +38,7 @@ #include <linux/rmap.h>

#include <asm/tlbflush.h> +#include <linux/page_cache_limit.h>

#include "internal.h" #include "shuffle.h" @@ -735,6 +736,7 @@ int __ref online_pages(unsigned long pfn, unsigned long nr_pages,

kswapd_run(nid); kcompactd_run(nid); + kpagecache_limitd_run(nid);

writeback_set_ratelimit();

@@ -1491,6 +1493,7 @@ int __ref offline_pages(unsigned long start_pfn, unsigned long nr_pages) if (arg.status_change_nid >= 0) { kswapd_stop(node); kcompactd_stop(node); + kpagecache_limitd_stop(node); }

writeback_set_ratelimit(); diff --git a/mm/page_cache_limit.c b/mm/page_cache_limit.c index 1581334429e1..0a3098c9bb33 100644 --- a/mm/page_cache_limit.c +++ b/mm/page_cache_limit.c @@ -31,18 +31,27 @@ static unsigned long get_node_total_pages(int nid) return managed_pages; }

-static void setup_pagecache_limit(void) +static void setup_node_pagecache_limit(int nid) { - int i; unsigned long node_total_pages;

+ node_total_pages = get_node_total_pages(nid); + node_pagecache_limit_pages[nid] = node_total_pages * pagecache_limit_ratio / 100; +} + +#define ALL_NODE (-1) +static void setup_pagecache_limit(int nid) +{ + int i; + pagecache_limit_pages = pagecache_limit_ratio * totalram_pages() / 100;

- for (i = 0; i < MAX_NUMNODES; i++) { - node_total_pages = get_node_total_pages(i); - node_pagecache_limit_pages[i] = node_total_pages * - pagecache_limit_ratio / 100; - } + if (nid != ALL_NODE) + setup_node_pagecache_limit(nid); + + else + for (i = 0; i < MAX_NUMNODES; i++) + setup_node_pagecache_limit(i); }

int proc_page_cache_limit(struct ctl_table *table, int write, @@ -53,7 +62,7 @@ int proc_page_cache_limit(struct ctl_table *table, int write, ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);

if (write && !ret) - setup_pagecache_limit(); + setup_pagecache_limit(ALL_NODE);

return ret; } @@ -72,6 +81,8 @@ void kpagecache_limitd_stop(int nid) kvfree(pagecache_limitd_wait_queue[nid]); pagecache_limitd_wait_queue[nid] = NULL; } + + setup_pagecache_limit(nid); }

static void wakeup_kpagecache_limitd(int nid) @@ -207,7 +218,7 @@ static int pagecache_limitd(void *arg) return 0; }

-int kpagecache_limitd_run(int nid) +static int __kpagecache_limitd_run(int nid) { int ret = 0; wait_queue_head_t *queue_head = NULL; @@ -236,6 +247,22 @@ int kpagecache_limitd_run(int nid) return ret; }

+int kpagecache_limitd_run(int nid) +{ + int ret; + + if (nid < 0 || nid >= MAX_NUMNODES) + return -EINVAL; + + ret = __kpagecache_limitd_run(nid); + if (ret) + return ret; + + setup_pagecache_limit(nid); + + return 0; +} + static int __init kpagecache_limitd_init(void) { int nid;

From: Chen Wandun chenwandun@huawei.com

hulk inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/I4HOXK

------------------------------------------

Add a proc interface to drop cache in target node.

Signed-off-by: Chen Wandun chenwandun@huawei.com Reviewed-by: Kefeng Wang wangkefeng.wang@huawei.com Signed-off-by: Zheng Zengkai zhengzengkai@huawei.com --- fs/drop_caches.c | 36 ++++++++++++++++++++++++++++++-- include/linux/fs.h | 9 ++++++++ include/linux/page_cache_limit.h | 3 +++ kernel/sysctl.c | 8 +++++++ mm/page_cache_limit.c | 2 ++ mm/truncate.c | 34 +++++++++++++++++++++++++++--- 6 files changed, 87 insertions(+), 5 deletions(-)

diff --git a/fs/drop_caches.c b/fs/drop_caches.c index f00fcc4a4f72..ff70ef7674e3 100644 --- a/fs/drop_caches.c +++ b/fs/drop_caches.c @@ -9,12 +9,17 @@ #include <linux/writeback.h> #include <linux/sysctl.h> #include <linux/gfp.h> + +#ifdef CONFIG_SHRINK_PAGECACHE +#include <linux/page_cache_limit.h> +#endif + #include "internal.h"

/* A global variable is a bit ugly, but it keeps the code simple */ int sysctl_drop_caches;

-static void drop_pagecache_sb(struct super_block *sb, void *unused) +static void drop_pagecache_sb(struct super_block *sb, void *nid) { struct inode *inode, *toput_inode = NULL;

@@ -35,7 +40,12 @@ static void drop_pagecache_sb(struct super_block *sb, void *unused) spin_unlock(&inode->i_lock); spin_unlock(&sb->s_inode_list_lock);

- invalidate_mapping_pages(inode->i_mapping, 0, -1); + if (!nid) + invalidate_mapping_pages(inode->i_mapping, 0, -1); + else + node_invalidate_mapping_pages(inode->i_mapping, + *(int *)nid, 0, -1); + iput(toput_inode); toput_inode = inode;

@@ -74,3 +84,25 @@ int drop_caches_sysctl_handler(struct ctl_table *table, int write, } return 0; } + +#ifdef CONFIG_SHRINK_PAGECACHE +int proc_shrink_node_caches(struct ctl_table *table, int write, + void __user *buffer, size_t *lenp, loff_t *ppos) +{ + int ret; + + ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos); + if (ret || !write) + return ret; + + if (node_to_shrink >= MAX_NUMNODES) + return -EINVAL; + + if (!node_isset(node_to_shrink, node_states[N_MEMORY])) + return 0; + + iterate_supers(drop_pagecache_sb, &node_to_shrink); + + return 0; +} +#endif diff --git a/include/linux/fs.h b/include/linux/fs.h index dd3379e76525..8f6704a3f596 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -2613,6 +2613,15 @@ extern bool is_bad_inode(struct inode *); unsigned long invalidate_mapping_pages(struct address_space *mapping, pgoff_t start, pgoff_t end);

+#ifdef CONFIG_SHRINK_PAGECACHE +unsigned long node_invalidate_mapping_pages(struct address_space *mapping, + int nid, pgoff_t start, pgoff_t end); +#else +static inline unsigned long +node_invalidate_mapping_pages(struct address_space *mapping, int nid, + pgoff_t start, pgoff_t end) { return 0; } +#endif + void invalidate_mapping_pagevec(struct address_space *mapping, pgoff_t start, pgoff_t end, unsigned long *nr_pagevec); diff --git a/include/linux/page_cache_limit.h b/include/linux/page_cache_limit.h index 2df08a0604d8..442d6126c529 100644 --- a/include/linux/page_cache_limit.h +++ b/include/linux/page_cache_limit.h @@ -12,6 +12,7 @@ enum page_cache_reclaim_flag { extern int pagecache_reclaim_enable; extern int pagecache_limit_ratio; extern int pagecache_reclaim_ratio; +extern int node_to_shrink;

int proc_page_cache_limit(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos); @@ -20,6 +21,8 @@ unsigned long __shrink_node_page_cache(int nid, gfp_t mask, void kpagecache_limitd_stop(int nid); int kpagecache_limitd_run(int nid); void wakeup_all_kpagecache_limitd(void); +int proc_shrink_node_caches(struct ctl_table *table, int write, + void __user *buffer, size_t *lenp, loff_t *ppos); #else static inline void kpagecache_limitd_stop(int nid) {} static inline int kpagecache_limitd_run(int nid) { return 0; } diff --git a/kernel/sysctl.c b/kernel/sysctl.c index b3ee0deaa8dd..261787cebd8e 100644 --- a/kernel/sysctl.c +++ b/kernel/sysctl.c @@ -3224,6 +3224,14 @@ static struct ctl_table vm_table[] = { .extra1 = SYSCTL_ZERO, .extra2 = (void *)&one_hundred, }, + { + .procname = "node_drop_caches", + .data = &node_to_shrink, + .maxlen = sizeof(node_to_shrink), + .mode = 0600, + .proc_handler = proc_shrink_node_caches, + .extra1 = SYSCTL_ZERO, + }, #endif { } }; diff --git a/mm/page_cache_limit.c b/mm/page_cache_limit.c index 0a3098c9bb33..0ccc1388c8dc 100644 --- a/mm/page_cache_limit.c +++ b/mm/page_cache_limit.c @@ -5,11 +5,13 @@ #include <linux/module.h> #include <linux/err.h> #include <linux/swap.h> +#include <linux/fs.h> #include <linux/page_cache_limit.h>

int pagecache_reclaim_enable; int pagecache_limit_ratio; int pagecache_reclaim_ratio; +int node_to_shrink;

static unsigned long pagecache_limit_pages; static unsigned long node_pagecache_limit_pages[MAX_NUMNODES]; diff --git a/mm/truncate.c b/mm/truncate.c index 98d08f197766..6d4887a43cd8 100644 --- a/mm/truncate.c +++ b/mm/truncate.c @@ -465,7 +465,7 @@ void truncate_inode_pages_final(struct address_space *mapping) EXPORT_SYMBOL(truncate_inode_pages_final);

static unsigned long __invalidate_mapping_pages(struct address_space *mapping, - pgoff_t start, pgoff_t end, unsigned long *nr_pagevec) + pgoff_t start, pgoff_t end, unsigned long *nr_pagevec, int nid) { pgoff_t indices[PAGEVEC_SIZE]; struct pagevec pvec; @@ -487,6 +487,10 @@ static unsigned long __invalidate_mapping_pages(struct address_space *mapping, page); continue; } + + if (nid != NUMA_NO_NODE && page_to_nid(page) != nid) + continue; + index += thp_nr_pages(page) - 1;

ret = invalidate_inode_page(page); @@ -529,10 +533,34 @@ static unsigned long __invalidate_mapping_pages(struct address_space *mapping, unsigned long invalidate_mapping_pages(struct address_space *mapping, pgoff_t start, pgoff_t end) { - return __invalidate_mapping_pages(mapping, start, end, NULL); + return __invalidate_mapping_pages(mapping, start, end, NULL, NUMA_NO_NODE); } EXPORT_SYMBOL(invalidate_mapping_pages);

+ +/** + * node_invalidate_mapping_pages - Invalidate all the unlocked pages in @nid of one inode + * @mapping: the address_space which holds the pages to invalidate + * @nid: pages belong to this node will be invalidate + * @start: the offset 'from' which to invalidate + * @end: the offset 'to' which to invalidate (inclusive) + * + * This function only removes the unlocked pages, if you want to + * remove all the pages of one inode, you must call truncate_inode_pages. + * + * node_invalidate_mapping_pages() will not block on IO activity. It will not + * invalidate pages which are dirty, locked, under writeback or mapped into + * pagetables. + * + * Return: the number of the pages that were invalidated + */ +#ifdef CONFIG_SHRINK_PAGECACHE +unsigned long node_invalidate_mapping_pages(struct address_space *mapping, + int nid, pgoff_t start, pgoff_t end) +{ + return __invalidate_mapping_pages(mapping, start, end, NULL, nid); +} +#endif /** * This helper is similar with the above one, except that it accounts for pages * that are likely on a pagevec and count them in @nr_pagevec, which will used by @@ -541,7 +569,7 @@ EXPORT_SYMBOL(invalidate_mapping_pages); void invalidate_mapping_pagevec(struct address_space *mapping, pgoff_t start, pgoff_t end, unsigned long *nr_pagevec) { - __invalidate_mapping_pages(mapping, start, end, nr_pagevec); + __invalidate_mapping_pages(mapping, start, end, nr_pagevec, NUMA_NO_NODE); }

/*

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278, https://gitee.com/openeuler/kernel/issues/I4K27D CVE: NA

-------------------------------------------------

Proximity domain of Memory MSC node cannot be treated as node id for components' index, we should use acpi_map_pxm_to_node() to get the exact node id anyway, for instance, after DIE interleaving, we can only use node id instead, for pxm is discontinuous at this time.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com --- drivers/acpi/arm64/mpam.c | 33 ++++----------------------------- 1 file changed, 4 insertions(+), 29 deletions(-)

diff --git a/drivers/acpi/arm64/mpam.c b/drivers/acpi/arm64/mpam.c index 6c238f5a5c5a..51419473f63b 100644 --- a/drivers/acpi/arm64/mpam.c +++ b/drivers/acpi/arm64/mpam.c @@ -71,42 +71,17 @@ acpi_mpam_label_cache_component_id(struct acpi_table_header *table_hdr, return 0; }

-/** - * acpi_mpam_label_memory_component_id() - Use proximity_domain id to - * label mpam memory node, which be signed by @component_id. - * @proximity_domain: proximity_domain of ACPI MPAM memory node - * @component_id: The id labels the structure mpam_node memory - */ -static int acpi_mpam_label_memory_component_id(u8 proximity_domain, - u32 *component_id) -{ - u32 nid = (u32)proximity_domain; - - if (nid >= nr_online_nodes) { - pr_err_once("Invalid proximity domain\n"); - return -EINVAL; - } - - *component_id = nid; - return 0; -} - static int __init acpi_mpam_parse_memory(struct acpi_mpam_header *h) { - int ret; u32 component_id; struct mpam_device *dev; struct acpi_mpam_node_memory *node = (struct acpi_mpam_node_memory *)h;

- ret = acpi_mpam_label_memory_component_id(node->proximity_domain, - &component_id); - if (ret) { - pr_err("Failed to label memory component id\n"); - return -EINVAL; - } + component_id = acpi_map_pxm_to_node(node->proximity_domain); + if (component_id == NUMA_NO_NODE) + component_id = 0;

- dev = mpam_device_create_memory(component_id, - node->header.base_address); + dev = mpam_device_create_memory(component_id, node->header.base_address); if (IS_ERR(dev)) { pr_err("Failed to create memory node\n"); return -EINVAL;

From: yangerkun yangerkun@huawei.com

hulk inclusion category: bugfix bugzilla: 185805, https://gitee.com/openeuler/kernel/issues/I4JX0L CVE: NA

---------------------------

Parallel thread to add negative dentry under root dir. Sometimes later, 'systemctl daemon-reload' will report softlockup since __fsnotify_update_child_dentry_flags need update all child under root dentry without distinguish does it active or not. It will waste so long time with catching d_lock of root dentry. And other thread try to spin_lock d_lock will run overtime.

Limit negative dentry under dir can avoid this.

Signed-off-by: yangerkun yangerkun@huawei.com Reviewed-by: Miao Xie miaoxie@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com

Conflicts: fs/dcache.c include/linux/dcache.h Reviewed-by: Zhang Yi yi.zhang@huawei.com Signed-off-by: Zheng Zengkai zhengzengkai@huawei.com --- fs/dcache.c | 43 ++++++++++++++++++++++++++++++++++++++++-- include/linux/dcache.h | 4 ++++ 2 files changed, 45 insertions(+), 2 deletions(-)

diff --git a/fs/dcache.c b/fs/dcache.c index 185d71a1c05b..f5b78cc80a00 100644 --- a/fs/dcache.c +++ b/fs/dcache.c @@ -314,10 +314,18 @@ static inline void __d_set_inode_and_type(struct dentry *dentry, unsigned type_flags) { unsigned flags; + struct dentry *parent; + + parent = dentry->d_parent; + if ((dentry->d_flags & DCACHE_NEGATIVE_ACCOUNT) && parent) { + WARN_ON(!inode); + atomic_dec(&parent->d_neg_dnum); + }

dentry->d_inode = inode; flags = READ_ONCE(dentry->d_flags); - flags &= ~(DCACHE_ENTRY_TYPE | DCACHE_FALLTHRU); + flags &= ~(DCACHE_ENTRY_TYPE | DCACHE_FALLTHRU | + DCACHE_NEGATIVE_ACCOUNT); flags |= type_flags; smp_store_release(&dentry->d_flags, flags); } @@ -336,6 +344,7 @@ static inline void __d_clear_type_and_inode(struct dentry *dentry) static void dentry_free(struct dentry *dentry) { WARN_ON(!hlist_unhashed(&dentry->d_u.d_alias)); + WARN_ON(dentry->d_flags & DCACHE_NEGATIVE_ACCOUNT); if (unlikely(dname_external(dentry))) { struct external_name *p = external_name(dentry); if (likely(atomic_dec_and_test(&p->u.count))) { @@ -573,8 +582,14 @@ static void __dentry_kill(struct dentry *dentry) /* if it was on the hash then remove it */ __d_drop(dentry); dentry_unlist(dentry, parent); - if (parent) + if (parent) { + if (dentry->d_flags & DCACHE_NEGATIVE_ACCOUNT) { + atomic_dec(&parent->d_neg_dnum); + dentry->d_flags &= ~DCACHE_NEGATIVE_ACCOUNT; + } + spin_unlock(&parent->d_lock); + } if (dentry->d_inode) dentry_unlink_inode(dentry); else @@ -634,6 +649,8 @@ static inline struct dentry *lock_parent(struct dentry *dentry)

static inline bool retain_dentry(struct dentry *dentry) { + struct dentry *parent; + WARN_ON(d_in_lookup(dentry));

/* Unreachable? Get rid of it */ @@ -651,6 +668,27 @@ static inline bool retain_dentry(struct dentry *dentry) if (unlikely(dentry->d_flags & DCACHE_DONTCACHE)) return false;

+ if (unlikely(!dentry->d_parent)) + goto noparent; + + parent = dentry->d_parent; + /* Return false if it's negative */ + WARN_ON((atomic_read(&parent->d_neg_dnum) < 0)); + if (!dentry->d_inode) { + if (!(dentry->d_flags & DCACHE_NEGATIVE_ACCOUNT)) { + unsigned int flags = READ_ONCE(dentry->d_flags); + + flags |= DCACHE_NEGATIVE_ACCOUNT; + WRITE_ONCE(dentry->d_flags, flags); + atomic_inc(&parent->d_neg_dnum); + } + } + + if (!dentry->d_inode && + atomic_read(&parent->d_neg_dnum) >= NEG_DENTRY_LIMIT) + return false; + +noparent: /* retain; LRU fodder */ dentry->d_lockref.count--; if (unlikely(!(dentry->d_flags & DCACHE_LRU_LIST))) @@ -1749,6 +1787,7 @@ static struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name) seqcount_spinlock_init(&dentry->d_seq, &dentry->d_lock); dentry->d_inode = NULL; dentry->d_parent = dentry; + atomic_set(&dentry->d_neg_dnum, 0); dentry->d_sb = sb; dentry->d_op = NULL; dentry->d_fsdata = NULL; diff --git a/include/linux/dcache.h b/include/linux/dcache.h index 6f95c3300cbb..edb5efeff11a 100644 --- a/include/linux/dcache.h +++ b/include/linux/dcache.h @@ -84,6 +84,7 @@ extern struct dentry_stat_t dentry_stat; # endif #endif

+#define NEG_DENTRY_LIMIT 16384 #define d_lock d_lockref.lock

struct dentry { @@ -118,6 +119,8 @@ struct dentry { struct hlist_bl_node d_in_lookup_hash; /* only for in-lookup ones */ struct rcu_head d_rcu; } d_u; + /* negative dentry under this dentry, if it's dir */ + atomic_t d_neg_dnum; } __randomize_layout;

/* @@ -219,6 +222,7 @@ struct dentry_operations { #define DCACHE_PAR_LOOKUP 0x10000000 /* being looked up (with parent locked shared) */ #define DCACHE_DENTRY_CURSOR 0x20000000 #define DCACHE_NORCU 0x40000000 /* No RCU delay for freeing */ +#define DCACHE_NEGATIVE_ACCOUNT 0x80000000

extern seqlock_t rename_lock;

From: Anshuman Khandual khandual@linux.vnet.ibm.com

ascend inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/I4JMLR CVE: NA -------------------

Kernel allocation to CDM node has already been prevented by putting it's entire memory in ZONE_MOVABLE. But the CDM nodes must also be isolated from implicit allocations happening on the system.

Any isolation seeking CDM node requires isolation from implicit memory allocations from user space but at the same time there should also have an explicit way to do the memory allocation.

Platform node's both zonelists are fundamental to where the memory comes from when there is an allocation request. In order to achieve these two objectives as stated above, zonelists building process has to change as both zonelists (i.e FALLBACK and NOFALLBACK) gives access to the node's memory zones during any kind of memory allocation. The following changes are implemented in this regard.

* CDM node's zones are not part of any other node's FALLBACK zonelist * CDM node's FALLBACK list contains it's own memory zones followed by all system RAM zones in regular order as before * CDM node's zones are part of it's own NOFALLBACK zonelist

These above changes ensure the following which in turn isolates the CDM nodes as desired.

* There wont be any implicit memory allocation ending up in the CDM node * Only __GFP_THISNODE marked allocations will come from the CDM node * CDM node memory can be allocated through mbind(MPOL_BIND) interface * System RAM memory will be used as fallback option in regular order in case the CDM memory is insufficient during targted allocation request

Sample zonelist configuration:

[NODE (0)] RAM ZONELIST_FALLBACK (0xc00000000140da00) (0) (node 0) (DMA 0xc00000000140c000) (1) (node 1) (DMA 0xc000000100000000) ZONELIST_NOFALLBACK (0xc000000001411a10) (0) (node 0) (DMA 0xc00000000140c000) [NODE (1)] RAM ZONELIST_FALLBACK (0xc000000100001a00) (0) (node 1) (DMA 0xc000000100000000) (1) (node 0) (DMA 0xc00000000140c000) ZONELIST_NOFALLBACK (0xc000000100005a10) (0) (node 1) (DMA 0xc000000100000000) [NODE (2)] CDM ZONELIST_FALLBACK (0xc000000001427700) (0) (node 2) (Movable 0xc000000001427080) (1) (node 0) (DMA 0xc00000000140c000) (2) (node 1) (DMA 0xc000000100000000) ZONELIST_NOFALLBACK (0xc00000000142b710) (0) (node 2) (Movable 0xc000000001427080) [NODE (3)] CDM ZONELIST_FALLBACK (0xc000000001431400) (0) (node 3) (Movable 0xc000000001430d80) (1) (node 0) (DMA 0xc00000000140c000) (2) (node 1) (DMA 0xc000000100000000) ZONELIST_NOFALLBACK (0xc000000001435410) (0) (node 3) (Movable 0xc000000001430d80) [NODE (4)] CDM ZONELIST_FALLBACK (0xc00000000143b100) (0) (node 4) (Movable 0xc00000000143aa80) (1) (node 0) (DMA 0xc00000000140c000) (2) (node 1) (DMA 0xc000000100000000) ZONELIST_NOFALLBACK (0xc00000000143f110) (0) (node 4) (Movable 0xc00000000143aa80)

Signed-off-by: Anshuman Khandual khandual@linux.vnet.ibm.com Signed-off-by: Lijun Fang fanglijun3@huawei.com Reviewed-by: Weilong Chen chenweilong@huawei.com Signed-off-by: Zheng Zengkai zhengzengkai@huawei.com --- mm/page_alloc.c | 10 ++++++++++ 1 file changed, 10 insertions(+)

diff --git a/mm/page_alloc.c b/mm/page_alloc.c index 308b570cdcec..9bf6ce119d6d 100644 --- a/mm/page_alloc.c +++ b/mm/page_alloc.c @@ -5981,6 +5981,16 @@ static void build_zonelists(pg_data_t *pgdat)

memset(node_order, 0, sizeof(node_order)); while ((node = find_next_best_node(local_node, &used_mask)) >= 0) { +#ifdef CONFIG_COHERENT_DEVICE + /* + * CDM node's own zones should not be part of any other + * node's fallback zonelist but only it's own fallback + * zonelist. + */ + if (is_cdm_node(node) && (pgdat->node_id != node)) + continue; +#endif + /* * We don't want to pressure a particular node. * So adding penalty to the first node in same

From: Anshuman Khandual khandual@linux.vnet.ibm.com

ascend inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/I4JMLR CVE: NA -------------------

Mark all the applicable VMAs with VM_CDM explicitly during mbind(MPOL_BIND) call if the user provided nodemask has a CDM node.

Mark the corresponding VMA with VM_CDM flag if the allocated page happens to be from a CDM node. This can be expensive from performance stand point. There are multiple checks to avoid an expensive page_to_nid lookup but it can be optimized further.

Signed-off-by: Anshuman Khandual khandual@linux.vnet.ibm.com Signed-off-by: Lijun Fang fanglijun3@huawei.com Reviewed-by: Weilong Chen chenweilong@huawei.com Signed-off-by: Zheng Zengkai zhengzengkai@huawei.com --- include/linux/mm.h | 5 +++++ mm/mempolicy.c | 41 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 46 insertions(+)

diff --git a/include/linux/mm.h b/include/linux/mm.h index 656f524ba7d3..07ea9972c4a9 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -282,6 +282,11 @@ extern unsigned int kobjsize(const void *objp); #define VM_ACCOUNT 0x00100000 /* Is a VM accounted object */ #define VM_NORESERVE 0x00200000 /* should the VM suppress accounting */ #define VM_HUGETLB 0x00400000 /* Huge TLB Page VM */ + +#ifdef CONFIG_COHERENT_DEVICE +#define VM_CDM 0x00800000 /* Contains coherent device memory */ +#endif + #define VM_SYNC 0x00800000 /* Synchronous page faults */ #define VM_ARCH_1 0x01000000 /* Architecture-specific flag */ #define VM_WIPEONFORK 0x02000000 /* Wipe VMA contents in child. */ diff --git a/mm/mempolicy.c b/mm/mempolicy.c index a4c07466d65f..6b6a5f7ce211 100644 --- a/mm/mempolicy.c +++ b/mm/mempolicy.c @@ -190,6 +190,42 @@ static void mpol_relative_nodemask(nodemask_t *ret, const nodemask_t *orig, nodes_onto(*ret, tmp, *rel); }

+#ifdef CONFIG_COHERENT_DEVICE +static inline void set_vm_cdm(struct vm_area_struct *vma) +{ + vma->vm_flags |= VM_CDM; +} + +static inline void clr_vm_cdm(struct vm_area_struct *vma) +{ + vma->vm_flags &= ~VM_CDM; +} + +static void mark_vma_cdm(nodemask_t *nmask, + struct page *page, struct vm_area_struct *vma) +{ + if (!page || !vma) + return; + + if (vma->vm_flags & VM_CDM) + return; + + if (nmask && !nodemask_has_cdm(*nmask)) + return; + + if (is_cdm_node(page_to_nid(page))) + vma->vm_flags |= VM_CDM; +} +#else +static inline void set_vm_cdm(struct vm_area_struct *vma) { } +static inline void clr_vm_cdm(struct vm_area_struct *vma) { } + +static void mark_vma_cdm(nodemask_t *nmask, + struct page *page, struct vm_area_struct *vma) +{ +} +#endif + static int mpol_new_interleave(struct mempolicy *pol, const nodemask_t *nodes) { if (nodes_empty(*nodes)) @@ -822,6 +858,10 @@ static int mbind_range(struct mm_struct *mm, unsigned long start, vmstart = max(start, vma->vm_start); vmend = min(end, vma->vm_end);

+ if (new_pol && (new_pol->mode == MPOL_BIND) && + nodemask_has_cdm(new_pol->v.nodes)) + set_vm_cdm(vma); + if (mpol_equal(vma_policy(vma), new_pol)) continue;

@@ -2224,6 +2264,7 @@ struct page *alloc_pages_vma(gfp_t gfp, int order, struct vm_area_struct *vma, nmask = policy_nodemask(gfp, pol); preferred_nid = policy_node(gfp, pol, node); page = __alloc_pages(gfp, order, preferred_nid, nmask); + mark_vma_cdm(nmask, page, vma); mpol_cond_put(pol); out: return page;

From: Anshuman Khandual khandual@linux.vnet.ibm.com

ascend inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/I4JMLR CVE: NA -------------------

Kernel cannot track device memory accesses behind VMAs containing CDM memory. Hence all the VM_CDM marked VMAs should not be part of the auto NUMA migration scheme. This patch also adds a new function is_cdm_vma() to detect any VMA marked with flag VM_CDM.

Signed-off-by: Anshuman Khandual khandual@linux.vnet.ibm.com Signed-off-by: Lijun Fang fanglijun3@huawei.com Reviewed-by: Weilong Chen chenweilong@huawei.com Signed-off-by: Zheng Zengkai zhengzengkai@huawei.com --- include/linux/mempolicy.h | 14 ++++++++++++++ kernel/sched/fair.c | 3 ++- 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/include/linux/mempolicy.h b/include/linux/mempolicy.h index 5f1c74df264d..64ab4398ba90 100644 --- a/include/linux/mempolicy.h +++ b/include/linux/mempolicy.h @@ -181,6 +181,20 @@ extern int mpol_parse_str(char *str, struct mempolicy **mpol);

extern void mpol_to_str(char *buffer, int maxlen, struct mempolicy *pol);

+#ifdef CONFIG_COHERENT_DEVICE +static inline bool is_cdm_vma(struct vm_area_struct *vma) +{ + if (vma->vm_flags & VM_CDM) + return true; + return false; +} +#else +static inline bool is_cdm_vma(struct vm_area_struct *vma) +{ + return false; +} +#endif + /* Check if a vma is migratable */ extern bool vma_migratable(struct vm_area_struct *vma);

diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c index 9c34ad6f9a67..1a0cb9a4161e 100644 --- a/kernel/sched/fair.c +++ b/kernel/sched/fair.c @@ -2836,7 +2836,8 @@ static void task_numa_work(struct callback_head *work) } for (; vma; vma = vma->vm_next) { if (!vma_migratable(vma) || !vma_policy_mof(vma) || - is_vm_hugetlb_page(vma) || (vma->vm_flags & VM_MIXEDMAP)) { + is_vm_hugetlb_page(vma) || is_cdm_vma(vma) || + (vma->vm_flags & VM_MIXEDMAP)) { continue; }

From: Anshuman Khandual khandual@linux.vnet.ibm.com

ascend inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/I4JMLR CVE: NA -------------------

__GFP_THISNODE specifically asks the memory to be allocated from the given node. Not all the requests that end up in __alloc_pages_nodemask() are originated from the process context where cpuset makes more sense. The current condition enforces cpuset limitation on every allocation whether originated from process context or not which prevents __GFP_THISNODE mandated allocations to come from the specified node. In context of the coherent device memory node which is isolated from all cpuset nodemask in the system, it prevents the only way of allocation into it which has been changed with this patch.

Signed-off-by: Anshuman Khandual khandual@linux.vnet.ibm.com Signed-off-by: Lijun Fang fanglijun3@huawei.com Reviewed-by: Weilong Chen chenweilong@huawei.com Signed-off-by: Zheng Zengkai zhengzengkai@huawei.com --- mm/page_alloc.c | 4 ++++ 1 file changed, 4 insertions(+)

diff --git a/mm/page_alloc.c b/mm/page_alloc.c index 9ffa2badb706..4bfb52cb677f 100644 --- a/mm/page_alloc.c +++ b/mm/page_alloc.c @@ -4896,7 +4896,11 @@ static inline bool prepare_alloc_pages(gfp_t gfp_mask, unsigned int order, ac->nodemask = nodemask; ac->migratetype = gfp_migratetype(gfp_mask);

+#ifdef CONFIG_COHERENT_DEVICE + if (cpusets_enabled() && !(*alloc_gfp & __GFP_THISNODE)) { +#else if (cpusets_enabled()) { +#endif *alloc_gfp |= __GFP_HARDWALL; /* * When we are in the interrupt context, it is irrelevant

From: Lijun Fang fanglijun3@huawei.com

ascend inclusion category: feature bugzilla: https://gitee.com/openeuler/kernel/issues/I4JMLR CVE: NA ---------------------

When the kernel boot, we need to determine DDR or HBM, and add them to nodes by parse cmdline, instead of memory hotplug.

Signed-off-by: Lijun Fang fanglijun3@huawei.com Reviewed-by: Weilong Chen chenweilong@huawei.com Signed-off-by: Zheng Zengkai zhengzengkai@huawei.com --- .../admin-guide/kernel-parameters.txt | 6 ++++++ arch/arm64/include/asm/numa.h | 3 +++ arch/arm64/mm/numa.c | 20 +++++++++++++++++++ 3 files changed, 29 insertions(+)

diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt index 8eca743da732..d4b9d4a05b7d 100644 --- a/Documentation/admin-guide/kernel-parameters.txt +++ b/Documentation/admin-guide/kernel-parameters.txt @@ -493,6 +493,12 @@ ccw_timeout_log [S390] See Documentation/s390/common_io.rst for details.

+ cdm-nodes= [KNL] + Format: hexadecimal expression + One bit express one node, if the node is HBM, set the + bit to 1. Then transform Binary to hexadecimal. + Example: node1, node2 is HBM, cdm-nodes=0x06. + cgroup_disable= [KNL] Disable a particular controller Format: {name of the controller(s) to disable} The effects of cgroup_disable=foo are: diff --git a/arch/arm64/include/asm/numa.h b/arch/arm64/include/asm/numa.h index e0c51519e71b..43bfff72a32f 100644 --- a/arch/arm64/include/asm/numa.h +++ b/arch/arm64/include/asm/numa.h @@ -19,6 +19,9 @@ extern bool numa_off; extern cpumask_var_t node_to_cpumask_map[MAX_NUMNODES]; void numa_clear_node(unsigned int cpu);

+#ifdef CONFIG_COHERENT_DEVICE +extern nodemask_t cdmmask; +#endif #ifdef CONFIG_DEBUG_PER_CPU_MAPS const struct cpumask *cpumask_of_node(int node); #else diff --git a/arch/arm64/mm/numa.c b/arch/arm64/mm/numa.c index dae7179ba609..b2260bb53691 100644 --- a/arch/arm64/mm/numa.c +++ b/arch/arm64/mm/numa.c @@ -26,10 +26,30 @@ static u8 *numa_distance; bool numa_off;

#ifdef CONFIG_COHERENT_DEVICE +nodemask_t cdmmask; + inline int arch_check_node_cdm(int nid) { + return node_isset(nid, cdmmask); +} + +static int __init cdm_nodes_setup(char *s) +{ + int nid; + unsigned long tmpmask; + int err; + + err = kstrtoul(s, 0, &tmpmask); + if (err) + return err; + + for (nid = 0; nid < MAX_NUMNODES; nid++) { + if ((tmpmask >> nid) & 1) + node_set(nid, cdmmask); + } return 0; } +early_param("cdm-nodes", cdm_nodes_setup); #endif

static __init int numa_parse_early_param(char *opt)

From: Lijun Fang fanglijun3@huawei.com

ascend inclusion category: bugfix bugzilla: https://gitee.com/openeuler/kernel/issues/I4JMLR CVE: NA -------------------

enable CONFIG_COHERENT_DEVICE in openeuler_defconfig

Signed-off-by: Lijun Fang fanglijun3@huawei.com Reviewed-by: Weilong Chen chenweilong@huawei.com Signed-off-by: Zheng Zengkai zhengzengkai@huawei.com --- arch/arm64/configs/openeuler_defconfig | 1 + 1 file changed, 1 insertion(+)

diff --git a/arch/arm64/configs/openeuler_defconfig b/arch/arm64/configs/openeuler_defconfig index fe7123dd102a..f23a30a6fb01 100644 --- a/arch/arm64/configs/openeuler_defconfig +++ b/arch/arm64/configs/openeuler_defconfig @@ -988,6 +988,7 @@ CONFIG_HAVE_FAST_GUP=y CONFIG_ARCH_KEEP_MEMBLOCK=y CONFIG_NUMA_KEEP_MEMINFO=y CONFIG_MEMORY_ISOLATION=y +CONFIG_COHERENT_DEVICE=y CONFIG_MEMORY_HOTPLUG=y CONFIG_MEMORY_HOTPLUG_SPARSE=y CONFIG_MEMORY_HOTPLUG_DEFAULT_ONLINE=y

From: Cheng Jian cj.chengjian@huawei.com

hulk inclusion category: bugfix bugzilla: 34546, https://gitee.com/openeuler/kernel/issues/I4JKT1 CVE: NA

-----------------------------------------------

A deadlock caused by logbuf_lock occurs when panic:

a) Panic CPU is running in non-NMI context b) Panic CPU sends out shutdown IPI via NMI vector c) One of the CPUs that we bring down via NMI vector holded logbuf_lock d) Panic CPU try to hold logbuf_lock, then deadlock occurs.

we try to re-init the logbuf_lock in printk_safe_flush_on_panic() to avoid deadlock, but it does not work here, because :

Firstly, it is inappropriate to check num_online_cpus() here. When the CPU bring down via NMI vector, the panic CPU willn't wait too long for other cores to stop, so when this problem occurs, num_online_cpus() may be greater than 1.

Secondly, printk_safe_flush_on_panic() is called after panic notifier callback, so if printk() is called in panic notifier callback, deadlock will still occurs. Eg, if ftrace_dump_on_oops is set, we print some debug information, it will try to hold the logbuf_lock.

To avoid this deadlock, attempt to re-init logbuf_lock from panic CPU before panic_notifier_list callback,

Signed-off-by: Cheng Jian cj.chengjian@huawei.com Reviewed-by: Xie XiuQi xiexiuqi@huawei.com Signed-off-by: Chen Zhou chenzhou10@huawei.com Signed-off-by: Cheng Jian cj.chengjian@huawei.com Reviewed-by: Xie XiuQi xiexiuqi@huawei.com Signed-off-by: Zheng Zengkai zhengzengkai@huawei.com --- include/linux/printk.h | 5 +++++ kernel/panic.c | 2 ++ kernel/printk/printk.c | 17 +++++++++++++++++ 3 files changed, 24 insertions(+)

diff --git a/include/linux/printk.h b/include/linux/printk.h index fe7eb2351610..de1457e3af3f 100644 --- a/include/linux/printk.h +++ b/include/linux/printk.h @@ -209,6 +209,7 @@ void show_regs_print_info(const char *log_lvl); extern asmlinkage void dump_stack(void) __cold; extern void printk_safe_flush(void); extern void printk_safe_flush_on_panic(void); +extern void zap_locks(void); #else static inline __printf(1, 0) int vprintk(const char *s, va_list args) @@ -280,6 +281,10 @@ static inline void printk_safe_flush(void) static inline void printk_safe_flush_on_panic(void) { } + +static inline void zap_locks(void) +{ +} #endif

extern int kptr_restrict; diff --git a/kernel/panic.c b/kernel/panic.c index 332736a72a58..75f07bb57006 100644 --- a/kernel/panic.c +++ b/kernel/panic.c @@ -265,6 +265,8 @@ void panic(const char *fmt, ...) crash_smp_send_stop(); }

+ zap_locks(); + /* * Run any panic handlers, including those that might need to * add information to the kmsg dump output. diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c index d0df95346ab3..a504ff599d69 100644 --- a/kernel/printk/printk.c +++ b/kernel/printk/printk.c @@ -1742,6 +1742,23 @@ static DEFINE_RAW_SPINLOCK(console_owner_lock); static struct task_struct *console_owner; static bool console_waiter;

+void zap_locks(void) +{ + if (raw_spin_is_locked(&logbuf_lock)) { + debug_locks_off(); + raw_spin_lock_init(&logbuf_lock); + + console_suspended = 1; + sema_init(&console_sem, 1); + } + + if (raw_spin_is_locked(&console_owner_lock)) { + raw_spin_lock_init(&console_owner_lock); + console_owner = NULL; + console_waiter = false; + } +} + /** * console_lock_spinning_enable - mark beginning of code where another * thread might safely busy wait

From: Chen Zhou chenzhou10@huawei.com

hulk inclusion category: bugfix bugzilla: 41832, https://gitee.com/openeuler/kernel/issues/I4JKT1 CVE: NA

-----------------------------------------------

When one cpu panic, the panic cpu send NMI to other cpus, if one of the non-panic cpus is in printk() and get stopped before release console_waiter, the panic cpu may spin waiting.

Here just release console_waiter directly after all non-panic cpus get stopped.

Signed-off-by: Chen Zhou chenzhou10@huawei.com Reviewed-by: Jian Cheng cj.chengjian@huawei.com Reviewed-by: Xie XiuQi xiexiuqi@huawei.com Signed-off-by: Chen Zhou chenzhou10@huawei.com Signed-off-by: Cheng Jian cj.chengjian@huawei.com Reviewed-by: Xie XiuQi xiexiuqi@huawei.com Signed-off-by: Zheng Zengkai zhengzengkai@huawei.com --- kernel/printk/printk.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c index bf58d5777bce..e4328bc341f3 100644 --- a/kernel/printk/printk.c +++ b/kernel/printk/printk.c @@ -1751,9 +1751,10 @@ void zap_locks(void)

if (raw_spin_is_locked(&console_owner_lock)) { raw_spin_lock_init(&console_owner_lock); - console_owner = NULL; - console_waiter = false; } + + console_owner = NULL; + console_waiter = false; }

/**

From: Cheng Jian cj.chengjian@huawei.com

hulk inclusion category: bugfix bugzilla: 34546, https://gitee.com/openeuler/kernel/issues/I4JKT1 CVE: NA

----------------------------------------

Any architecture that involves an NMI should be treated with caution. For example, the X86 architecture and ARM64 enabled PSEUDO NMI.

Signed-off-by: Cheng Jian cj.chengjian@huawei.com Reviewed-by: Xie XiuQi xiexiuqi@huawei.com Signed-off-by: Zheng Zengkai zhengzengkai@huawei.com --- include/linux/printk.h | 4 ++++ kernel/panic.c | 2 +- kernel/printk/printk.c | 2 ++ 3 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/include/linux/printk.h b/include/linux/printk.h index de1457e3af3f..e6a8ee6db68e 100644 --- a/include/linux/printk.h +++ b/include/linux/printk.h @@ -209,8 +209,12 @@ void show_regs_print_info(const char *log_lvl); extern asmlinkage void dump_stack(void) __cold; extern void printk_safe_flush(void); extern void printk_safe_flush_on_panic(void); +#if defined(CONFIG_X86) || defined(CONFIG_ARM64_PSEUDO_NMI) extern void zap_locks(void); #else +static inline void zap_locks(void) { } +#endif +#else static inline __printf(1, 0) int vprintk(const char *s, va_list args) { diff --git a/kernel/panic.c b/kernel/panic.c index 3d75855db4e6..d991c3b1b559 100644 --- a/kernel/panic.c +++ b/kernel/panic.c @@ -265,6 +265,7 @@ void panic(const char *fmt, ...) crash_smp_send_stop(); }

+#if defined(CONFIG_X86) || defined(CONFIG_ARM64_PSEUDO_NMI) /* * ZAP console related locks when nmi broadcast. If a crash is occurring, * make sure we can't deadlock. And make sure that we print immediately. @@ -288,7 +289,6 @@ void panic(const char *fmt, ...) * have a chance to see the messages. Others prefer to always * reach emergency_restart() and reboot the machine. */ -#ifdef CONFIG_X86 zap_locks(); #endif

diff --git a/kernel/printk/printk.c b/kernel/printk/printk.c index 69a1be81dd98..729e4ce2decb 100644 --- a/kernel/printk/printk.c +++ b/kernel/printk/printk.c @@ -1742,6 +1742,7 @@ static DEFINE_RAW_SPINLOCK(console_owner_lock); static struct task_struct *console_owner; static bool console_waiter;

+#if defined(CONFIG_X86) || defined(CONFIG_ARM64_PSEUDO_NMI) void zap_locks(void) { if (raw_spin_is_locked(&logbuf_lock)) { @@ -1758,6 +1759,7 @@ void zap_locks(void)

sema_init(&console_sem, 1); } +#endif

/** * console_lock_spinning_enable - mark beginning of code where another