Merge tag 'mm-hotfixes-stable-2022-06-26' of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm

Pull hotfixes from Andrew Morton: "Minor things, mainly - mailmap updates, MAINTAINERS updates, etc. Fixes for this merge window: - fix for a damon boot hang, from SeongJae - fix for a kfence warning splat, from Jason Donenfeld - fix for zero-pfn pinning, from Alex Williamson - fix for fallocate hole punch clearing, from Mike Kravetz Fixes for previous releases: - fix for a performance regression, from Marcelo - fix for a hwpoisining BUG from zhenwei pi" * tag 'mm-hotfixes-stable-2022-06-26' of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm: mailmap: add entry for Christian Marangi mm/memory-failure: disable unpoison once hw error happens hugetlbfs: zero partial pages during fallocate hole punch mm: memcontrol: reference to tools/cgroup/memcg_slabinfo.py mm: re-allow pinning of zero pfns mm/kfence: select random number before taking raw lock MAINTAINERS: add maillist information for LoongArch MAINTAINERS: update MM tree references MAINTAINERS: update Abel Vesa's email MAINTAINERS: add MEMORY HOT(UN)PLUG section and add David as reviewer MAINTAINERS: add Miaohe Lin as a memory-failure reviewer mailmap: add alias for jarkko@profian.com mm/damon/reclaim: schedule 'damon_reclaim_timer' only after 'system_wq' is initialized kthread: make it clear that kthread_create_on_node() might be terminated by any fatal signal mm: lru_cache_disable: use synchronize_rcu_expedited mm/page_isolation.c: fix one kernel-doc comment

Linus Torvalds committed 4 years ago

Commit 413c1f12 parents 893d1ea e67679c15 files · +117 −35Browse files

Unified · Split

15 files

.mailmap +4 −0
Documentation/vm/hwpoison.rst +2 −1
MAINTAINERS +17 −4
drivers/base/memory.c +1 −1
fs/hugetlbfs/inode.c +53 −15
include/linux/mm.h +2 −1
kernel/kthread.c +7 −7
mm/damon/reclaim.c +8 −0
mm/hwpoison-inject.c +1 −1
mm/kfence/core.c +5 −2
mm/madvise.c +1 −1
mm/memcontrol.c +1 −1
mm/memory-failure.c +12 −0
mm/page_isolation.c +2 −0
mm/swap.c +1 −1

.mailmap+4−0

 # Please keep this list dictionary sorted.
 #
 Aaron Durbin <adurbin@google.com>
+Abel Vesa <abelvesa@kernel.org> <abel.vesa@nxp.com>
+Abel Vesa <abelvesa@kernel.org> <abelvesa@gmail.com>
 Abhinav Kumar <quic_abhinavk@quicinc.com> <abhinavk@codeaurora.org>
 Adam Oldham <oldhamca@gmail.com>
 Adam Radford <aradford@gmail.com>
 Christian Brauner <brauner@kernel.org> <christian@brauner.io>
 Christian Brauner <brauner@kernel.org> <christian.brauner@canonical.com>
 Christian Brauner <brauner@kernel.org> <christian.brauner@ubuntu.com>
+Christian Marangi <ansuelsmth@gmail.com>
 Christophe Ricard <christophe.ricard@gmail.com>
 Christoph Hellwig <hch@lst.de>
 Colin Ian King <colin.king@intel.com> <colin.king@canonical.com>
 Jan Glauber <jan.glauber@gmail.com> <jang@linux.vnet.ibm.com>
 Jan Glauber <jan.glauber@gmail.com> <jglauber@cavium.com>
 Jarkko Sakkinen <jarkko@kernel.org> <jarkko.sakkinen@linux.intel.com>
+Jarkko Sakkinen <jarkko@kernel.org> <jarkko@profian.com>
 Jason Gunthorpe <jgg@ziepe.ca> <jgg@mellanox.com>
 Jason Gunthorpe <jgg@ziepe.ca> <jgg@nvidia.com>
 Jason Gunthorpe <jgg@ziepe.ca> <jgunthorpe@obsidianresearch.com>

Documentation/vm/hwpoison.rst+2−1

@@ -120,7 +120,8 @@ Testing · 119 unmodified lines
120	unpoison-pfn	120	unpoison-pfn
121	Software-unpoison page at PFN echoed into this file. This way	121	Software-unpoison page at PFN echoed into this file. This way
122	a page can be reused again. This only works for Linux	122	a page can be reused again. This only works for Linux
123	injected failures, not for real memory failures.	123	injected failures, not for real memory failures. Once any hardware
		124	memory failure happens, this feature is disabled.
