#include <linux/config.h>
-#include <linux/version.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/sysdev.h>
#include <linux/ctype.h>
+#include <linux/kthread.h>
#include <asm/uaccess.h>
#include <asm/page.h>
#define EDAC_MC_VERSION "edac_mc Ver: 2.0.0 " __DATE__
+/* For now, disable the EDAC sysfs code. The sysfs interface that EDAC
+ * presents to user space needs more thought, and is likely to change
+ * substantially.
+ */
+#define DISABLE_EDAC_SYSFS
+
#ifdef CONFIG_EDAC_DEBUG
/* Values of 0 to 4 will generate output */
int edac_debug_level = 1;
/* EDAC Controls, setable by module parameter, and sysfs */
static int log_ue = 1;
static int log_ce = 1;
-static int panic_on_ue = 1;
+static int panic_on_ue;
static int poll_msec = 1000;
static int check_pci_parity = 0; /* default YES check PCI parity */
static DECLARE_MUTEX(mem_ctls_mutex);
static struct list_head mc_devices = LIST_HEAD_INIT(mc_devices);
+static struct task_struct *edac_thread;
+
/* Structure of the whitelist and blacklist arrays */
struct edac_pci_device_list {
unsigned int vendor; /* Vendor ID */
/* START sysfs data and methods */
+#ifndef DISABLE_EDAC_SYSFS
+
static const char *mem_types[] = {
[MEM_EMPTY] = "Empty",
[MEM_RESERVED] = "Reserved",
* /sys/devices/system/edac/mc;
* data structures and methods
*/
+#if 0
static ssize_t memctrl_string_show(void *ptr, char *buffer)
{
char *value = (char*) ptr;
return sprintf(buffer, "%s\n", value);
}
+#endif
static ssize_t memctrl_int_show(void *ptr, char *buffer)
{
};
/* cwrow<id> attribute f*/
+#if 0
MEMCTRL_STRING_ATTR(mc_version,EDAC_MC_VERSION,S_IRUGO,memctrl_string_show,NULL);
+#endif
/* csrow<id> control files */
MEMCTRL_ATTR(panic_on_ue,S_IRUGO|S_IWUSR,memctrl_int_show,memctrl_int_store);
&attr_log_ue,
&attr_log_ce,
&attr_poll_msec,
- &attr_mc_version,
NULL,
};
.default_attrs = (struct attribute **) memctrl_attr,
};
+#endif /* DISABLE_EDAC_SYSFS */
/* Initialize the main sysfs entries for edac:
* /sys/devices/system/edac
* !0 FAILURE
*/
static int edac_sysfs_memctrl_setup(void)
+#ifdef DISABLE_EDAC_SYSFS
+{
+ return 0;
+}
+#else
{
int err=0;
return err;
}
+#endif /* DISABLE_EDAC_SYSFS */
/*
* MC teardown:
*/
static void edac_sysfs_memctrl_teardown(void)
{
+#ifndef DISABLE_EDAC_SYSFS
debugf0("MC: " __FILE__ ": %s()\n", __func__);
/* Unregister the MC's kobject */
/* Unregister the 'edac' object */
sysdev_class_unregister(&edac_class);
+#endif /* DISABLE_EDAC_SYSFS */
}
+#ifndef DISABLE_EDAC_SYSFS
+
/*
* /sys/devices/system/edac/pci;
* data structures and methods
int *count;
};
+
+#if 0
/* Output the list as: vendor_id:device:id<,vendor_id:device_id> */
static ssize_t edac_pci_list_string_show(void *ptr, char *buffer)
{
return count;
}
+#endif
static ssize_t edac_pci_int_show(void *ptr, char *buffer)
{
int *value = ptr;
.store = _store, \
};
+#if 0
static struct list_control pci_whitelist_control = {
.list = pci_whitelist,
.count = &pci_whitelist_count
S_IRUGO|S_IWUSR,
edac_pci_list_string_show,
edac_pci_list_string_store);
+#endif
/* PCI Parity control files */
EDAC_PCI_ATTR(check_pci_parity,S_IRUGO|S_IWUSR,edac_pci_int_show,edac_pci_int_store);
&edac_pci_attr_check_pci_parity,
&edac_pci_attr_panic_on_pci_parity,
&edac_pci_attr_pci_parity_count,
- &edac_pci_attr_pci_parity_whitelist,
- &edac_pci_attr_pci_parity_blacklist,
NULL,
};
.default_attrs = (struct attribute **) edac_pci_attr,
};
+#endif /* DISABLE_EDAC_SYSFS */
+
/**
* edac_sysfs_pci_setup()
*
*/
static int edac_sysfs_pci_setup(void)
+#ifdef DISABLE_EDAC_SYSFS
+{
+ return 0;
+}
+#else
{
int err;
}
return err;
}
-
+#endif /* DISABLE_EDAC_SYSFS */
static void edac_sysfs_pci_teardown(void)
{
+#ifndef DISABLE_EDAC_SYSFS
debugf0("MC: " __FILE__ ": %s()\n", __func__);
kobject_unregister(&edac_pci_kobj);
kobject_put(&edac_pci_kobj);
+#endif
}
+#ifndef DISABLE_EDAC_SYSFS
+
/* EDAC sysfs CSROW data structures and methods */
/* Set of more detailed csrow<id> attribute show/store functions */
.default_attrs = (struct attribute **) mci_attr,
};
+#endif /* DISABLE_EDAC_SYSFS */
+
#define EDAC_DEVICE_SYMLINK "device"
/*
* !0 Failure
*/
static int edac_create_sysfs_mci_device(struct mem_ctl_info *mci)
+#ifdef DISABLE_EDAC_SYSFS
+{
+ return 0;
+}
+#else
{
int i;
int err;
return err;
}
+#endif /* DISABLE_EDAC_SYSFS */
/*
* remove a Memory Controller instance
*/
static void edac_remove_sysfs_mci_device(struct mem_ctl_info *mci)
{
+#ifndef DISABLE_EDAC_SYSFS
int i;
debugf0("MC: " __FILE__ ": %s()\n", __func__);
kobject_unregister(&mci->edac_mci_kobj);
kobject_put(&mci->edac_mci_kobj);
+#endif /* DISABLE_EDAC_SYSFS */
}
/* END OF sysfs data and methods */
*/
static void do_edac_check(void)
{
-
debugf3("MC: " __FILE__ ": %s()\n", __func__);
check_mc_devices();
do_pci_parity_check();
}
-
-/*
- * EDAC thread state information
- */
-struct bs_thread_info
-{
- struct task_struct *task;
- struct completion *event;
- char *name;
- void (*run)(void);
-};
-
-static struct bs_thread_info bs_thread;
-
-/*
- * edac_kernel_thread
- * This the kernel thread that processes edac operations
- * in a normal thread environment
- */
static int edac_kernel_thread(void *arg)
{
- struct bs_thread_info *thread = (struct bs_thread_info *) arg;
-
- /* detach thread */
- daemonize(thread->name);
-
- current->exit_signal = SIGCHLD;
- allow_signal(SIGKILL);
- thread->task = current;
-
- /* indicate to starting task we have started */
- complete(thread->event);
-
- /* loop forever, until we are told to stop */
- while(thread->run != NULL) {
- void (*run)(void);
-
- /* call the function to check the memory controllers */
- run = thread->run;
- if (run)
- run();
-
- if (signal_pending(current))
- flush_signals(current);
-
- /* ensure we are interruptable */
- set_current_state(TASK_INTERRUPTIBLE);
+ while (!kthread_should_stop()) {
+ do_edac_check();
/* goto sleep for the interval */
- schedule_timeout((HZ * poll_msec) / 1000);
+ schedule_timeout_interruptible((HZ * poll_msec) / 1000);
try_to_freeze();
}
- /* notify waiter that we are exiting */
- complete(thread->event);
-
return 0;
}
*/
static int __init edac_mc_init(void)
{
- int ret;
- struct completion event;
-
printk(KERN_INFO "MC: " __FILE__ " version " EDAC_MC_VERSION "\n");
/*
return -ENODEV;
}
- /* Create our kernel thread */
- init_completion(&event);
- bs_thread.event = &event;
- bs_thread.name = "kedac";
- bs_thread.run = do_edac_check;
-
/* create our kernel thread */
- ret = kernel_thread(edac_kernel_thread, &bs_thread, CLONE_KERNEL);
- if (ret < 0) {
+ edac_thread = kthread_run(edac_kernel_thread, NULL, "kedac");
+ if (IS_ERR(edac_thread)) {
/* remove the sysfs entries */
edac_sysfs_memctrl_teardown();
edac_sysfs_pci_teardown();
- return -ENOMEM;
+ return PTR_ERR(edac_thread);
}
- /* wait for our kernel theard ack that it is up and running */
- wait_for_completion(&event);
-
return 0;
}
*/
static void __exit edac_mc_exit(void)
{
- struct completion event;
-
debugf0("MC: " __FILE__ ": %s()\n", __func__);
- init_completion(&event);
- bs_thread.event = &event;
-
- /* As soon as ->run is set to NULL, the task could disappear,
- * so we need to hold tasklist_lock until we have sent the signal
- */
- read_lock(&tasklist_lock);
- bs_thread.run = NULL;
- send_sig(SIGKILL, bs_thread.task, 1);
- read_unlock(&tasklist_lock);
- wait_for_completion(&event);
+ kthread_stop(edac_thread);
/* tear down the sysfs device */
edac_sysfs_memctrl_teardown();
projects / powerpc.git / blobdiff