static int edac_device_create_instance(struct edac_device_ctl_info *edac_dev, int idx) { int i, j; int err; struct edac_device_instance *instance; struct kobject *main_kobj; instance = &edac_dev->instances[idx]; memset(&instance->kobj, 0, sizeof(struct kobject)); instance->ctl = edac_dev; main_kobj = kobject_get(&edac_dev->kobj); if (!main_kobj) { err = -ENODEV; goto err_out; } err = kobject_init_and_add(&instance->kobj, &ktype_instance_ctrl, &edac_dev->kobj, "%s", instance->name); if (err != 0) { debugf2("%s() Failed to register instance '%s'\n", __func__, instance->name); kobject_put(main_kobj); goto err_out; } debugf4("%s() now register '%d' blocks for instance %d\n", __func__, instance->nr_blocks, idx); for (i = 0; i < instance->nr_blocks; i++) { err = edac_device_create_block(edac_dev, instance, &instance->blocks[i]); if (err) { for (j = 0; j < i; j++) edac_device_delete_block(edac_dev, &instance->blocks[j]); goto err_release_instance_kobj; } } kobject_uevent(&instance->kobj, KOBJ_ADD); debugf4("%s() Registered instance %d '%s' kobject\n", __func__, idx, instance->name); return 0; err_release_instance_kobj: kobject_put(&instance->kobj); err_out: return err; }
/* * 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) { struct sysdev_class *edac_class; int err; debugf1("%s()\n", __func__); /* get the /sys/devices/system/edac reference */ edac_class = edac_get_edac_class(); if (edac_class == NULL) { debugf1("%s() no edac_class error\n", __func__); err = -ENODEV; goto err_out; } /* Point to the 'edac_class' this instance 'reports' to */ edac_dev->edac_class = edac_class; /* Init the devices's kobject */ memset(&edac_dev->kobj, 0, sizeof(struct kobject)); /* Record which module 'owns' this control structure * and bump the ref count of the module */ edac_dev->owner = THIS_MODULE; if (!try_module_get(edac_dev->owner)) { err = -ENODEV; goto err_out; } /* register */ err = kobject_init_and_add(&edac_dev->kobj, &ktype_device_ctrl, &edac_class->kset.kobj, "%s", edac_dev->name); if (err) { debugf1("%s()Failed to register '.../edac/%s'\n", __func__, edac_dev->name); goto err_kobj_reg; } kobject_uevent(&edac_dev->kobj, KOBJ_ADD); /* At this point, to 'free' the control struct, * edac_device_unregister_sysfs_main_kobj() must be used */ debugf4("%s() Registered '.../edac/%s' kobject\n", __func__, edac_dev->name); return 0; /* Error exit stack */ err_kobj_reg: module_put(edac_dev->owner); err_out: return err; }
void edac_device_unregister_sysfs_main_kobj(struct edac_device_ctl_info *dev) { debugf0("%s()\n", __func__); debugf4("%s() name of kobject is: %s\n", __func__, kobject_name(&dev->kobj)); kobject_put(&dev->kobj); edac_put_sysfs_subsys(); }
int edac_device_register_sysfs_main_kobj(struct edac_device_ctl_info *edac_dev) { struct bus_type *edac_subsys; int err; debugf1("%s()\n", __func__); edac_subsys = edac_get_sysfs_subsys(); if (edac_subsys == NULL) { debugf1("%s() no edac_subsys error\n", __func__); err = -ENODEV; goto err_out; } edac_dev->edac_subsys = edac_subsys; memset(&edac_dev->kobj, 0, sizeof(struct kobject)); edac_dev->owner = THIS_MODULE; if (!try_module_get(edac_dev->owner)) { err = -ENODEV; goto err_mod_get; } err = kobject_init_and_add(&edac_dev->kobj, &ktype_device_ctrl, &edac_subsys->dev_root->kobj, "%s", edac_dev->name); if (err) { debugf1("%s()Failed to register '.../edac/%s'\n", __func__, edac_dev->name); goto err_kobj_reg; } kobject_uevent(&edac_dev->kobj, KOBJ_ADD); debugf4("%s() Registered '.../edac/%s' kobject\n", __func__, edac_dev->name); return 0; err_kobj_reg: module_put(edac_dev->owner); err_mod_get: edac_put_sysfs_subsys(); err_out: return err; }
static void edac_device_ctrl_master_release(struct kobject *kobj) { struct edac_device_ctl_info *edac_dev = to_edacdev(kobj); debugf4("%s() control index=%d\n", __func__, edac_dev->dev_idx); module_put(edac_dev->owner); kfree(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) { int err; struct kobject *edac_kobj = &edac_dev->kobj; debugf0("%s() idx=%d\n", __func__, edac_dev->dev_idx); /* go create any main attributes callers wants */ err = edac_device_add_main_sysfs_attributes(edac_dev); if (err) { debugf0("%s() failed to add sysfs attribs\n", __func__); goto err_out; } /* create a symlink from the edac device * to the platform 'device' being used for this */ err = sysfs_create_link(edac_kobj, &edac_dev->dev->kobj, EDAC_DEVICE_SYMLINK); if (err) { debugf0("%s() sysfs_create_link() returned err= %d\n", __func__, err); goto err_remove_main_attribs; } /* Create the first level instance directories * In turn, the nested blocks beneath the instances will * be registered as well */ err = edac_device_create_instances(edac_dev); if (err) { debugf0("%s() edac_device_create_instances() " "returned err= %d\n", __func__, err); goto err_remove_link; } debugf4("%s() create-instances done, idx=%d\n", __func__, edac_dev->dev_idx); return 0; /* Error unwind stack */ err_remove_link: /* remove the sym link */ sysfs_remove_link(&edac_dev->kobj, EDAC_DEVICE_SYMLINK); err_remove_main_attribs: edac_device_remove_main_sysfs_attributes(edac_dev); err_out: return err; }
/* * 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) { struct edac_device_ctl_info *edac_dev = to_edacdev(kobj); debugf4("%s() control index=%d\n", __func__, edac_dev->dev_idx); /* decrement the EDAC CORE module ref count */ module_put(edac_dev->owner); /* free the control struct containing the 'main' kobj * passed in to this routine */ kfree(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) { debugf0("%s()\n", __func__); debugf4("%s() name of kobject is: %s\n", __func__, kobject_name(&dev->kobj)); /* * Unregister the edac device's kobject and * allow for reference count to reach 0 at which point * the callback will be called to: * a) module_put() this module * b) 'kfree' the memory */ kobject_put(&dev->kobj); edac_put_sysfs_class(); }
int edac_device_create_sysfs(struct edac_device_ctl_info *edac_dev) { int err; struct kobject *edac_kobj = &edac_dev->kobj; debugf0("%s() idx=%d\n", __func__, edac_dev->dev_idx); err = edac_device_add_main_sysfs_attributes(edac_dev); if (err) { debugf0("%s() failed to add sysfs attribs\n", __func__); goto err_out; } err = sysfs_create_link(edac_kobj, &edac_dev->dev->kobj, EDAC_DEVICE_SYMLINK); if (err) { debugf0("%s() sysfs_create_link() returned err= %d\n", __func__, err); goto err_remove_main_attribs; } err = edac_device_create_instances(edac_dev); if (err) { debugf0("%s() edac_device_create_instances() " "returned err= %d\n", __func__, err); goto err_remove_link; } debugf4("%s() create-instances done, idx=%d\n", __func__, edac_dev->dev_idx); return 0; err_remove_link: sysfs_remove_link(&edac_dev->kobj, EDAC_DEVICE_SYMLINK); err_remove_main_attribs: edac_device_remove_main_sysfs_attributes(edac_dev); err_out: return err; }
/* * PCI Parity polling * * Fucntion to retrieve the current parity status * and decode it * */ static void edac_pci_dev_parity_test(struct pci_dev *dev) { unsigned long flags; u16 status; u8 header_type; /* stop any interrupts until we can acquire the status */ local_irq_save(flags); /* read the STATUS register on this device */ status = get_pci_parity_status(dev, 0); /* read the device TYPE, looking for bridges */ pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type); local_irq_restore(flags); debugf4("PCI STATUS= 0x%04x %s\n", status, dev_name(&dev->dev)); /* check the status reg for errors on boards NOT marked as broken * if broken, we cannot trust any of the status bits */ if (status && !dev->broken_parity_status) { if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) { edac_printk(KERN_CRIT, EDAC_PCI, "Signaled System Error on %s\n", pci_name(dev)); atomic_inc(&pci_nonparity_count); } if (status & (PCI_STATUS_PARITY)) { edac_printk(KERN_CRIT, EDAC_PCI, "Master Data Parity Error on %s\n", pci_name(dev)); atomic_inc(&pci_parity_count); } if (status & (PCI_STATUS_DETECTED_PARITY)) { edac_printk(KERN_CRIT, EDAC_PCI, "Detected Parity Error on %s\n", pci_name(dev)); atomic_inc(&pci_parity_count); } } debugf4("PCI HEADER TYPE= 0x%02x %s\n", header_type, dev_name(&dev->dev)); if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { /* On bridges, need to examine secondary status register */ status = get_pci_parity_status(dev, 1); debugf4("PCI SEC_STATUS= 0x%04x %s\n", status, dev_name(&dev->dev)); /* check the secondary status reg for errors, * on NOT broken boards */ if (status && !dev->broken_parity_status) { if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) { edac_printk(KERN_CRIT, EDAC_PCI, "Bridge " "Signaled System Error on %s\n", pci_name(dev)); atomic_inc(&pci_nonparity_count); } if (status & (PCI_STATUS_PARITY)) { edac_printk(KERN_CRIT, EDAC_PCI, "Bridge " "Master Data Parity Error on " "%s\n", pci_name(dev)); atomic_inc(&pci_parity_count); } if (status & (PCI_STATUS_DETECTED_PARITY)) { edac_printk(KERN_CRIT, EDAC_PCI, "Bridge " "Detected Parity Error on %s\n", pci_name(dev)); atomic_inc(&pci_parity_count); } } } }
/* * 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) { int i, j; int err; struct edac_device_instance *instance; struct kobject *main_kobj; instance = &edac_dev->instances[idx]; /* Init the instance's kobject */ memset(&instance->kobj, 0, sizeof(struct kobject)); instance->ctl = edac_dev; /* bump the main kobject's reference count for this controller * and this instance is dependant on the main */ main_kobj = kobject_get(&edac_dev->kobj); if (!main_kobj) { err = -ENODEV; goto err_out; } /* Formally register this instance's kobject under the edac_device */ err = kobject_init_and_add(&instance->kobj, &ktype_instance_ctrl, &edac_dev->kobj, "%s", instance->name); if (err != 0) { debugf2("%s() Failed to register instance '%s'\n", __func__, instance->name); kobject_put(main_kobj); goto err_out; } debugf4("%s() now register '%d' blocks for instance %d\n", __func__, instance->nr_blocks, idx); /* register all blocks of this instance */ for (i = 0; i < instance->nr_blocks; i++) { err = edac_device_create_block(edac_dev, instance, &instance->blocks[i]); if (err) { /* If any fail, remove all previous ones */ for (j = 0; j < i; j++) edac_device_delete_block(edac_dev, &instance->blocks[j]); goto err_release_instance_kobj; } } kobject_uevent(&instance->kobj, KOBJ_ADD); debugf4("%s() Registered instance %d '%s' kobject\n", __func__, idx, instance->name); return 0; /* error unwind stack */ err_release_instance_kobj: kobject_put(&instance->kobj); err_out: return err; }
/* * 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) { int i; int err; struct edac_dev_sysfs_block_attribute *sysfs_attrib; struct kobject *main_kobj; debugf4("%s() Instance '%s' inst_p=%p block '%s' block_p=%p\n", __func__, instance->name, instance, block->name, block); debugf4("%s() block kobj=%p block kobj->parent=%p\n", __func__, &block->kobj, &block->kobj.parent); /* init this block's kobject */ memset(&block->kobj, 0, sizeof(struct kobject)); /* bump the main kobject's reference count for this controller * and this instance is dependant on the main */ main_kobj = kobject_get(&edac_dev->kobj); if (!main_kobj) { err = -ENODEV; goto err_out; } /* Add this block's kobject */ err = kobject_init_and_add(&block->kobj, &ktype_block_ctrl, &instance->kobj, "%s", block->name); if (err) { debugf1("%s() Failed to register instance '%s'\n", __func__, block->name); kobject_put(main_kobj); err = -ENODEV; goto err_out; } /* If there are driver level block attributes, then added them * to the block kobject */ sysfs_attrib = block->block_attributes; if (sysfs_attrib && block->nr_attribs) { for (i = 0; i < block->nr_attribs; i++, sysfs_attrib++) { debugf4("%s() creating block attrib='%s' " "attrib->%p to kobj=%p\n", __func__, sysfs_attrib->attr.name, sysfs_attrib, &block->kobj); /* Create each block_attribute file */ err = sysfs_create_file(&block->kobj, &sysfs_attrib->attr); if (err) goto err_on_attrib; } } kobject_uevent(&block->kobj, KOBJ_ADD); return 0; /* Error unwind stack */ err_on_attrib: kobject_put(&block->kobj); err_out: return err; }
static int edac_device_create_block(struct edac_device_ctl_info *edac_dev, struct edac_device_instance *instance, struct edac_device_block *block) { int i; int err; struct edac_dev_sysfs_block_attribute *sysfs_attrib; struct kobject *main_kobj; debugf4("%s() Instance '%s' inst_p=%p block '%s' block_p=%p\n", __func__, instance->name, instance, block->name, block); debugf4("%s() block kobj=%p block kobj->parent=%p\n", __func__, &block->kobj, &block->kobj.parent); memset(&block->kobj, 0, sizeof(struct kobject)); main_kobj = kobject_get(&edac_dev->kobj); if (!main_kobj) { err = -ENODEV; goto err_out; } err = kobject_init_and_add(&block->kobj, &ktype_block_ctrl, &instance->kobj, "%s", block->name); if (err) { debugf1("%s() Failed to register instance '%s'\n", __func__, block->name); kobject_put(main_kobj); err = -ENODEV; goto err_out; } sysfs_attrib = block->block_attributes; if (sysfs_attrib && block->nr_attribs) { for (i = 0; i < block->nr_attribs; i++, sysfs_attrib++) { debugf4("%s() creating block attrib='%s' " "attrib->%p to kobj=%p\n", __func__, sysfs_attrib->attr.name, sysfs_attrib, &block->kobj); err = sysfs_create_file(&block->kobj, &sysfs_attrib->attr); if (err) goto err_on_attrib; } } kobject_uevent(&block->kobj, KOBJ_ADD); return 0; err_on_attrib: kobject_put(&block->kobj); err_out: return err; }