/* * file for managing the edac_device subsystem of devices for EDAC * * (C) 2007 SoftwareBitMaker * * This file may be distributed under the terms of the * GNU General Public License. * * Written Doug Thompson <[email protected]> * */ #include <linux/ctype.h> #include <linux/module.h> #include <linux/slab.h> #include <linux/edac.h> #include "edac_device.h" #include "edac_module.h" #define EDAC_DEVICE_SYMLINK … #define to_edacdev(k) … #define to_edacdev_attr(a) … /* * Set of edac_device_ctl_info attribute store/show functions */ /* 'log_ue' */ static ssize_t edac_device_ctl_log_ue_show(struct edac_device_ctl_info *ctl_info, char *data) { … } static ssize_t edac_device_ctl_log_ue_store(struct edac_device_ctl_info *ctl_info, const char *data, size_t count) { … } /* 'log_ce' */ static ssize_t edac_device_ctl_log_ce_show(struct edac_device_ctl_info *ctl_info, char *data) { … } static ssize_t edac_device_ctl_log_ce_store(struct edac_device_ctl_info *ctl_info, const char *data, size_t count) { … } /* 'panic_on_ue' */ static ssize_t edac_device_ctl_panic_on_ue_show(struct edac_device_ctl_info *ctl_info, char *data) { … } static ssize_t edac_device_ctl_panic_on_ue_store(struct edac_device_ctl_info *ctl_info, const char *data, size_t count) { … } /* 'poll_msec' show and store functions*/ static ssize_t edac_device_ctl_poll_msec_show(struct edac_device_ctl_info *ctl_info, char *data) { … } static ssize_t edac_device_ctl_poll_msec_store(struct edac_device_ctl_info *ctl_info, const char *data, size_t count) { … } /* edac_device_ctl_info specific attribute structure */ struct ctl_info_attribute { … }; #define to_ctl_info(k) … #define to_ctl_info_attr(a) … /* Function to 'show' fields from the edac_dev 'ctl_info' structure */ static ssize_t edac_dev_ctl_info_show(struct kobject *kobj, struct attribute *attr, char *buffer) { … } /* Function to 'store' fields into the edac_dev 'ctl_info' structure */ static ssize_t edac_dev_ctl_info_store(struct kobject *kobj, struct attribute *attr, const char *buffer, size_t count) { … } /* edac_dev file operations for an 'ctl_info' */ static const struct sysfs_ops device_ctl_info_ops = …; #define CTL_INFO_ATTR(_name,_mode,_show,_store) … /* Declare the various ctl_info attributes here and their respective ops */ CTL_INFO_ATTR(log_ue, S_IRUGO | S_IWUSR, edac_device_ctl_log_ue_show, edac_device_ctl_log_ue_store); CTL_INFO_ATTR(log_ce, S_IRUGO | S_IWUSR, edac_device_ctl_log_ce_show, edac_device_ctl_log_ce_store); CTL_INFO_ATTR(panic_on_ue, S_IRUGO | S_IWUSR, edac_device_ctl_panic_on_ue_show, edac_device_ctl_panic_on_ue_store); CTL_INFO_ATTR(poll_msec, S_IRUGO | S_IWUSR, edac_device_ctl_poll_msec_show, edac_device_ctl_poll_msec_store); /* Base Attributes of the EDAC_DEVICE ECC object */ static struct attribute *device_ctrl_attrs[] = …; ATTRIBUTE_GROUPS(…); /* * edac_device_ctrl_master_release * * called when the reference count for the 'main' kobj * for a edac_device control struct reaches zero * * Reference count model: * One 'main' kobject for each control structure allocated. * That main kobj is initially set to one AND * the reference count for the EDAC 'core' module is * bumped by one, thus added 'keep in memory' dependency. * * Each new internal kobj (in instances and blocks) then * bumps the 'main' kobject. * * When they are released their release functions decrement * the 'main' kobj. * * When the main kobj reaches zero (0) then THIS function * is called which then decrements the EDAC 'core' module. * When the module reference count reaches zero then the * module no longer has dependency on keeping the release * function code in memory and module can be unloaded. * * This will support several control objects as well, each * with its own 'main' kobj. */ static void edac_device_ctrl_master_release(struct kobject *kobj) { … } /* ktype for the main (master) kobject */ static struct kobj_type ktype_device_ctrl = …; /* * edac_device_register_sysfs_main_kobj * * perform the high level setup for the new edac_device instance * * Return: 0 SUCCESS * !0 FAILURE */ int edac_device_register_sysfs_main_kobj(struct edac_device_ctl_info *edac_dev) { … } /* * edac_device_unregister_sysfs_main_kobj: * the '..../edac/<name>' kobject */ void edac_device_unregister_sysfs_main_kobj(struct edac_device_ctl_info *dev) { … } /* edac_dev -> instance information */ /* * Set of low-level instance attribute show functions */ static ssize_t instance_ue_count_show(struct edac_device_instance *instance, char *data) { … } static ssize_t instance_ce_count_show(struct edac_device_instance *instance, char *data) { … } #define to_instance(k) … #define to_instance_attr(a) … /* DEVICE instance kobject release() function */ static void edac_device_ctrl_instance_release(struct kobject *kobj) { … } /* instance specific attribute structure */ struct instance_attribute { … }; /* Function to 'show' fields from the edac_dev 'instance' structure */ static ssize_t edac_dev_instance_show(struct kobject *kobj, struct attribute *attr, char *buffer) { … } /* Function to 'store' fields into the edac_dev 'instance' structure */ static ssize_t edac_dev_instance_store(struct kobject *kobj, struct attribute *attr, const char *buffer, size_t count) { … } /* edac_dev file operations for an 'instance' */ static const struct sysfs_ops device_instance_ops = …; #define INSTANCE_ATTR(_name,_mode,_show,_store) … /* * Define attributes visible for the edac_device instance object * Each contains a pointer to a show and an optional set * function pointer that does the low level output/input */ INSTANCE_ATTR(ce_count, S_IRUGO, instance_ce_count_show, NULL); INSTANCE_ATTR(ue_count, S_IRUGO, instance_ue_count_show, NULL); /* list of edac_dev 'instance' attributes */ static struct attribute *device_instance_attrs[] = …; ATTRIBUTE_GROUPS(…); /* The 'ktype' for each edac_dev 'instance' */ static struct kobj_type ktype_instance_ctrl = …; /* edac_dev -> instance -> block information */ #define to_block(k) … #define to_block_attr(a) … /* * Set of low-level block attribute show functions */ static ssize_t block_ue_count_show(struct kobject *kobj, struct attribute *attr, char *data) { … } static ssize_t block_ce_count_show(struct kobject *kobj, struct attribute *attr, char *data) { … } /* DEVICE block kobject release() function */ static void edac_device_ctrl_block_release(struct kobject *kobj) { … } /* Function to 'show' fields from the edac_dev 'block' structure */ static ssize_t edac_dev_block_show(struct kobject *kobj, struct attribute *attr, char *buffer) { … } /* edac_dev file operations for a 'block' */ static const struct sysfs_ops device_block_ops = …; #define BLOCK_ATTR(_name,_mode,_show) … BLOCK_ATTR(ce_count, S_IRUGO, block_ce_count_show); BLOCK_ATTR(ue_count, S_IRUGO, block_ue_count_show); /* list of edac_dev 'block' attributes */ static struct attribute *device_block_attrs[] = …; ATTRIBUTE_GROUPS(…); /* The 'ktype' for each edac_dev 'block' */ static struct kobj_type ktype_block_ctrl = …; /* block ctor/dtor code */ /* * edac_device_create_block */ static int edac_device_create_block(struct edac_device_ctl_info *edac_dev, struct edac_device_instance *instance, struct edac_device_block *block) { … } /* * edac_device_delete_block(edac_dev,block); */ static void edac_device_delete_block(struct edac_device_ctl_info *edac_dev, struct edac_device_block *block) { … } /* instance ctor/dtor code */ /* * edac_device_create_instance * create just one instance of an edac_device 'instance' */ static int edac_device_create_instance(struct edac_device_ctl_info *edac_dev, int idx) { … } /* * edac_device_remove_instance * remove an edac_device instance */ static void edac_device_delete_instance(struct edac_device_ctl_info *edac_dev, int idx) { … } /* * edac_device_create_instances * create the first level of 'instances' for this device * (ie 'cache' might have 'cache0', 'cache1', 'cache2', etc */ static int edac_device_create_instances(struct edac_device_ctl_info *edac_dev) { … } /* * edac_device_delete_instances(edac_dev); * unregister all the kobjects of the instances */ static void edac_device_delete_instances(struct edac_device_ctl_info *edac_dev) { … } /* edac_dev sysfs ctor/dtor code */ /* * edac_device_add_main_sysfs_attributes * add some attributes to this instance's main kobject */ static int edac_device_add_main_sysfs_attributes( struct edac_device_ctl_info *edac_dev) { … } /* * edac_device_remove_main_sysfs_attributes * remove any attributes to this instance's main kobject */ static void edac_device_remove_main_sysfs_attributes( struct edac_device_ctl_info *edac_dev) { … } /* * edac_device_create_sysfs() Constructor * * accept a created edac_device control structure * and 'export' it to sysfs. The 'main' kobj should already have been * created. 'instance' and 'block' kobjects should be registered * along with any 'block' attributes from the low driver. In addition, * the main attributes (if any) are connected to the main kobject of * the control structure. * * Return: * 0 Success * !0 Failure */ int edac_device_create_sysfs(struct edac_device_ctl_info *edac_dev) { … } /* * edac_device_remove_sysfs() destructor * * given an edac_device struct, tear down the kobject resources */ void edac_device_remove_sysfs(struct edac_device_ctl_info *edac_dev) { … }
Codebase Browser
linux