Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192// SPDX-License-Identifier: GPL-2.0/* * Dummy EDAC driver * * A minimal EDAC device driver that registers its own platform device * unconditionally, so it probes successfully on any system -- including * VMs and guests that have no real ECC-capable cache/memory hardware * exposed to them. Useful for exercising the EDAC core, sysfs interface, * and userspace tooling (edac-utils, mcelog, etc.) without needing the * physical hardware the "real" drivers depend on. * * Modeled after drivers/edac/a72_edac.c (Cortex A72 EDAC L1/L2 cache * error detection), but with all of the hardware-specific bits (system * register reads, SMP cross-calls, devicetree compatible matching) * replaced by a software-only error source that can be poked from * debugfs or left to generate nothing at all. */
#include <linux/cpu.h>#include <linux/debugfs.h>#include <linux/module.h>#include <linux/platform_device.h>#include <linux/slab.h>
#include "edac_module.h"
#define DRVNAME "dummy-edac"#define MESSAGE_SIZE 64
/* * Simulated "error syndrome". In real hardware drivers this would be * read out of a per-CPU system/MMIO register. Here userspace (via * debugfs) or nothing at all drives it, which is exactly the point: * the driver has no dependency on any physical error source. */struct dummy_edac_priv { struct dentry *debugfs_dir; atomic_t inject_ce; atomic_t inject_ue;};
static void dummy_edac_check(struct edac_device_ctl_info *edac_ctl){ struct dummy_edac_priv *priv = edac_ctl->pvt_info; int cpu = raw_smp_processor_id(); char msg[MESSAGE_SIZE];
if (atomic_xchg(&priv->inject_ce, 0)) { snprintf(msg, MESSAGE_SIZE, "simulated correctable error on CPU %d", cpu); edac_device_handle_ce(edac_ctl, cpu, 0, msg); }
if (atomic_xchg(&priv->inject_ue, 0)) { snprintf(msg, MESSAGE_SIZE, "simulated uncorrectable error on CPU %d", cpu); edac_device_handle_ue(edac_ctl, cpu, 0, msg); }}
/* * debugfs knobs so you can drive the driver from userspace inside the * guest, e.g.: * echo 1 > /sys/kernel/debug/dummy-edac/inject_ce * echo 1 > /sys/kernel/debug/dummy-edac/inject_ue */static int inject_ce_set(void *data, u64 val){ struct dummy_edac_priv *priv = data;
if (val) atomic_set(&priv->inject_ce, 1); return 0;}DEFINE_DEBUGFS_ATTRIBUTE(inject_ce_fops, NULL, inject_ce_set, "%llu\n");
static int inject_ue_set(void *data, u64 val){ struct dummy_edac_priv *priv = data;
if (val) atomic_set(&priv->inject_ue, 1); return 0;}DEFINE_DEBUGFS_ATTRIBUTE(inject_ue_fops, NULL, inject_ue_set, "%llu\n");
static int dummy_edac_probe(struct platform_device *pdev){ struct edac_device_ctl_info *edac_ctl; struct dummy_edac_priv *priv; struct device *dev = &pdev->dev; int rc;
edac_ctl = edac_device_alloc_ctl_info(sizeof(*priv), "cpu", num_possible_cpus(), "L", 1, 1, edac_device_alloc_index()); if (!edac_ctl) return -ENOMEM;
priv = edac_ctl->pvt_info; atomic_set(&priv->inject_ce, 0); atomic_set(&priv->inject_ue, 0);
edac_ctl->edac_check = dummy_edac_check; edac_ctl->dev = dev; edac_ctl->mod_name = dev_name(dev); edac_ctl->dev_name = dev_name(dev); edac_ctl->ctl_name = DRVNAME; /* Poll fairly slowly; this is a software source, not real hardware. */ edac_ctl->poll_msec = 1000; dev_set_drvdata(dev, edac_ctl);
rc = edac_device_add_device(edac_ctl); if (rc) goto out_dev;
priv->debugfs_dir = debugfs_create_dir(DRVNAME, NULL); debugfs_create_file_unsafe("inject_ce", 0200, priv->debugfs_dir, priv, &inject_ce_fops); debugfs_create_file_unsafe("inject_ue", 0200, priv->debugfs_dir, priv, &inject_ue_fops);
return 0;
out_dev: edac_device_free_ctl_info(edac_ctl);
return rc;}
static void dummy_edac_remove(struct platform_device *pdev){ struct edac_device_ctl_info *edac_ctl = dev_get_drvdata(&pdev->dev); struct dummy_edac_priv *priv = edac_ctl->pvt_info;
debugfs_remove_recursive(priv->debugfs_dir); edac_device_del_device(edac_ctl->dev); edac_device_free_ctl_info(edac_ctl);}
static struct platform_driver dummy_edac_driver = { .probe = dummy_edac_probe, .remove = dummy_edac_remove, .driver = { .name = DRVNAME, },};
/* * No devicetree/ACPI match table, and no scan of CPU nodes for a "compatible" * + enable property: simply register a platform device unconditionally so * probe() always runs. There is nothing here that depends on the underlying * platform actually exposing the corresponding hardware, so it loads fine * under QEMU/KVM, containers-with-a-kernel, or any other guest environment. */static struct platform_device *dummy_pdev;
static int __init dummy_edac_driver_init(void){ int rc;
dummy_pdev = platform_device_register_simple(DRVNAME, -1, NULL, 0); if (IS_ERR(dummy_pdev)) { pr_err(DRVNAME ": failed to register dummy platform device\n"); return PTR_ERR(dummy_pdev); }
rc = platform_driver_register(&dummy_edac_driver); if (rc) { platform_device_unregister(dummy_pdev); return rc; }
pr_info("Loading %s\n", DRVNAME);
return 0;}
static void __exit dummy_edac_driver_exit(void){ platform_driver_unregister(&dummy_edac_driver); platform_device_unregister(dummy_pdev);
pr_info("Removing %s\n", DRVNAME);}
module_init(dummy_edac_driver_init);module_exit(dummy_edac_driver_exit);
MODULE_LICENSE("GPL");MODULE_DESCRIPTION("Dummy EDAC driver for testing without real ECC hardware");