[linux-2.6-block.git] / mm / hwpoison-inject.c

// SPDX-License-Identifier: GPL-2.0-only
/* Inject a hwpoison memory failure on a arbitrary pfn */
#include <linux/module.h>
#include <linux/debugfs.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/swap.h>
#include <linux/pagemap.h>
#include <linux/hugetlb.h>
#include "internal.h"

static struct dentry *hwpoison_dir;

static int hwpoison_inject(void *data, u64 val)
{
	unsigned long pfn = val;
	struct page *p;
	struct folio *folio;
	int err;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	if (!pfn_valid(pfn))
		return -ENXIO;

	p = pfn_to_page(pfn);
	folio = page_folio(p);

	if (!hwpoison_filter_enable)
		goto inject;

	shake_folio(folio);
	/*
	 * This implies unable to support non-LRU pages except free page.
	 */
	if (!folio_test_lru(folio) && !folio_test_hugetlb(folio) &&
	    !is_free_buddy_page(p))
		return 0;

	/*
	 * do a racy check to make sure PG_hwpoison will only be set for
	 * the targeted owner (or on a free page).
	 * memory_failure() will redo the check reliably inside page lock.
	 */
	err = hwpoison_filter(&folio->page);
	if (err)
		return 0;

inject:
	pr_info("Injecting memory failure at pfn %#lx\n", pfn);
	err = memory_failure(pfn, MF_SW_SIMULATED);
	return (err == -EOPNOTSUPP) ? 0 : err;
}

static int hwpoison_unpoison(void *data, u64 val)
{
	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	return unpoison_memory(val);
}

DEFINE_DEBUGFS_ATTRIBUTE(hwpoison_fops, NULL, hwpoison_inject, "%lli\n");
DEFINE_DEBUGFS_ATTRIBUTE(unpoison_fops, NULL, hwpoison_unpoison, "%lli\n");

static void __exit pfn_inject_exit(void)
{
	hwpoison_filter_enable = 0;
	debugfs_remove_recursive(hwpoison_dir);
}

static int __init pfn_inject_init(void)
{
	hwpoison_dir = debugfs_create_dir("hwpoison", NULL);

	/*
	 * Note that the below poison/unpoison interfaces do not involve
	 * hardware status change, hence do not require hardware support.
	 * They are mainly for testing hwpoison in software level.
	 */
	debugfs_create_file("corrupt-pfn", 0200, hwpoison_dir, NULL,
			    &hwpoison_fops);

	debugfs_create_file("unpoison-pfn", 0200, hwpoison_dir, NULL,
			    &unpoison_fops);

	debugfs_create_u32("corrupt-filter-enable", 0600, hwpoison_dir,
			   &hwpoison_filter_enable);

	debugfs_create_u32("corrupt-filter-dev-major", 0600, hwpoison_dir,
			   &hwpoison_filter_dev_major);

	debugfs_create_u32("corrupt-filter-dev-minor", 0600, hwpoison_dir,
			   &hwpoison_filter_dev_minor);

	debugfs_create_u64("corrupt-filter-flags-mask", 0600, hwpoison_dir,
			   &hwpoison_filter_flags_mask);

	debugfs_create_u64("corrupt-filter-flags-value", 0600, hwpoison_dir,
			   &hwpoison_filter_flags_value);

#ifdef CONFIG_MEMCG
	debugfs_create_u64("corrupt-filter-memcg", 0600, hwpoison_dir,
			   &hwpoison_filter_memcg);
#endif

	return 0;
}

module_init(pfn_inject_init);
module_exit(pfn_inject_exit);
MODULE_DESCRIPTION("HWPoison pages injector");
MODULE_LICENSE("GPL");
Commit	Line	Data
09c434b8	1	// SPDX-License-Identifier: GPL-2.0-only
25985edc	2	/* Inject a hwpoison memory failure on a arbitrary pfn */
cae681fc AK	3	#include <linux/module.h>
	4	#include <linux/debugfs.h>
	5	#include <linux/kernel.h>
	6	#include <linux/mm.h>