124		125
125	Note these injection interfaces are not stable and might change between	126	Note these injection interfaces are not stable and might change between
126	kernel versions	127	kernel versions

MAINTAINERS+17−4

 HWPOISON MEMORY FAILURE HANDLING
 M:	Naoya Horiguchi <naoya.horiguchi@nec.com>
+R:	Miaohe Lin <linmiaohe@huawei.com>
 L:	linux-mm@kvack.org
 S:	Maintained
 F:	mm/hwpoison-inject.c
 LOONGARCH
 M:	Huacai Chen <chenhuacai@kernel.org>
 R:	WANG Xuerui <kernel@xen0n.name>
+L:	loongarch@lists.linux.dev
 S:	Maintained
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/chenhuacai/linux-loongson.git
 F:	arch/loongarch/
 L:	linux-mm@kvack.org
 S:	Maintained
 W:	http://www.linux-mm.org
-T:	quilt https://ozlabs.org/~akpm/mmotm/
+T:	git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm
-T:	quilt https://ozlabs.org/~akpm/mmots/
+T:	quilt git://git.kernel.org/pub/scm/linux/kernel/git/akpm/25-new
-T:	git git://github.com/hnaz/linux-mm.git
 F:	include/linux/gfp.h
 F:	include/linux/memory_hotplug.h
 F:	include/linux/mm.h
 F:	mm/
 F:	tools/testing/selftests/vm/
+MEMORY HOT(UN)PLUG
+M:	David Hildenbrand <david@redhat.com>
+M:	Oscar Salvador <osalvador@suse.de>
+L:	linux-mm@kvack.org
+S:	Maintained
+F:	Documentation/admin-guide/mm/memory-hotplug.rst
+F:	Documentation/core-api/memory-hotplug.rst
+F:	drivers/base/memory.c
+F:	include/linux/memory_hotplug.h
+F:	mm/memory_hotplug.c
+F:	tools/testing/selftests/memory-hotplug/
 MEMORY TECHNOLOGY DEVICES (MTD)
 M:	Miquel Raynal <miquel.raynal@bootlin.com>
 M:	Richard Weinberger <richard@nod.at>
 F:	drivers/iio/gyro/fxas21002c_spi.c
 NXP i.MX CLOCK DRIVERS
-M:	Abel Vesa <abel.vesa@nxp.com>
+M:	Abel Vesa <abelvesa@kernel.org>
 L:	linux-clk@vger.kernel.org
 L:	linux-imx@nxp.com
 S:	Maintained

drivers/base/memory.c+1−1

@@ -558,7 +558,7 @@ static ssize_t hard_offline_page_store(struct device *dev, · 557 unmodified lines
558	if (kstrtoull(buf, 0, &pfn) < 0)	558	if (kstrtoull(buf, 0, &pfn) < 0)
559	return -EINVAL;	559	return -EINVAL;
560	pfn >>= PAGE_SHIFT;	560	pfn >>= PAGE_SHIFT;
561	ret = memory_failure(pfn, 0);	561	ret = memory_failure(pfn, MF_SW_SIMULATED);
562	if (ret == -EOPNOTSUPP)	562	if (ret == -EOPNOTSUPP)
563	ret = 0;	563	ret = 0;
564	return ret ? ret : count;	564	return ret ? ret : count;

fs/hugetlbfs/inode.c+53−15

@@ -600,41 +600,79 @@ static void hugetlb_vmtruncate(struct inode *inode, loff_t offset) · 599 unmodified lines
600	remove_inode_hugepages(inode, offset, LLONG_MAX);	600	remove_inode_hugepages(inode, offset, LLONG_MAX);
601	}	601	}
602		602
		603	static void hugetlbfs_zero_partial_page(struct hstate *h,
		604	struct address_space *mapping,
		605	loff_t start,
		606	loff_t end)
		607	{
		608	pgoff_t idx = start >> huge_page_shift(h);
		609	struct folio *folio;
		610
		611	folio = filemap_lock_folio(mapping, idx);
		612	if (!folio)
		613	return;
		614
		615	start = start & ~huge_page_mask(h);
		616	end = end & ~huge_page_mask(h);
		617	if (!end)
		618	end = huge_page_size(h);
		619
		620	folio_zero_segment(folio, (size_t)start, (size_t)end);
		621
		622	folio_unlock(folio);
		623	folio_put(folio);
		624	}
		625
