drivers/edac/edac_device_sysfs.c

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