linux/drivers/edac/edac_device_sysfs.c
<<
>>
Prefs
   1/*
   2 * file for managing the edac_device class of devices for EDAC
   3 *
   4 * (C) 2007 SoftwareBitMaker 
   5 *
   6 * This file may be distributed under the terms of the
   7 * GNU General Public License.
   8 *
   9 * Written Doug Thompson <norsk5@xmission.com>
  10 *
  11 */
  12
  13#include <linux/ctype.h>
  14#include <linux/module.h>
  15#include <linux/slab.h>
  16#include <linux/edac.h>
  17
  18#include "edac_core.h"
  19#include "edac_module.h"
  20
  21#define EDAC_DEVICE_SYMLINK     "device"
  22
  23#define to_edacdev(k) container_of(k, struct edac_device_ctl_info, kobj)
  24#define to_edacdev_attr(a) container_of(a, struct edacdev_attribute, attr)
  25
  26
  27/*
  28 * Set of edac_device_ctl_info attribute store/show functions
  29 */
  30
  31/* 'log_ue' */
  32static ssize_t edac_device_ctl_log_ue_show(struct edac_device_ctl_info
  33                                        *ctl_info, char *data)
  34{
  35        return sprintf(data, "%u\n", ctl_info->log_ue);
  36}
  37
  38static ssize_t edac_device_ctl_log_ue_store(struct edac_device_ctl_info
  39                                        *ctl_info, const char *data,
  40                                        size_t count)
  41{
  42        /* if parameter is zero, turn off flag, if non-zero turn on flag */
  43        ctl_info->log_ue = (simple_strtoul(data, NULL, 0) != 0);
  44
  45        return count;
  46}
  47
  48/* 'log_ce' */
  49static ssize_t edac_device_ctl_log_ce_show(struct edac_device_ctl_info
  50                                        *ctl_info, char *data)
  51{
  52        return sprintf(data, "%u\n", ctl_info->log_ce);
  53}
  54
  55static ssize_t edac_device_ctl_log_ce_store(struct edac_device_ctl_info
  56                                        *ctl_info, const char *data,
  57                                        size_t count)
  58{
  59        /* if parameter is zero, turn off flag, if non-zero turn on flag */
  60        ctl_info->log_ce = (simple_strtoul(data, NULL, 0) != 0);
  61
  62        return count;
  63}
  64
  65/* 'panic_on_ue' */
  66static ssize_t edac_device_ctl_panic_on_ue_show(struct edac_device_ctl_info
  67                                                *ctl_info, char *data)
  68{
  69        return sprintf(data, "%u\n", ctl_info->panic_on_ue);
  70}
  71
  72static ssize_t edac_device_ctl_panic_on_ue_store(struct edac_device_ctl_info
  73                                                 *ctl_info, const char *data,
  74                                                 size_t count)
  75{
  76        /* if parameter is zero, turn off flag, if non-zero turn on flag */
  77        ctl_info->panic_on_ue = (simple_strtoul(data, NULL, 0) != 0);
  78
  79        return count;
  80}
  81
  82/* 'poll_msec' show and store functions*/
  83static ssize_t edac_device_ctl_poll_msec_show(struct edac_device_ctl_info
  84                                        *ctl_info, char *data)
  85{
  86        return sprintf(data, "%u\n", ctl_info->poll_msec);
  87}
  88
  89static ssize_t edac_device_ctl_poll_msec_store(struct edac_device_ctl_info
  90                                        *ctl_info, const char *data,
  91                                        size_t count)
  92{
  93        unsigned long value;
  94
  95        /* get the value and enforce that it is non-zero, must be at least
  96         * one millisecond for the delay period, between scans
  97         * Then cancel last outstanding delay for the work request
  98         * and set a new one.
  99         */
 100        value = simple_strtoul(data, NULL, 0);
 101        edac_device_reset_delay_period(ctl_info, value);
 102
 103        return count;
 104}
 105
 106/* edac_device_ctl_info specific attribute structure */
 107struct ctl_info_attribute {
 108        struct attribute attr;
 109        ssize_t(*show) (struct edac_device_ctl_info *, char *);
 110        ssize_t(*store) (struct edac_device_ctl_info *, const char *, size_t);
 111};
 112
 113#define to_ctl_info(k) container_of(k, struct edac_device_ctl_info, kobj)
 114#define to_ctl_info_attr(a) container_of(a,struct ctl_info_attribute,attr)
 115
 116/* Function to 'show' fields from the edac_dev 'ctl_info' structure */
 117static ssize_t edac_dev_ctl_info_show(struct kobject *kobj,
 118                                struct attribute *attr, char *buffer)
 119{
 120        struct edac_device_ctl_info *edac_dev = to_ctl_info(kobj);
 121        struct ctl_info_attribute *ctl_info_attr = to_ctl_info_attr(attr);
 122
 123        if (ctl_info_attr->show)
 124                return ctl_info_attr->show(edac_dev, buffer);
 125        return -EIO;
 126}
 127
 128/* Function to 'store' fields into the edac_dev 'ctl_info' structure */
 129static ssize_t edac_dev_ctl_info_store(struct kobject *kobj,
 130                                struct attribute *attr,
 131                                const char *buffer, size_t count)
 132{
 133        struct edac_device_ctl_info *edac_dev = to_ctl_info(kobj);
 134        struct ctl_info_attribute *ctl_info_attr = to_ctl_info_attr(attr);
 135
 136        if (ctl_info_attr->store)
 137                return ctl_info_attr->store(edac_dev, buffer, count);
 138        return -EIO;
 139}
 140
 141/* edac_dev file operations for an 'ctl_info' */
 142static const struct sysfs_ops device_ctl_info_ops = {
 143        .show = edac_dev_ctl_info_show,
 144        .store = edac_dev_ctl_info_store
 145};
 146
 147#define CTL_INFO_ATTR(_name,_mode,_show,_store)        \
 148static struct ctl_info_attribute attr_ctl_info_##_name = {      \
 149        .attr = {.name = __stringify(_name), .mode = _mode },   \
 150        .show   = _show,                                        \
 151        .store  = _store,                                       \
 152};
 153
 154/* Declare the various ctl_info attributes here and their respective ops */
 155CTL_INFO_ATTR(log_ue, S_IRUGO | S_IWUSR,
 156        edac_device_ctl_log_ue_show, edac_device_ctl_log_ue_store);
 157CTL_INFO_ATTR(log_ce, S_IRUGO | S_IWUSR,
 158        edac_device_ctl_log_ce_show, edac_device_ctl_log_ce_store);
 159CTL_INFO_ATTR(panic_on_ue, S_IRUGO | S_IWUSR,
 160        edac_device_ctl_panic_on_ue_show,
 161        edac_device_ctl_panic_on_ue_store);
 162CTL_INFO_ATTR(poll_msec, S_IRUGO | S_IWUSR,
 163        edac_device_ctl_poll_msec_show, edac_device_ctl_poll_msec_store);
 164
 165/* Base Attributes of the EDAC_DEVICE ECC object */
 166static struct ctl_info_attribute *device_ctrl_attr[] = {
 167        &attr_ctl_info_panic_on_ue,
 168        &attr_ctl_info_log_ue,
 169        &attr_ctl_info_log_ce,
 170        &attr_ctl_info_poll_msec,
 171        NULL,
 172};
 173
 174/*
 175 * edac_device_ctrl_master_release
 176 *
 177 *      called when the reference count for the 'main' kobj
 178 *      for a edac_device control struct reaches zero
 179 *
 180 *      Reference count model:
 181 *              One 'main' kobject for each control structure allocated.
 182 *              That main kobj is initially set to one AND
 183 *              the reference count for the EDAC 'core' module is
 184 *              bumped by one, thus added 'keep in memory' dependency.
 185 *
 186 *              Each new internal kobj (in instances and blocks) then
 187 *              bumps the 'main' kobject.
 188 *
 189 *              When they are released their release functions decrement
 190 *              the 'main' kobj.
 191 *
 192 *              When the main kobj reaches zero (0) then THIS function
 193 *              is called which then decrements the EDAC 'core' module.
 194 *              When the module reference count reaches zero then the
 195 *              module no longer has dependency on keeping the release
 196 *              function code in memory and module can be unloaded.
 197 *
 198 *              This will support several control objects as well, each
 199 *              with its own 'main' kobj.
 200 */
 201static void edac_device_ctrl_master_release(struct kobject *kobj)
 202{
 203        struct edac_device_ctl_info *edac_dev = to_edacdev(kobj);
 204
 205        debugf4("%s() control index=%d\n", __func__, edac_dev->dev_idx);
 206
 207        /* decrement the EDAC CORE module ref count */
 208        module_put(edac_dev->owner);
 209
 210        /* free the control struct containing the 'main' kobj
 211         * passed in to this routine
 212         */
 213        kfree(edac_dev);
 214}
 215
 216/* ktype for the main (master) kobject */
 217static struct kobj_type ktype_device_ctrl = {
 218        .release = edac_device_ctrl_master_release,
 219        .sysfs_ops = &device_ctl_info_ops,
 220        .default_attrs = (struct attribute **)device_ctrl_attr,
 221};
 222
 223/*
 224 * edac_device_register_sysfs_main_kobj
 225 *
 226 *      perform the high level setup for the new edac_device instance
 227 *
 228 * Return:  0 SUCCESS
 229 *         !0 FAILURE
 230 */
 231int edac_device_register_sysfs_main_kobj(struct edac_device_ctl_info *edac_dev)
 232{
 233        struct sysdev_class *edac_class;
 234        int err;
 235
 236        debugf1("%s()\n", __func__);
 237
 238        /* get the /sys/devices/system/edac reference */
 239        edac_class = edac_get_sysfs_class();
 240        if (edac_class == NULL) {
 241                debugf1("%s() no edac_class error\n", __func__);
 242                err = -ENODEV;
 243                goto err_out;
 244        }
 245
 246        /* Point to the 'edac_class' this instance 'reports' to */
 247        edac_dev->edac_class = edac_class;
 248
 249        /* Init the devices's kobject */
 250        memset(&edac_dev->kobj, 0, sizeof(struct kobject));
 251
 252        /* Record which module 'owns' this control structure
 253         * and bump the ref count of the module
 254         */
 255        edac_dev->owner = THIS_MODULE;
 256
 257        if (!try_module_get(edac_dev->owner)) {
 258                err = -ENODEV;
 259                goto err_mod_get;
 260        }
 261
 262        /* register */
 263        err = kobject_init_and_add(&edac_dev->kobj, &ktype_device_ctrl,
 264                                   &edac_class->kset.kobj,
 265                                   "%s", edac_dev->name);
 266        if (err) {
 267                debugf1("%s()Failed to register '.../edac/%s'\n",
 268                        __func__, edac_dev->name);
 269                goto err_kobj_reg;
 270        }
 271        kobject_uevent(&edac_dev->kobj, KOBJ_ADD);
 272
 273        /* At this point, to 'free' the control struct,
 274         * edac_device_unregister_sysfs_main_kobj() must be used
 275         */
 276
 277        debugf4("%s() Registered '.../edac/%s' kobject\n",
 278                __func__, edac_dev->name);
 279
 280        return 0;
 281
 282        /* Error exit stack */
 283err_kobj_reg:
 284        module_put(edac_dev->owner);
 285
 286err_mod_get:
 287        edac_put_sysfs_class();
 288
 289err_out:
 290        return err;
 291}
 292
 293/*
 294 * edac_device_unregister_sysfs_main_kobj:
 295 *      the '..../edac/<name>' kobject
 296 */
 297void edac_device_unregister_sysfs_main_kobj(struct edac_device_ctl_info *dev)
 298{
 299        debugf0("%s()\n", __func__);
 300        debugf4("%s() name of kobject is: %s\n",
 301                __func__, kobject_name(&dev->kobj));
 302
 303        /*
 304         * Unregister the edac device's kobject and
 305         * allow for reference count to reach 0 at which point
 306         * the callback will be called to:
 307         *   a) module_put() this module
 308         *   b) 'kfree' the memory
 309         */
 310        kobject_put(&dev->kobj);
 311        edac_put_sysfs_class();
 312}
 313
 314/* edac_dev -> instance information */
 315
 316/*
 317 * Set of low-level instance attribute show functions
 318 */
 319static ssize_t instance_ue_count_show(struct edac_device_instance *instance,
 320                                char *data)
 321{
 322        return sprintf(data, "%u\n", instance->counters.ue_count);
 323}
 324
 325static ssize_t instance_ce_count_show(struct edac_device_instance *instance,
 326                                char *data)
 327{
 328        return sprintf(data, "%u\n", instance->counters.ce_count);
 329}
 330
 331#define to_instance(k) container_of(k, struct edac_device_instance, kobj)
 332#define to_instance_attr(a) container_of(a,struct instance_attribute,attr)
 333
 334/* DEVICE instance kobject release() function */
 335static void edac_device_ctrl_instance_release(struct kobject *kobj)
 336{
 337        struct edac_device_instance *instance;
 338
 339        debugf1("%s()\n", __func__);
 340
 341        /* map from this kobj to the main control struct
 342         * and then dec the main kobj count
 343         */
 344        instance = to_instance(kobj);
 345        kobject_put(&instance->ctl->kobj);
 346}
 347
 348/* instance specific attribute structure */
 349struct instance_attribute {
 350        struct attribute attr;
 351        ssize_t(*show) (struct edac_device_instance *, char *);
 352        ssize_t(*store) (struct edac_device_instance *, const char *, size_t);
 353};
 354
 355/* Function to 'show' fields from the edac_dev 'instance' structure */
 356static ssize_t edac_dev_instance_show(struct kobject *kobj,
 357                                struct attribute *attr, char *buffer)
 358{
 359        struct edac_device_instance *instance = to_instance(kobj);
 360        struct instance_attribute *instance_attr = to_instance_attr(attr);
 361
 362        if (instance_attr->show)
 363                return instance_attr->show(instance, buffer);
 364        return -EIO;
 365}
 366
 367/* Function to 'store' fields into the edac_dev 'instance' structure */
 368static ssize_t edac_dev_instance_store(struct kobject *kobj,
 369                                struct attribute *attr,
 370                                const char *buffer, size_t count)
 371{
 372        struct edac_device_instance *instance = to_instance(kobj);
 373        struct instance_attribute *instance_attr = to_instance_attr(attr);
 374
 375        if (instance_attr->store)
 376                return instance_attr->store(instance, buffer, count);
 377        return -EIO;
 378}
 379
 380/* edac_dev file operations for an 'instance' */
 381static const struct sysfs_ops device_instance_ops = {
 382        .show = edac_dev_instance_show,
 383        .store = edac_dev_instance_store
 384};
 385
 386#define INSTANCE_ATTR(_name,_mode,_show,_store)        \
 387static struct instance_attribute attr_instance_##_name = {      \
 388        .attr = {.name = __stringify(_name), .mode = _mode },   \
 389        .show   = _show,                                        \
 390        .store  = _store,                                       \
 391};
 392
 393/*
 394 * Define attributes visible for the edac_device instance object
 395 *      Each contains a pointer to a show and an optional set
 396 *      function pointer that does the low level output/input
 397 */
 398INSTANCE_ATTR(ce_count, S_IRUGO, instance_ce_count_show, NULL);
 399INSTANCE_ATTR(ue_count, S_IRUGO, instance_ue_count_show, NULL);
 400
 401/* list of edac_dev 'instance' attributes */
 402static struct instance_attribute *device_instance_attr[] = {
 403        &attr_instance_ce_count,
 404        &attr_instance_ue_count,
 405        NULL,
 406};
 407
 408/* The 'ktype' for each edac_dev 'instance' */
 409static struct kobj_type ktype_instance_ctrl = {
 410        .release = edac_device_ctrl_instance_release,
 411        .sysfs_ops = &device_instance_ops,
 412        .default_attrs = (struct attribute **)device_instance_attr,
 413};
 414
 415/* edac_dev -> instance -> block information */
 416
 417#define to_block(k) container_of(k, struct edac_device_block, kobj)
 418#define to_block_attr(a) \
 419        container_of(a, struct edac_dev_sysfs_block_attribute, attr)
 420
 421/*
 422 * Set of low-level block attribute show functions
 423 */
 424static ssize_t block_ue_count_show(struct kobject *kobj,
 425                                        struct attribute *attr, char *data)
 426{
 427        struct edac_device_block *block = to_block(kobj);
 428
 429        return sprintf(data, "%u\n", block->counters.ue_count);
 430}
 431
 432static ssize_t block_ce_count_show(struct kobject *kobj,
 433                                        struct attribute *attr, char *data)
 434{
 435        struct edac_device_block *block = to_block(kobj);
 436
 437        return sprintf(data, "%u\n", block->counters.ce_count);
 438}
 439
 440/* DEVICE block kobject release() function */
 441static void edac_device_ctrl_block_release(struct kobject *kobj)
 442{
 443        struct edac_device_block *block;
 444
 445        debugf1("%s()\n", __func__);
 446
 447        /* get the container of the kobj */
 448        block = to_block(kobj);
 449
 450        /* map from 'block kobj' to 'block->instance->controller->main_kobj'
 451         * now 'release' the block kobject
 452         */
 453        kobject_put(&block->instance->ctl->kobj);
 454}
 455
 456
 457/* Function to 'show' fields from the edac_dev 'block' structure */
 458static ssize_t edac_dev_block_show(struct kobject *kobj,
 459                                struct attribute *attr, char *buffer)
 460{
 461        struct edac_dev_sysfs_block_attribute *block_attr =
 462                                                to_block_attr(attr);
 463
 464        if (block_attr->show)
 465                return block_attr->show(kobj, attr, buffer);
 466        return -EIO;
 467}
 468
 469/* Function to 'store' fields into the edac_dev 'block' structure */
 470static ssize_t edac_dev_block_store(struct kobject *kobj,
 471                                struct attribute *attr,
 472                                const char *buffer, size_t count)
 473{
 474        struct edac_dev_sysfs_block_attribute *block_attr;
 475
 476        block_attr = to_block_attr(attr);
 477
 478        if (block_attr->store)
 479                return block_attr->store(kobj, attr, buffer, count);
 480        return -EIO;
 481}
 482
 483/* edac_dev file operations for a 'block' */
 484static const struct sysfs_ops device_block_ops = {
 485        .show = edac_dev_block_show,
 486        .store = edac_dev_block_store
 487};
 488
 489#define BLOCK_ATTR(_name,_mode,_show,_store)        \
 490static struct edac_dev_sysfs_block_attribute attr_block_##_name = {     \
 491        .attr = {.name = __stringify(_name), .mode = _mode },   \
 492        .show   = _show,                                        \
 493        .store  = _store,                                       \
 494};
 495
 496BLOCK_ATTR(ce_count, S_IRUGO, block_ce_count_show, NULL);
 497BLOCK_ATTR(ue_count, S_IRUGO, block_ue_count_show, NULL);
 498
 499/* list of edac_dev 'block' attributes */
 500static struct edac_dev_sysfs_block_attribute *device_block_attr[] = {
 501        &attr_block_ce_count,
 502        &attr_block_ue_count,
 503        NULL,
 504};
 505
 506/* The 'ktype' for each edac_dev 'block' */
 507static struct kobj_type ktype_block_ctrl = {
 508        .release = edac_device_ctrl_block_release,
 509        .sysfs_ops = &device_block_ops,
 510        .default_attrs = (struct attribute **)device_block_attr,
 511};
 512
 513/* block ctor/dtor  code */
 514
 515/*
 516 * edac_device_create_block
 517 */
 518static int edac_device_create_block(struct edac_device_ctl_info *edac_dev,
 519                                struct edac_device_instance *instance,
 520                                struct edac_device_block *block)
 521{
 522        int i;
 523        int err;
 524        struct edac_dev_sysfs_block_attribute *sysfs_attrib;
 525        struct kobject *main_kobj;
 526
 527        debugf4("%s() Instance '%s' inst_p=%p  block '%s'  block_p=%p\n",
 528                __func__, instance->name, instance, block->name, block);
 529        debugf4("%s() block kobj=%p  block kobj->parent=%p\n",
 530                __func__, &block->kobj, &block->kobj.parent);
 531
 532        /* init this block's kobject */
 533        memset(&block->kobj, 0, sizeof(struct kobject));
 534
 535        /* bump the main kobject's reference count for this controller
 536         * and this instance is dependant on the main
 537         */
 538        main_kobj = kobject_get(&edac_dev->kobj);
 539        if (!main_kobj) {
 540                err = -ENODEV;
 541                goto err_out;
 542        }
 543
 544        /* Add this block's kobject */
 545        err = kobject_init_and_add(&block->kobj, &ktype_block_ctrl,
 546                                   &instance->kobj,
 547                                   "%s", block->name);
 548        if (err) {
 549                debugf1("%s() Failed to register instance '%s'\n",
 550                        __func__, block->name);
 551                kobject_put(main_kobj);
 552                err = -ENODEV;
 553                goto err_out;
 554        }
 555
 556        /* If there are driver level block attributes, then added them
 557         * to the block kobject
 558         */
 559        sysfs_attrib = block->block_attributes;
 560        if (sysfs_attrib && block->nr_attribs) {
 561                for (i = 0; i < block->nr_attribs; i++, sysfs_attrib++) {
 562
 563                        debugf4("%s() creating block attrib='%s' "
 564                                "attrib->%p to kobj=%p\n",
 565                                __func__,
 566                                sysfs_attrib->attr.name,
 567                                sysfs_attrib, &block->kobj);
 568
 569                        /* Create each block_attribute file */
 570                        err = sysfs_create_file(&block->kobj,
 571                                &sysfs_attrib->attr);
 572                        if (err)
 573                                goto err_on_attrib;
 574                }
 575        }
 576        kobject_uevent(&block->kobj, KOBJ_ADD);
 577
 578        return 0;
 579
 580        /* Error unwind stack */
 581err_on_attrib:
 582        kobject_put(&block->kobj);
 583
 584err_out:
 585        return err;
 586}
 587
 588/*
 589 * edac_device_delete_block(edac_dev,block);
 590 */
 591static void edac_device_delete_block(struct edac_device_ctl_info *edac_dev,
 592                                struct edac_device_block *block)
 593{
 594        struct edac_dev_sysfs_block_attribute *sysfs_attrib;
 595        int i;
 596
 597        /* if this block has 'attributes' then we need to iterate over the list
 598         * and 'remove' the attributes on this block
 599         */
 600        sysfs_attrib = block->block_attributes;
 601        if (sysfs_attrib && block->nr_attribs) {
 602                for (i = 0; i < block->nr_attribs; i++, sysfs_attrib++) {
 603
 604                        /* remove each block_attrib file */
 605                        sysfs_remove_file(&block->kobj,
 606                                (struct attribute *) sysfs_attrib);
 607                }
 608        }
 609
 610        /* unregister this block's kobject, SEE:
 611         *      edac_device_ctrl_block_release() callback operation
 612         */
 613        kobject_put(&block->kobj);
 614}
 615
 616/* instance ctor/dtor code */
 617
 618/*
 619 * edac_device_create_instance
 620 *      create just one instance of an edac_device 'instance'
 621 */
 622static int edac_device_create_instance(struct edac_device_ctl_info *edac_dev,
 623                                int idx)
 624{
 625        int i, j;
 626        int err;
 627        struct edac_device_instance *instance;
 628        struct kobject *main_kobj;
 629
 630        instance = &edac_dev->instances[idx];
 631
 632        /* Init the instance's kobject */
 633        memset(&instance->kobj, 0, sizeof(struct kobject));
 634
 635        instance->ctl = edac_dev;
 636
 637        /* bump the main kobject's reference count for this controller
 638         * and this instance is dependant on the main
 639         */
 640        main_kobj = kobject_get(&edac_dev->kobj);
 641        if (!main_kobj) {
 642                err = -ENODEV;
 643                goto err_out;
 644        }
 645
 646        /* Formally register this instance's kobject under the edac_device */
 647        err = kobject_init_and_add(&instance->kobj, &ktype_instance_ctrl,
 648                                   &edac_dev->kobj, "%s", instance->name);
 649        if (err != 0) {
 650                debugf2("%s() Failed to register instance '%s'\n",
 651                        __func__, instance->name);
 652                kobject_put(main_kobj);
 653                goto err_out;
 654        }
 655
 656        debugf4("%s() now register '%d' blocks for instance %d\n",
 657                __func__, instance->nr_blocks, idx);
 658
 659        /* register all blocks of this instance */
 660        for (i = 0; i < instance->nr_blocks; i++) {
 661                err = edac_device_create_block(edac_dev, instance,
 662                                                &instance->blocks[i]);
 663                if (err) {
 664                        /* If any fail, remove all previous ones */
 665                        for (j = 0; j < i; j++)
 666                                edac_device_delete_block(edac_dev,
 667                                                        &instance->blocks[j]);
 668                        goto err_release_instance_kobj;
 669                }
 670        }
 671        kobject_uevent(&instance->kobj, KOBJ_ADD);
 672
 673        debugf4("%s() Registered instance %d '%s' kobject\n",
 674                __func__, idx, instance->name);
 675
 676        return 0;
 677
 678        /* error unwind stack */
 679err_release_instance_kobj:
 680        kobject_put(&instance->kobj);
 681
 682err_out:
 683        return err;
 684}
 685
 686/*
 687 * edac_device_remove_instance
 688 *      remove an edac_device instance
 689 */
 690static void edac_device_delete_instance(struct edac_device_ctl_info *edac_dev,
 691                                        int idx)
 692{
 693        struct edac_device_instance *instance;
 694        int i;
 695
 696        instance = &edac_dev->instances[idx];
 697
 698        /* unregister all blocks in this instance */
 699        for (i = 0; i < instance->nr_blocks; i++)
 700                edac_device_delete_block(edac_dev, &instance->blocks[i]);
 701
 702        /* unregister this instance's kobject, SEE:
 703         *      edac_device_ctrl_instance_release() for callback operation
 704         */
 705        kobject_put(&instance->kobj);
 706}
 707
 708/*
 709 * edac_device_create_instances
 710 *      create the first level of 'instances' for this device
 711 *      (ie  'cache' might have 'cache0', 'cache1', 'cache2', etc
 712 */
 713static int edac_device_create_instances(struct edac_device_ctl_info *edac_dev)
 714{
 715        int i, j;
 716        int err;
 717
 718        debugf0("%s()\n", __func__);
 719
 720        /* iterate over creation of the instances */
 721        for (i = 0; i < edac_dev->nr_instances; i++) {
 722                err = edac_device_create_instance(edac_dev, i);
 723                if (err) {
 724                        /* unwind previous instances on error */
 725                        for (j = 0; j < i; j++)
 726                                edac_device_delete_instance(edac_dev, j);
 727                        return err;
 728                }
 729        }
 730
 731        return 0;
 732}
 733
 734/*
 735 * edac_device_delete_instances(edac_dev);
 736 *      unregister all the kobjects of the instances
 737 */
 738static void edac_device_delete_instances(struct edac_device_ctl_info *edac_dev)
 739{
 740        int i;
 741
 742        /* iterate over creation of the instances */
 743        for (i = 0; i < edac_dev->nr_instances; i++)
 744                edac_device_delete_instance(edac_dev, i);
 745}
 746
 747/* edac_dev sysfs ctor/dtor  code */
 748
 749/*
 750 * edac_device_add_main_sysfs_attributes
 751 *      add some attributes to this instance's main kobject
 752 */
 753static int edac_device_add_main_sysfs_attributes(
 754                        struct edac_device_ctl_info *edac_dev)
 755{
 756        struct edac_dev_sysfs_attribute *sysfs_attrib;
 757        int err = 0;
 758
 759        sysfs_attrib = edac_dev->sysfs_attributes;
 760        if (sysfs_attrib) {
 761                /* iterate over the array and create an attribute for each
 762                 * entry in the list
 763                 */
 764                while (sysfs_attrib->attr.name != NULL) {
 765                        err = sysfs_create_file(&edac_dev->kobj,
 766                                (struct attribute*) sysfs_attrib);
 767                        if (err)
 768                                goto err_out;
 769
 770                        sysfs_attrib++;
 771                }
 772        }
 773
 774err_out:
 775        return err;
 776}
 777
 778/*
 779 * edac_device_remove_main_sysfs_attributes
 780 *      remove any attributes to this instance's main kobject
 781 */
 782static void edac_device_remove_main_sysfs_attributes(
 783                        struct edac_device_ctl_info *edac_dev)
 784{
 785        struct edac_dev_sysfs_attribute *sysfs_attrib;
 786
 787        /* if there are main attributes, defined, remove them. First,
 788         * point to the start of the array and iterate over it
 789         * removing each attribute listed from this device's instance's kobject
 790         */
 791        sysfs_attrib = edac_dev->sysfs_attributes;
 792        if (sysfs_attrib) {
 793                while (sysfs_attrib->attr.name != NULL) {
 794                        sysfs_remove_file(&edac_dev->kobj,
 795                                        (struct attribute *) sysfs_attrib);
 796                        sysfs_attrib++;
 797                }
 798        }
 799}
 800
 801/*
 802 * edac_device_create_sysfs() Constructor
 803 *
 804 * accept a created edac_device control structure
 805 * and 'export' it to sysfs. The 'main' kobj should already have been
 806 * created. 'instance' and 'block' kobjects should be registered
 807 * along with any 'block' attributes from the low driver. In addition,
 808 * the main attributes (if any) are connected to the main kobject of
 809 * the control structure.
 810 *
 811 * Return:
 812 *      0       Success
 813 *      !0      Failure
 814 */
 815int edac_device_create_sysfs(struct edac_device_ctl_info *edac_dev)
 816{
 817        int err;
 818        struct kobject *edac_kobj = &edac_dev->kobj;
 819
 820        debugf0("%s() idx=%d\n", __func__, edac_dev->dev_idx);
 821
 822        /*  go create any main attributes callers wants */
 823        err = edac_device_add_main_sysfs_attributes(edac_dev);
 824        if (err) {
 825                debugf0("%s() failed to add sysfs attribs\n", __func__);
 826                goto err_out;
 827        }
 828
 829        /* create a symlink from the edac device
 830         * to the platform 'device' being used for this
 831         */
 832        err = sysfs_create_link(edac_kobj,
 833                                &edac_dev->dev->kobj, EDAC_DEVICE_SYMLINK);
 834        if (err) {
 835                debugf0("%s() sysfs_create_link() returned err= %d\n",
 836                        __func__, err);
 837                goto err_remove_main_attribs;
 838        }
 839
 840        /* Create the first level instance directories
 841         * In turn, the nested blocks beneath the instances will
 842         * be registered as well
 843         */
 844        err = edac_device_create_instances(edac_dev);
 845        if (err) {
 846                debugf0("%s() edac_device_create_instances() "
 847                        "returned err= %d\n", __func__, err);
 848                goto err_remove_link;
 849        }
 850
 851
 852        debugf4("%s() create-instances done, idx=%d\n",
 853                __func__, edac_dev->dev_idx);
 854
 855        return 0;
 856
 857        /* Error unwind stack */
 858err_remove_link:
 859        /* remove the sym link */
 860        sysfs_remove_link(&edac_dev->kobj, EDAC_DEVICE_SYMLINK);
 861
 862err_remove_main_attribs:
 863        edac_device_remove_main_sysfs_attributes(edac_dev);
 864
 865err_out:
 866        return err;
 867}
 868
 869/*
 870 * edac_device_remove_sysfs() destructor
 871 *
 872 * given an edac_device struct, tear down the kobject resources
 873 */
 874void edac_device_remove_sysfs(struct edac_device_ctl_info *edac_dev)
 875{
 876        debugf0("%s()\n", __func__);
 877
 878        /* remove any main attributes for this device */
 879        edac_device_remove_main_sysfs_attributes(edac_dev);
 880
 881        /* remove the device sym link */
 882        sysfs_remove_link(&edac_dev->kobj, EDAC_DEVICE_SYMLINK);
 883
 884        /* walk the instance/block kobject tree, deconstructing it */
 885        edac_device_delete_instances(edac_dev);
 886}
 887