drivers/edac/edac_device_sysfs.c

   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' */
  32 static 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
  38 static 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' */
  49 static 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
  55 static 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' */
  66 static 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
  72 static 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*/
  83 static 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
  89 static 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 */
 107 struct 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 */
 117 static 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 */
 129 static 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' */
 142 static 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)        \
 148 static 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 */
 155 CTL_INFO_ATTR(log_ue, S_IRUGO | S_IWUSR,
 156         edac_device_ctl_log_ue_show, edac_device_ctl_log_ue_store);
 157 CTL_INFO_ATTR(log_ce, S_IRUGO | S_IWUSR,
 158         edac_device_ctl_log_ce_show, edac_device_ctl_log_ce_store);
 159 CTL_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);
 162 CTL_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 */
 166 static 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  */
 201 static 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 */
 217 static 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  */
 231 int 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 */
 283 err_kobj_reg:
 284         module_put(edac_dev->owner);
 285
 286 err_mod_get:
 287         edac_put_sysfs_class();
 288
 289 err_out:
 290         return err;
 291 }
 292
 293 /*
 294  * edac_device_unregister_sysfs_main_kobj:
 295  *      the '..../edac/<name>' kobject
 296  */
 297 void 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  */
 319 static 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
 325 static 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 */
 335 static 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 */
 349 struct 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 */
 356 static 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 */
 368 static 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' */
 381 static 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)        \
 387 static 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  */
 398 INSTANCE_ATTR(ce_count, S_IRUGO, instance_ce_count_show, NULL);
 399 INSTANCE_ATTR(ue_count, S_IRUGO, instance_ue_count_show, NULL);
 400
 401 /* list of edac_dev 'instance' attributes */
 402 static 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' */
 409 static 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  */
 424 static 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
 432 static 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 */
 441 static 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 */
 458 static 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 */
 470 static 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' */
 484 static 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)        \
 490 static struct edac_dev_sysfs_block_attribute attr_block_##_name = {     \
 491         .attr = {.name = __stringify(_name), .mode = _mode },   \
 492         .show   = _show,                                        \
 493         .store  = _store,                                       \
 494 };
 495
 496 BLOCK_ATTR(ce_count, S_IRUGO, block_ce_count_show, NULL);
 497 BLOCK_ATTR(ue_count, S_IRUGO, block_ue_count_show, NULL);
 498
 499 /* list of edac_dev 'block' attributes */
 500 static 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' */
 507 static 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  */
 518 static 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 dependent 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 */
 581 err_on_attrib:
 582         kobject_put(&block->kobj);
 583
 584 err_out:
 585         return err;
 586 }
 587
 588 /*
 589  * edac_device_delete_block(edac_dev,block);
 590  */
 591 static 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  */
 622 static 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 dependent 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 */
 679 err_release_instance_kobj:
 680         kobject_put(&instance->kobj);
 681
 682 err_out:
 683         return err;
 684 }
 685
 686 /*
 687  * edac_device_remove_instance
 688  *      remove an edac_device instance
 689  */
 690 static 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  */
 713 static 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  */
 738 static 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  */
 753 static 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
 774 err_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  */
 782 static 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  */
 815 int 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 */
 858 err_remove_link:
 859         /* remove the sym link */
 860         sysfs_remove_link(&edac_dev->kobj, EDAC_DEVICE_SYMLINK);
 861
 862 err_remove_main_attribs:
 863         edac_device_remove_main_sysfs_attributes(edac_dev);
 864
 865 err_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  */
 874 void 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 }