drivers/edac/edac_device_sysfs.c

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