603	static long hugetlbfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)	626	static long hugetlbfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
604	{	627	{
		628	struct hugetlbfs_inode_info *info = HUGETLBFS_I(inode);
		629	struct address_space *mapping = inode->i_mapping;
605	struct hstate *h = hstate_inode(inode);	630	struct hstate *h = hstate_inode(inode);
606	loff_t hpage_size = huge_page_size(h);	631	loff_t hpage_size = huge_page_size(h);
607	loff_t hole_start, hole_end;	632	loff_t hole_start, hole_end;
608		633
609	/*	634	/*
610	* For hole punch round up the beginning offset of the hole and	635	* hole_start and hole_end indicate the full pages within the hole.
611	* round down the end.
612	*/	636	*/
613	hole_start = round_up(offset, hpage_size);	637	hole_start = round_up(offset, hpage_size);
614	hole_end = round_down(offset + len, hpage_size);	638	hole_end = round_down(offset + len, hpage_size);
615		639
616	if (hole_end > hole_start) {	640	inode_lock(inode);
617	struct address_space *mapping = inode->i_mapping;
618	struct hugetlbfs_inode_info *info = HUGETLBFS_I(inode);
619		641
620	inode_lock(inode);	642	/* protected by i_rwsem */
		643	if (info->seals & (F_SEAL_WRITE \| F_SEAL_FUTURE_WRITE)) {
		644	inode_unlock(inode);
		645	return -EPERM;
		646	}
621		647
622	/* protected by i_rwsem */	648	i_mmap_lock_write(mapping);
623	if (info->seals & (F_SEAL_WRITE \| F_SEAL_FUTURE_WRITE)) {	649
624	inode_unlock(inode);	650	/* If range starts before first full page, zero partial page. */
625	return -EPERM;	651	if (offset < hole_start)
626	}	652	hugetlbfs_zero_partial_page(h, mapping,
		653	offset, min(offset + len, hole_start));
627		654
628	i_mmap_lock_write(mapping);	655	/* Unmap users of full pages in the hole. */
		656	if (hole_end > hole_start) {
629	if (!RB_EMPTY_ROOT(&mapping->i_mmap.rb_root))	657	if (!RB_EMPTY_ROOT(&mapping->i_mmap.rb_root))
630	hugetlb_vmdelete_list(&mapping->i_mmap,	658	hugetlb_vmdelete_list(&mapping->i_mmap,
631	hole_start >> PAGE_SHIFT,	659	hole_start >> PAGE_SHIFT,
632	hole_end >> PAGE_SHIFT, 0);	660	hole_end >> PAGE_SHIFT, 0);
633	i_mmap_unlock_write(mapping);
634	remove_inode_hugepages(inode, hole_start, hole_end);
635	inode_unlock(inode);
636	}	661	}
637		662
		663	/* If range extends beyond last full page, zero partial page. */
		664	if ((offset + len) > hole_end && (offset + len) > hole_start)
		665	hugetlbfs_zero_partial_page(h, mapping,
		666	hole_end, offset + len);
		667
		668	i_mmap_unlock_write(mapping);
		669
		670	/* Remove full pages from the file. */
		671	if (hole_end > hole_start)
		672	remove_inode_hugepages(inode, hole_start, hole_end);
		673
		674	inode_unlock(inode);
		675
638	return 0;	676	return 0;
639	}	677	}
640		678

include/linux/mm.h+2−1

 	if (mt == MIGRATE_CMA || mt == MIGRATE_ISOLATE)
 		return false;
 #endif
-	return !(is_zone_movable_page(page) || is_zero_pfn(page_to_pfn(page)));
+	return !is_zone_movable_page(page) || is_zero_pfn(page_to_pfn(page));
 }
 #else
 static inline bool is_pinnable_page(struct page *page)
 	MF_MUST_KILL = 1 << 2,
 	MF_SOFT_OFFLINE = 1 << 3,
 	MF_UNPOISON = 1 << 4,
+	MF_SW_SIMULATED = 1 << 5,
 };
 extern int memory_failure(unsigned long pfn, int flags);
 extern void memory_failure_queue(unsigned long pfn, int flags);

kernel/kthread.c+7−7

