edac: Don't add __func__ or __FILE__ for debugf[0-9] msgs
[linux-3.10.git] / 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_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("control index=%d\n", 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 bus_type *edac_subsys;
234         int err;
235
236         debugf1("\n");
237
238         /* get the /sys/devices/system/edac reference */
239         edac_subsys = edac_get_sysfs_subsys();
240         if (edac_subsys == NULL) {
241                 debugf1("no edac_subsys error\n");
242                 err = -ENODEV;
243                 goto err_out;
244         }
245
246         /* Point to the 'edac_subsys' this instance 'reports' to */
247         edac_dev->edac_subsys = edac_subsys;
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_subsys->dev_root->kobj,
265                                    "%s", edac_dev->name);
266         if (err) {
267                 debugf1("Failed to register '.../edac/%s'\n",
268                         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("Registered '.../edac/%s' kobject\n",
278                 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_subsys();
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("\n");
300         debugf4("name of kobject is: %s\n",
301                 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_subsys();
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("\n");
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("\n");
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("Instance '%s' inst_p=%p  block '%s'  block_p=%p\n",
528                 instance->name, instance, block->name, block);
529         debugf4("block kobj=%p  block kobj->parent=%p\n",
530                 &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("Failed to register instance '%s'\n",
550                         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("creating block attrib='%s' "
564                                 "attrib->%p to kobj=%p\n",
565                                 sysfs_attrib->attr.name,
566                                 sysfs_attrib, &block->kobj);
567
568                         /* Create each block_attribute file */
569                         err = sysfs_create_file(&block->kobj,
570                                 &sysfs_attrib->attr);
571                         if (err)
572                                 goto err_on_attrib;
573                 }
574         }
575         kobject_uevent(&block->kobj, KOBJ_ADD);
576
577         return 0;
578
579         /* Error unwind stack */
580 err_on_attrib:
581         kobject_put(&block->kobj);
582
583 err_out:
584         return err;
585 }
586
587 /*
588  * edac_device_delete_block(edac_dev,block);
589  */
590 static void edac_device_delete_block(struct edac_device_ctl_info *edac_dev,
591                                 struct edac_device_block *block)
592 {
593         struct edac_dev_sysfs_block_attribute *sysfs_attrib;
594         int i;
595
596         /* if this block has 'attributes' then we need to iterate over the list
597          * and 'remove' the attributes on this block
598          */
599         sysfs_attrib = block->block_attributes;
600         if (sysfs_attrib && block->nr_attribs) {
601                 for (i = 0; i < block->nr_attribs; i++, sysfs_attrib++) {
602
603                         /* remove each block_attrib file */
604                         sysfs_remove_file(&block->kobj,
605                                 (struct attribute *) sysfs_attrib);
606                 }
607         }
608
609         /* unregister this block's kobject, SEE:
610          *      edac_device_ctrl_block_release() callback operation
611          */
612         kobject_put(&block->kobj);
613 }
614
615 /* instance ctor/dtor code */
616
617 /*
618  * edac_device_create_instance
619  *      create just one instance of an edac_device 'instance'
620  */
621 static int edac_device_create_instance(struct edac_device_ctl_info *edac_dev,
622                                 int idx)
623 {
624         int i, j;
625         int err;
626         struct edac_device_instance *instance;
627         struct kobject *main_kobj;
628
629         instance = &edac_dev->instances[idx];
630
631         /* Init the instance's kobject */
632         memset(&instance->kobj, 0, sizeof(struct kobject));
633
634         instance->ctl = edac_dev;
635
636         /* bump the main kobject's reference count for this controller
637          * and this instance is dependent on the main
638          */
639         main_kobj = kobject_get(&edac_dev->kobj);
640         if (!main_kobj) {
641                 err = -ENODEV;
642                 goto err_out;
643         }
644
645         /* Formally register this instance's kobject under the edac_device */
646         err = kobject_init_and_add(&instance->kobj, &ktype_instance_ctrl,
647                                    &edac_dev->kobj, "%s", instance->name);
648         if (err != 0) {
649                 debugf2("Failed to register instance '%s'\n",
650                         instance->name);
651                 kobject_put(main_kobj);
652                 goto err_out;
653         }
654
655         debugf4("now register '%d' blocks for instance %d\n",
656                 instance->nr_blocks, idx);
657
658         /* register all blocks of this instance */
659         for (i = 0; i < instance->nr_blocks; i++) {
660                 err = edac_device_create_block(edac_dev, instance,
661                                                 &instance->blocks[i]);
662                 if (err) {
663                         /* If any fail, remove all previous ones */
664                         for (j = 0; j < i; j++)
665                                 edac_device_delete_block(edac_dev,
666                                                         &instance->blocks[j]);
667                         goto err_release_instance_kobj;
668                 }
669         }
670         kobject_uevent(&instance->kobj, KOBJ_ADD);
671
672         debugf4("Registered instance %d '%s' kobject\n",
673                 idx, instance->name);
674
675         return 0;
676
677         /* error unwind stack */
678 err_release_instance_kobj:
679         kobject_put(&instance->kobj);
680
681 err_out:
682         return err;
683 }
684
685 /*
686  * edac_device_remove_instance
687  *      remove an edac_device instance
688  */
689 static void edac_device_delete_instance(struct edac_device_ctl_info *edac_dev,
690                                         int idx)
691 {
692         struct edac_device_instance *instance;
693         int i;
694
695         instance = &edac_dev->instances[idx];
696
697         /* unregister all blocks in this instance */
698         for (i = 0; i < instance->nr_blocks; i++)
699                 edac_device_delete_block(edac_dev, &instance->blocks[i]);
700
701         /* unregister this instance's kobject, SEE:
702          *      edac_device_ctrl_instance_release() for callback operation
703          */
704         kobject_put(&instance->kobj);
705 }
706
707 /*
708  * edac_device_create_instances
709  *      create the first level of 'instances' for this device
710  *      (ie  'cache' might have 'cache0', 'cache1', 'cache2', etc
711  */
712 static int edac_device_create_instances(struct edac_device_ctl_info *edac_dev)
713 {
714         int i, j;
715         int err;
716
717         debugf0("\n");
718
719         /* iterate over creation of the instances */
720         for (i = 0; i < edac_dev->nr_instances; i++) {
721                 err = edac_device_create_instance(edac_dev, i);
722                 if (err) {
723                         /* unwind previous instances on error */
724                         for (j = 0; j < i; j++)
725                                 edac_device_delete_instance(edac_dev, j);
726                         return err;
727                 }
728         }
729
730         return 0;
731 }
732
733 /*
734  * edac_device_delete_instances(edac_dev);
735  *      unregister all the kobjects of the instances
736  */
737 static void edac_device_delete_instances(struct edac_device_ctl_info *edac_dev)
738 {
739         int i;
740
741         /* iterate over creation of the instances */
742         for (i = 0; i < edac_dev->nr_instances; i++)
743                 edac_device_delete_instance(edac_dev, i);
744 }
745
746 /* edac_dev sysfs ctor/dtor  code */
747
748 /*
749  * edac_device_add_main_sysfs_attributes
750  *      add some attributes to this instance's main kobject
751  */
752 static int edac_device_add_main_sysfs_attributes(
753                         struct edac_device_ctl_info *edac_dev)
754 {
755         struct edac_dev_sysfs_attribute *sysfs_attrib;
756         int err = 0;
757
758         sysfs_attrib = edac_dev->sysfs_attributes;
759         if (sysfs_attrib) {
760                 /* iterate over the array and create an attribute for each
761                  * entry in the list
762                  */
763                 while (sysfs_attrib->attr.name != NULL) {
764                         err = sysfs_create_file(&edac_dev->kobj,
765                                 (struct attribute*) sysfs_attrib);
766                         if (err)
767                                 goto err_out;
768
769                         sysfs_attrib++;
770                 }
771         }
772
773 err_out:
774         return err;
775 }
776
777 /*
778  * edac_device_remove_main_sysfs_attributes
779  *      remove any attributes to this instance's main kobject
780  */
781 static void edac_device_remove_main_sysfs_attributes(
782                         struct edac_device_ctl_info *edac_dev)
783 {
784         struct edac_dev_sysfs_attribute *sysfs_attrib;
785
786         /* if there are main attributes, defined, remove them. First,
787          * point to the start of the array and iterate over it
788          * removing each attribute listed from this device's instance's kobject
789          */
790         sysfs_attrib = edac_dev->sysfs_attributes;
791         if (sysfs_attrib) {
792                 while (sysfs_attrib->attr.name != NULL) {
793                         sysfs_remove_file(&edac_dev->kobj,
794                                         (struct attribute *) sysfs_attrib);
795                         sysfs_attrib++;
796                 }
797         }
798 }
799
800 /*
801  * edac_device_create_sysfs() Constructor
802  *
803  * accept a created edac_device control structure
804  * and 'export' it to sysfs. The 'main' kobj should already have been
805  * created. 'instance' and 'block' kobjects should be registered
806  * along with any 'block' attributes from the low driver. In addition,
807  * the main attributes (if any) are connected to the main kobject of
808  * the control structure.
809  *
810  * Return:
811  *      0       Success
812  *      !0      Failure
813  */
814 int edac_device_create_sysfs(struct edac_device_ctl_info *edac_dev)
815 {
816         int err;
817         struct kobject *edac_kobj = &edac_dev->kobj;
818
819         debugf0("idx=%d\n", edac_dev->dev_idx);
820
821         /*  go create any main attributes callers wants */
822         err = edac_device_add_main_sysfs_attributes(edac_dev);
823         if (err) {
824                 debugf0("failed to add sysfs attribs\n");
825                 goto err_out;
826         }
827
828         /* create a symlink from the edac device
829          * to the platform 'device' being used for this
830          */
831         err = sysfs_create_link(edac_kobj,
832                                 &edac_dev->dev->kobj, EDAC_DEVICE_SYMLINK);
833         if (err) {
834                 debugf0("sysfs_create_link() returned err= %d\n",
835                         err);
836                 goto err_remove_main_attribs;
837         }
838
839         /* Create the first level instance directories
840          * In turn, the nested blocks beneath the instances will
841          * be registered as well
842          */
843         err = edac_device_create_instances(edac_dev);
844         if (err) {
845                 debugf0("edac_device_create_instances() "
846                         "returned err= %d\n", err);
847                 goto err_remove_link;
848         }
849
850
851         debugf4("create-instances done, idx=%d\n",
852                 edac_dev->dev_idx);
853
854         return 0;
855
856         /* Error unwind stack */
857 err_remove_link:
858         /* remove the sym link */
859         sysfs_remove_link(&edac_dev->kobj, EDAC_DEVICE_SYMLINK);
860
861 err_remove_main_attribs:
862         edac_device_remove_main_sysfs_attributes(edac_dev);
863
864 err_out:
865         return err;
866 }
867
868 /*
869  * edac_device_remove_sysfs() destructor
870  *
871  * given an edac_device struct, tear down the kobject resources
872  */
873 void edac_device_remove_sysfs(struct edac_device_ctl_info *edac_dev)
874 {
875         debugf0("\n");
876
877         /* remove any main attributes for this device */
878         edac_device_remove_main_sysfs_attributes(edac_dev);
879
880         /* remove the device sym link */
881         sysfs_remove_link(&edac_dev->kobj, EDAC_DEVICE_SYMLINK);
882
883         /* walk the instance/block kobject tree, deconstructing it */
884         edac_device_delete_instances(edac_dev);
885 }