31d3d348 WF	7	#include <linux/swap.h>
31d3d348 WF	8	#include <linux/pagemap.h>
43131e14	9	#include <linux/hugetlb.h>
7c116f2b	10	#include "internal.h"
cae681fc	11
847ce401	12	static struct dentry *hwpoison_dir;
cae681fc AK	13
	14	static int hwpoison_inject(void *data, u64 val)
	15	{
31d3d348 WF	16	unsigned long pfn = val;
31d3d348 WF	17	struct page *p;
fed5348e	18	struct folio *folio;
31d3d348 WF	19	int err;
31d3d348 WF	20
cae681fc AK	21	if (!capable(CAP_SYS_ADMIN))
cae681fc AK	22	return -EPERM;
31d3d348 WF	23
	24	if (!pfn_valid(pfn))
	25	return -ENXIO;
	26
	27	p = pfn_to_page(pfn);
fed5348e	28	folio = page_folio(p);
31d3d348	29
fb31ba30 WL	30	if (!hwpoison_filter_enable)
	31	goto inject;
	32
fed5348e	33	shake_folio(folio);
31d3d348	34	/*
a581865e	35	* This implies unable to support non-LRU pages except free page.
31d3d348	36	*/
fed5348e MWO	37	if (!folio_test_lru(folio) && !folio_test_hugetlb(folio) &&
fed5348e MWO	38	!is_free_buddy_page(p))
fd476720	39	return 0;
31d3d348 WF	40
31d3d348 WF	41	/*
fd476720 NH	42	* do a racy check to make sure PG_hwpoison will only be set for
fd476720 NH	43	* the targeted owner (or on a free page).
cd42f4a3	44	* memory_failure() will redo the check reliably inside page lock.
31d3d348	45	*/
fed5348e	46	err = hwpoison_filter(&folio->page);
31d3d348	47	if (err)
fd476720	48	return 0;
31d3d348	49
0d57eb8d	50	inject:
4883e997	51	pr_info("Injecting memory failure at pfn %#lx\n", pfn);
67f22ba7	52	err = memory_failure(pfn, MF_SW_SIMULATED);
d1fe111f	53	return (err == -EOPNOTSUPP) ? 0 : err;
cae681fc AK	54	}
cae681fc AK	55
847ce401 WF	56	static int hwpoison_unpoison(void *data, u64 val)
	57	{
	58	if (!capable(CAP_SYS_ADMIN))
	59	return -EPERM;
	60
	61	return unpoison_memory(val);
	62	}
	63
35e3d566	64	DEFINE_DEBUGFS_ATTRIBUTE(hwpoison_fops, NULL, hwpoison_inject, "%lli\n");
35e3d566	65	DEFINE_DEBUGFS_ATTRIBUTE(unpoison_fops, NULL, hwpoison_unpoison, "%lli\n");
cae681fc	66
4e07acdd	67	static void __exit pfn_inject_exit(void)
cae681fc	68	{
f0696cb4	69	hwpoison_filter_enable = 0;
c2ea2181	70	debugfs_remove_recursive(hwpoison_dir);
cae681fc AK	71	}
cae681fc AK	72
4e07acdd	73	static int __init pfn_inject_init(void)
cae681fc AK	74	{
cae681fc AK	75	hwpoison_dir = debugfs_create_dir("hwpoison", NULL);
847ce401 WF	76
	77	/*
	78	* Note that the below poison/unpoison interfaces do not involve
	79	* hardware status change, hence do not require hardware support.
	80	* They are mainly for testing hwpoison in software level.
	81	*/
2fcc6e20 GKH	82	debugfs_create_file("corrupt-pfn", 0200, hwpoison_dir, NULL,
	83	&hwpoison_fops);
	84
	85	debugfs_create_file("unpoison-pfn", 0200, hwpoison_dir, NULL,
	86	&unpoison_fops);
	87
	88	debugfs_create_u32("corrupt-filter-enable", 0600, hwpoison_dir,
	89	&hwpoison_filter_enable);
	90
	91	debugfs_create_u32("corrupt-filter-dev-major", 0600, hwpoison_dir,
	92	&hwpoison_filter_dev_major);
	93
	94	debugfs_create_u32("corrupt-filter-dev-minor", 0600, hwpoison_dir,
	95	&hwpoison_filter_dev_minor);
	96
	97	debugfs_create_u64("corrupt-filter-flags-mask", 0600, hwpoison_dir,
	98	&hwpoison_filter_flags_mask);
	99
	100	debugfs_create_u64("corrupt-filter-flags-value", 0600, hwpoison_dir,
	101	&hwpoison_filter_flags_value);
478c5ffc	102
94a59fb3	103	#ifdef CONFIG_MEMCG
2fcc6e20 GKH	104	debugfs_create_u64("corrupt-filter-memcg", 0600, hwpoison_dir,
2fcc6e20 GKH	105	&hwpoison_filter_memcg);
4fd466eb AK	106	#endif
4fd466eb AK	107
cae681fc AK	108	return 0;
	109	}
	110
	111	module_init(pfn_inject_init);
	112	module_exit(pfn_inject_exit);
2f57ced6	113	MODULE_DESCRIPTION("HWPoison pages injector");
cae681fc	114	MODULE_LICENSE("GPL");