@@ -340,7 +340,7 @@ static int kthread(void *_create) · 339 unmodified lines
340		340
341	self = to_kthread(current);	341	self = to_kthread(current);
342		342
343	/* If user was SIGKILLed, I release the structure. */	343	/* Release the structure when caller killed by a fatal signal. */
344	done = xchg(&create->done, NULL);	344	done = xchg(&create->done, NULL);
345	if (!done) {	345	if (!done) {
346	kfree(create);	346	kfree(create);
@@ -398,7 +398,7 @@ static void create_kthread(struct kthread_create_info *create) · 51 unmodified lines
398	/* We want our own signal handler (we take no signals by default). */	398	/* We want our own signal handler (we take no signals by default). */
399	pid = kernel_thread(kthread, create, CLONE_FS \| CLONE_FILES \| SIGCHLD);	399	pid = kernel_thread(kthread, create, CLONE_FS \| CLONE_FILES \| SIGCHLD);
400	if (pid < 0) {	400	if (pid < 0) {
401	/* If user was SIGKILLed, I release the structure. */	401	/* Release the structure when caller killed by a fatal signal. */
402	struct completion *done = xchg(&create->done, NULL);	402	struct completion *done = xchg(&create->done, NULL);
403		403
404	if (!done) {	404	if (!done) {
@@ -440,9 +440,9 @@ struct task_struct __kthread_create_on_node(int (threadfn)(void *data), · 35 unmodified lines
440	*/	440	*/
441	if (unlikely(wait_for_completion_killable(&done))) {	441	if (unlikely(wait_for_completion_killable(&done))) {
442	/*	442	/*
443	* If I was SIGKILLed before kthreadd (or new kernel thread)	443	* If I was killed by a fatal signal before kthreadd (or new
444	* calls complete(), leave the cleanup of this structure to	444	* kernel thread) calls complete(), leave the cleanup of this
445	* that thread.	445	* structure to that thread.
446	*/	446	*/
447	if (xchg(&create->done, NULL))	447	if (xchg(&create->done, NULL))
448	return ERR_PTR(-EINTR);	448	return ERR_PTR(-EINTR);
@@ -876,7 +876,7 @@ fail_task: · 427 unmodified lines
876	*	876	*
877	* Returns a pointer to the allocated worker on success, ERR_PTR(-ENOMEM)	877	* Returns a pointer to the allocated worker on success, ERR_PTR(-ENOMEM)
878	* when the needed structures could not get allocated, and ERR_PTR(-EINTR)	878	* when the needed structures could not get allocated, and ERR_PTR(-EINTR)
879	* when the worker was SIGKILLed.	879	* when the caller was killed by a fatal signal.
880	*/	880	*/
881	struct kthread_worker *	881	struct kthread_worker *
882	kthread_create_worker(unsigned int flags, const char namefmt[], ...)	882	kthread_create_worker(unsigned int flags, const char namefmt[], ...)
@@ -925,7 +925,7 @@ EXPORT_SYMBOL(kthread_create_worker); · 42 unmodified lines
925	* Return:	925	* Return:
926	* The pointer to the allocated worker on success, ERR_PTR(-ENOMEM)	926	* The pointer to the allocated worker on success, ERR_PTR(-ENOMEM)
927	* when the needed structures could not get allocated, and ERR_PTR(-EINTR)	927	* when the needed structures could not get allocated, and ERR_PTR(-EINTR)
928	* when the worker was SIGKILLed.	928	* when the caller was killed by a fatal signal.
929	*/	929	*/
930	struct kthread_worker *	930	struct kthread_worker *
931	kthread_create_worker_on_cpu(int cpu, unsigned int flags,	931	kthread_create_worker_on_cpu(int cpu, unsigned int flags,

mm/damon/reclaim.c+8−0

 }
 static DECLARE_DELAYED_WORK(damon_reclaim_timer, damon_reclaim_timer_fn);
+static bool damon_reclaim_initialized;
 static int enabled_store(const char *val,
 		const struct kernel_param *kp)
 {
 	if (rc < 0)
 		return rc;
+	/* system_wq might not initialized yet */
+	if (!damon_reclaim_initialized)
+		return rc;
 	if (enabled)
 		schedule_delayed_work(&damon_reclaim_timer, 0);
 	damon_add_target(ctx, target);
 	schedule_delayed_work(&damon_reclaim_timer, 0);
+	damon_reclaim_initialized = true;
 	return 0;
 }

mm/hwpoison-inject.c+1−1

@@ -48,7 +48,7 @@ static int hwpoison_inject(void *data, u64 val) · 47 unmodified lines
48		48
49	inject:	49	inject:
50	pr_info("Injecting memory failure at pfn %#lx\n", pfn);	50	pr_info("Injecting memory failure at pfn %#lx\n", pfn);
51	err = memory_failure(pfn, 0);	51	err = memory_failure(pfn, MF_SW_SIMULATED);
52	return (err == -EOPNOTSUPP) ? 0 : err;	52	return (err == -EOPNOTSUPP) ? 0 : err;
53	}	53	}
54		54

mm/kfence/core.c+5−2

 	unsigned long flags;
 	struct slab *slab;
 	void *addr;
+	const bool random_right_allocate = prandom_u32_max(2);
+	const bool random_fault = CONFIG_KFENCE_STRESS_TEST_FAULTS &&
+				  !prandom_u32_max(CONFIG_KFENCE_STRESS_TEST_FAULTS);
 	/* Try to obtain a free object. */
 	raw_spin_lock_irqsave(&kfence_freelist_lock, flags);
 	 * is that the out-of-bounds accesses detected are deterministic for
 	 * such allocations.
 	 */
-	if (prandom_u32_max(2)) {
+	if (random_right_allocate) {
 		/* Allocate on the "right" side, re-calculate address. */
 		meta->addr += PAGE_SIZE - size;
 		meta->addr = ALIGN_DOWN(meta->addr, cache->align);
 	if (cache->ctor)
 		cache->ctor(addr);
-	if (CONFIG_KFENCE_STRESS_TEST_FAULTS && !prandom_u32_max(CONFIG_KFENCE_STRESS_TEST_FAULTS))
+	if (random_fault)
 		kfence_protect(meta->addr); /* Random "faults" by protecting the object. */
 	atomic_long_inc(&counters[KFENCE_COUNTER_ALLOCATED]);

mm/madvise.c+1−1

@@ -1112,7 +1112,7 @@ static int madvise_inject_error(int behavior, · 1111 unmodified lines
1112	} else {	1112	} else {
1113	pr_info("Injecting memory failure for pfn %#lx at process virtual address %#lx\n",	1113	pr_info("Injecting memory failure for pfn %#lx at process virtual address %#lx\n",
1114	pfn, start);	1114	pfn, start);
1115	ret = memory_failure(pfn, MF_COUNT_INCREASED);	1115	ret = memory_failure(pfn, MF_COUNT_INCREASED \| MF_SW_SIMULATED);
1116	if (ret == -EOPNOTSUPP)	1116	if (ret == -EOPNOTSUPP)
1117	ret = 0;	1117	ret = 0;
1118	}	1118	}

mm/memcontrol.c+1−1

@@ -4859,7 +4859,7 @@ static int mem_cgroup_slab_show(struct seq_file m, void p) · 4858 unmodified lines
4859	{	4859	{
4860	/*	4860	/*
4861	* Deprecated.	4861	* Deprecated.
4862	* Please, take a look at tools/cgroup/slabinfo.py .	4862	* Please, take a look at tools/cgroup/memcg_slabinfo.py .
4863	*/	4863	*/
4864	return 0;	4864	return 0;
4865	}	4865	}

mm/memory-failure.c+12−0

 atomic_long_t num_poisoned_pages __read_mostly = ATOMIC_LONG_INIT(0);
+static bool hw_memory_failure __read_mostly = false;
 static bool __page_handle_poison(struct page *page)
 {
 	int ret;
 	mutex_lock(&mf_mutex);
+	if (!(flags & MF_SW_SIMULATED))
+		hw_memory_failure = true;
 	p = pfn_to_online_page(pfn);
 	if (!p) {
 		res = arch_memory_failure(pfn, flags);
 	mutex_lock(&mf_mutex);
+	if (hw_memory_failure) {
+		unpoison_pr_info("Unpoison: Disabled after HW memory failure %#lx\n",
+				 pfn, &unpoison_rs);
+		ret = -EOPNOTSUPP;
+		goto unlock_mutex;
+	}
 	if (!PageHWPoison(p)) {
 		unpoison_pr_info("Unpoison: Page was already unpoisoned %#lx\n",
 				 pfn, &unpoison_rs);

mm/page_isolation.c+2−0

  * @flags:			isolation flags
  * @gfp_flags:			GFP flags used for migrating pages
  * @isolate_before:	isolate the pageblock before the boundary_pfn
+ * @skip_isolation:	the flag to skip the pageblock isolation in second
+ *			isolate_single_pageblock()
  *
  * Free and in-use pages can be as big as MAX_ORDER-1 and contain more than one
  * pageblock. When not all pageblocks within a page are isolated at the same

mm/swap.c+1−1

@@ -881,7 +881,7 @@ void lru_cache_disable(void) · 880 unmodified lines
881	* lru_disable_count = 0 will have exited the critical	881	* lru_disable_count = 0 will have exited the critical
882	* section when synchronize_rcu() returns.	882	* section when synchronize_rcu() returns.
883	*/	883	*/
884	synchronize_rcu();	884	synchronize_rcu_expedited();
885	#ifdef CONFIG_SMP	885	#ifdef CONFIG_SMP
886	__lru_add_drain_all(true);	886	__lru_add_drain_all(true);
887	#else	887	#else

Merge tag 'mm-hotfixes-stable-2022-06-26' of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code