edac_mc.c revision 079708b9173595bf74b31b14c36e946359ae6c7e
1/* 2 * edac_mc kernel module 3 * (C) 2005, 2006 Linux Networx (http://lnxi.com) 4 * This file may be distributed under the terms of the 5 * GNU General Public License. 6 * 7 * Written by Thayne Harbaugh 8 * Based on work by Dan Hollis <goemon at anime dot net> and others. 9 * http://www.anime.net/~goemon/linux-ecc/ 10 * 11 * Modified by Dave Peterson and Doug Thompson 12 * 13 */ 14 15#include <linux/module.h> 16#include <linux/proc_fs.h> 17#include <linux/kernel.h> 18#include <linux/types.h> 19#include <linux/smp.h> 20#include <linux/init.h> 21#include <linux/sysctl.h> 22#include <linux/highmem.h> 23#include <linux/timer.h> 24#include <linux/slab.h> 25#include <linux/jiffies.h> 26#include <linux/spinlock.h> 27#include <linux/list.h> 28#include <linux/sysdev.h> 29#include <linux/ctype.h> 30#include <linux/edac.h> 31#include <asm/uaccess.h> 32#include <asm/page.h> 33#include <asm/edac.h> 34#include "edac_core.h" 35#include "edac_module.h" 36 37/* lock to memory controller's control array */ 38static DEFINE_MUTEX(mem_ctls_mutex); 39static struct list_head mc_devices = LIST_HEAD_INIT(mc_devices); 40 41#ifdef CONFIG_EDAC_DEBUG 42 43static void edac_mc_dump_channel(struct channel_info *chan) 44{ 45 debugf4("\tchannel = %p\n", chan); 46 debugf4("\tchannel->chan_idx = %d\n", chan->chan_idx); 47 debugf4("\tchannel->ce_count = %d\n", chan->ce_count); 48 debugf4("\tchannel->label = '%s'\n", chan->label); 49 debugf4("\tchannel->csrow = %p\n\n", chan->csrow); 50} 51 52static void edac_mc_dump_csrow(struct csrow_info *csrow) 53{ 54 debugf4("\tcsrow = %p\n", csrow); 55 debugf4("\tcsrow->csrow_idx = %d\n", csrow->csrow_idx); 56 debugf4("\tcsrow->first_page = 0x%lx\n", csrow->first_page); 57 debugf4("\tcsrow->last_page = 0x%lx\n", csrow->last_page); 58 debugf4("\tcsrow->page_mask = 0x%lx\n", csrow->page_mask); 59 debugf4("\tcsrow->nr_pages = 0x%x\n", csrow->nr_pages); 60 debugf4("\tcsrow->nr_channels = %d\n", csrow->nr_channels); 61 debugf4("\tcsrow->channels = %p\n", csrow->channels); 62 debugf4("\tcsrow->mci = %p\n\n", csrow->mci); 63} 64 65static void edac_mc_dump_mci(struct mem_ctl_info *mci) 66{ 67 debugf3("\tmci = %p\n", mci); 68 debugf3("\tmci->mtype_cap = %lx\n", mci->mtype_cap); 69 debugf3("\tmci->edac_ctl_cap = %lx\n", mci->edac_ctl_cap); 70 debugf3("\tmci->edac_cap = %lx\n", mci->edac_cap); 71 debugf4("\tmci->edac_check = %p\n", mci->edac_check); 72 debugf3("\tmci->nr_csrows = %d, csrows = %p\n", 73 mci->nr_csrows, mci->csrows); 74 debugf3("\tdev = %p\n", mci->dev); 75 debugf3("\tmod_name:ctl_name = %s:%s\n", mci->mod_name, mci->ctl_name); 76 debugf3("\tpvt_info = %p\n\n", mci->pvt_info); 77} 78 79#endif /* CONFIG_EDAC_DEBUG */ 80 81/* 'ptr' points to a possibly unaligned item X such that sizeof(X) is 'size'. 82 * Adjust 'ptr' so that its alignment is at least as stringent as what the 83 * compiler would provide for X and return the aligned result. 84 * 85 * If 'size' is a constant, the compiler will optimize this whole function 86 * down to either a no-op or the addition of a constant to the value of 'ptr'. 87 */ 88char *edac_align_ptr(void *ptr, unsigned size) 89{ 90 unsigned align, r; 91 92 /* Here we assume that the alignment of a "long long" is the most 93 * stringent alignment that the compiler will ever provide by default. 94 * As far as I know, this is a reasonable assumption. 95 */ 96 if (size > sizeof(long)) 97 align = sizeof(long long); 98 else if (size > sizeof(int)) 99 align = sizeof(long); 100 else if (size > sizeof(short)) 101 align = sizeof(int); 102 else if (size > sizeof(char)) 103 align = sizeof(short); 104 else 105 return (char *)ptr; 106 107 r = size % align; 108 109 if (r == 0) 110 return (char *)ptr; 111 112 return (char *)(((unsigned long)ptr) + align - r); 113} 114 115/** 116 * edac_mc_alloc: Allocate a struct mem_ctl_info structure 117 * @size_pvt: size of private storage needed 118 * @nr_csrows: Number of CWROWS needed for this MC 119 * @nr_chans: Number of channels for the MC 120 * 121 * Everything is kmalloc'ed as one big chunk - more efficient. 122 * Only can be used if all structures have the same lifetime - otherwise 123 * you have to allocate and initialize your own structures. 124 * 125 * Use edac_mc_free() to free mc structures allocated by this function. 126 * 127 * Returns: 128 * NULL allocation failed 129 * struct mem_ctl_info pointer 130 */ 131struct mem_ctl_info *edac_mc_alloc(unsigned sz_pvt, unsigned nr_csrows, 132 unsigned nr_chans) 133{ 134 struct mem_ctl_info *mci; 135 struct csrow_info *csi, *csrow; 136 struct channel_info *chi, *chp, *chan; 137 void *pvt; 138 unsigned size; 139 int row, chn; 140 141 /* Figure out the offsets of the various items from the start of an mc 142 * structure. We want the alignment of each item to be at least as 143 * stringent as what the compiler would provide if we could simply 144 * hardcode everything into a single struct. 145 */ 146 mci = (struct mem_ctl_info *)0; 147 csi = (struct csrow_info *)edac_align_ptr(&mci[1], sizeof(*csi)); 148 chi = (struct channel_info *) 149 edac_align_ptr(&csi[nr_csrows], sizeof(*chi)); 150 pvt = edac_align_ptr(&chi[nr_chans * nr_csrows], sz_pvt); 151 size = ((unsigned long)pvt) + sz_pvt; 152 153 if ((mci = kmalloc(size, GFP_KERNEL)) == NULL) 154 return NULL; 155 156 /* Adjust pointers so they point within the memory we just allocated 157 * rather than an imaginary chunk of memory located at address 0. 158 */ 159 csi = (struct csrow_info *)(((char *)mci) + ((unsigned long)csi)); 160 chi = (struct channel_info *)(((char *)mci) + ((unsigned long)chi)); 161 pvt = sz_pvt ? (((char *)mci) + ((unsigned long)pvt)) : NULL; 162 163 memset(mci, 0, size); /* clear all fields */ 164 mci->csrows = csi; 165 mci->pvt_info = pvt; 166 mci->nr_csrows = nr_csrows; 167 168 for (row = 0; row < nr_csrows; row++) { 169 csrow = &csi[row]; 170 csrow->csrow_idx = row; 171 csrow->mci = mci; 172 csrow->nr_channels = nr_chans; 173 chp = &chi[row * nr_chans]; 174 csrow->channels = chp; 175 176 for (chn = 0; chn < nr_chans; chn++) { 177 chan = &chp[chn]; 178 chan->chan_idx = chn; 179 chan->csrow = csrow; 180 } 181 } 182 183 mci->op_state = OP_ALLOC; 184 185 return mci; 186} 187 188EXPORT_SYMBOL_GPL(edac_mc_alloc); 189 190/** 191 * edac_mc_free: Free a previously allocated 'mci' structure 192 * @mci: pointer to a struct mem_ctl_info structure 193 */ 194void edac_mc_free(struct mem_ctl_info *mci) 195{ 196 kfree(mci); 197} 198 199EXPORT_SYMBOL_GPL(edac_mc_free); 200 201static struct mem_ctl_info *find_mci_by_dev(struct device *dev) 202{ 203 struct mem_ctl_info *mci; 204 struct list_head *item; 205 206 debugf3("%s()\n", __func__); 207 208 list_for_each(item, &mc_devices) { 209 mci = list_entry(item, struct mem_ctl_info, link); 210 211 if (mci->dev == dev) 212 return mci; 213 } 214 215 return NULL; 216} 217 218/* 219 * handler for EDAC to check if NMI type handler has asserted interrupt 220 */ 221static int edac_mc_assert_error_check_and_clear(void) 222{ 223 int old_state; 224 225 if (edac_op_state == EDAC_OPSTATE_POLL) 226 return 1; 227 228 old_state = edac_err_assert; 229 edac_err_assert = 0; 230 231 return old_state; 232} 233 234/* 235 * edac_mc_workq_function 236 * performs the operation scheduled by a workq request 237 */ 238#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)) 239static void edac_mc_workq_function(struct work_struct *work_req) 240{ 241 struct delayed_work *d_work = (struct delayed_work *)work_req; 242 struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work); 243#else 244static void edac_mc_workq_function(void *ptr) 245{ 246 struct mem_ctl_info *mci = (struct mem_ctl_info *)ptr; 247#endif 248 249 mutex_lock(&mem_ctls_mutex); 250 251 /* Only poll controllers that are running polled and have a check */ 252 if (edac_mc_assert_error_check_and_clear() && (mci->edac_check != NULL)) 253 mci->edac_check(mci); 254 255 /* 256 * FIXME: temp place holder for PCI checks, 257 * goes away when we break out PCI 258 */ 259 edac_pci_do_parity_check(); 260 261 mutex_unlock(&mem_ctls_mutex); 262 263 /* Reschedule */ 264 queue_delayed_work(edac_workqueue, &mci->work, 265 msecs_to_jiffies(edac_mc_get_poll_msec())); 266} 267 268/* 269 * edac_mc_workq_setup 270 * initialize a workq item for this mci 271 * passing in the new delay period in msec 272 */ 273void edac_mc_workq_setup(struct mem_ctl_info *mci, unsigned msec) 274{ 275 debugf0("%s()\n", __func__); 276 277#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)) 278 INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function); 279#else 280 INIT_WORK(&mci->work, edac_mc_workq_function, mci); 281#endif 282 queue_delayed_work(edac_workqueue, &mci->work, msecs_to_jiffies(msec)); 283} 284 285/* 286 * edac_mc_workq_teardown 287 * stop the workq processing on this mci 288 */ 289void edac_mc_workq_teardown(struct mem_ctl_info *mci) 290{ 291 int status; 292 293 status = cancel_delayed_work(&mci->work); 294 if (status == 0) { 295 /* workq instance might be running, wait for it */ 296 flush_workqueue(edac_workqueue); 297 } 298} 299 300/* 301 * edac_reset_delay_period 302 */ 303 304void edac_reset_delay_period(struct mem_ctl_info *mci, unsigned long value) 305{ 306 mutex_lock(&mem_ctls_mutex); 307 308 /* cancel the current workq request */ 309 edac_mc_workq_teardown(mci); 310 311 /* restart the workq request, with new delay value */ 312 edac_mc_workq_setup(mci, value); 313 314 mutex_unlock(&mem_ctls_mutex); 315} 316 317/* Return 0 on success, 1 on failure. 318 * Before calling this function, caller must 319 * assign a unique value to mci->mc_idx. 320 */ 321static int add_mc_to_global_list(struct mem_ctl_info *mci) 322{ 323 struct list_head *item, *insert_before; 324 struct mem_ctl_info *p; 325 326 insert_before = &mc_devices; 327 328 if (unlikely((p = find_mci_by_dev(mci->dev)) != NULL)) 329 goto fail0; 330 331 list_for_each(item, &mc_devices) { 332 p = list_entry(item, struct mem_ctl_info, link); 333 334 if (p->mc_idx >= mci->mc_idx) { 335 if (unlikely(p->mc_idx == mci->mc_idx)) 336 goto fail1; 337 338 insert_before = item; 339 break; 340 } 341 } 342 343 list_add_tail_rcu(&mci->link, insert_before); 344 atomic_inc(&edac_handlers); 345 return 0; 346 347 fail0: 348 edac_printk(KERN_WARNING, EDAC_MC, 349 "%s (%s) %s %s already assigned %d\n", p->dev->bus_id, 350 dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx); 351 return 1; 352 353 fail1: 354 edac_printk(KERN_WARNING, EDAC_MC, 355 "bug in low-level driver: attempt to assign\n" 356 " duplicate mc_idx %d in %s()\n", p->mc_idx, __func__); 357 return 1; 358} 359 360static void complete_mc_list_del(struct rcu_head *head) 361{ 362 struct mem_ctl_info *mci; 363 364 mci = container_of(head, struct mem_ctl_info, rcu); 365 INIT_LIST_HEAD(&mci->link); 366 complete(&mci->complete); 367} 368 369static void del_mc_from_global_list(struct mem_ctl_info *mci) 370{ 371 atomic_dec(&edac_handlers); 372 list_del_rcu(&mci->link); 373 init_completion(&mci->complete); 374 call_rcu(&mci->rcu, complete_mc_list_del); 375 wait_for_completion(&mci->complete); 376} 377 378/** 379 * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'. 380 * 381 * If found, return a pointer to the structure. 382 * Else return NULL. 383 * 384 * Caller must hold mem_ctls_mutex. 385 */ 386struct mem_ctl_info *edac_mc_find(int idx) 387{ 388 struct list_head *item; 389 struct mem_ctl_info *mci; 390 391 list_for_each(item, &mc_devices) { 392 mci = list_entry(item, struct mem_ctl_info, link); 393 394 if (mci->mc_idx >= idx) { 395 if (mci->mc_idx == idx) 396 return mci; 397 398 break; 399 } 400 } 401 402 return NULL; 403} 404 405EXPORT_SYMBOL(edac_mc_find); 406 407/** 408 * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and 409 * create sysfs entries associated with mci structure 410 * @mci: pointer to the mci structure to be added to the list 411 * @mc_idx: A unique numeric identifier to be assigned to the 'mci' structure. 412 * 413 * Return: 414 * 0 Success 415 * !0 Failure 416 */ 417 418/* FIXME - should a warning be printed if no error detection? correction? */ 419int edac_mc_add_mc(struct mem_ctl_info *mci, int mc_idx) 420{ 421 debugf0("%s()\n", __func__); 422 mci->mc_idx = mc_idx; 423#ifdef CONFIG_EDAC_DEBUG 424 if (edac_debug_level >= 3) 425 edac_mc_dump_mci(mci); 426 427 if (edac_debug_level >= 4) { 428 int i; 429 430 for (i = 0; i < mci->nr_csrows; i++) { 431 int j; 432 433 edac_mc_dump_csrow(&mci->csrows[i]); 434 for (j = 0; j < mci->csrows[i].nr_channels; j++) 435 edac_mc_dump_channel(&mci->csrows[i]. 436 channels[j]); 437 } 438 } 439#endif 440 mutex_lock(&mem_ctls_mutex); 441 442 if (add_mc_to_global_list(mci)) 443 goto fail0; 444 445 /* set load time so that error rate can be tracked */ 446 mci->start_time = jiffies; 447 448 if (edac_create_sysfs_mci_device(mci)) { 449 edac_mc_printk(mci, KERN_WARNING, 450 "failed to create sysfs device\n"); 451 goto fail1; 452 } 453 454 /* If there IS a check routine, then we are running POLLED */ 455 if (mci->edac_check != NULL) { 456 /* This instance is NOW RUNNING */ 457 mci->op_state = OP_RUNNING_POLL; 458 459 edac_mc_workq_setup(mci, edac_mc_get_poll_msec()); 460 } else { 461 mci->op_state = OP_RUNNING_INTERRUPT; 462 } 463 464 /* Report action taken */ 465 edac_mc_printk(mci, KERN_INFO, "Giving out device to %s %s: DEV %s\n", 466 mci->mod_name, mci->ctl_name, dev_name(mci)); 467 468 mutex_unlock(&mem_ctls_mutex); 469 return 0; 470 471 fail1: 472 del_mc_from_global_list(mci); 473 474 fail0: 475 mutex_unlock(&mem_ctls_mutex); 476 return 1; 477} 478 479EXPORT_SYMBOL_GPL(edac_mc_add_mc); 480 481/** 482 * edac_mc_del_mc: Remove sysfs entries for specified mci structure and 483 * remove mci structure from global list 484 * @pdev: Pointer to 'struct device' representing mci structure to remove. 485 * 486 * Return pointer to removed mci structure, or NULL if device not found. 487 */ 488struct mem_ctl_info *edac_mc_del_mc(struct device *dev) 489{ 490 struct mem_ctl_info *mci; 491 492 debugf0("MC: %s()\n", __func__); 493 mutex_lock(&mem_ctls_mutex); 494 495 if ((mci = find_mci_by_dev(dev)) == NULL) { 496 mutex_unlock(&mem_ctls_mutex); 497 return NULL; 498 } 499 500 /* marking MCI offline */ 501 mci->op_state = OP_OFFLINE; 502 503 /* flush workq processes */ 504 edac_mc_workq_teardown(mci); 505 506 edac_remove_sysfs_mci_device(mci); 507 del_mc_from_global_list(mci); 508 mutex_unlock(&mem_ctls_mutex); 509 edac_printk(KERN_INFO, EDAC_MC, 510 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx, 511 mci->mod_name, mci->ctl_name, dev_name(mci)); 512 return mci; 513} 514 515EXPORT_SYMBOL_GPL(edac_mc_del_mc); 516 517static void edac_mc_scrub_block(unsigned long page, unsigned long offset, 518 u32 size) 519{ 520 struct page *pg; 521 void *virt_addr; 522 unsigned long flags = 0; 523 524 debugf3("%s()\n", __func__); 525 526 /* ECC error page was not in our memory. Ignore it. */ 527 if (!pfn_valid(page)) 528 return; 529 530 /* Find the actual page structure then map it and fix */ 531 pg = pfn_to_page(page); 532 533 if (PageHighMem(pg)) 534 local_irq_save(flags); 535 536 virt_addr = kmap_atomic(pg, KM_BOUNCE_READ); 537 538 /* Perform architecture specific atomic scrub operation */ 539 atomic_scrub(virt_addr + offset, size); 540 541 /* Unmap and complete */ 542 kunmap_atomic(virt_addr, KM_BOUNCE_READ); 543 544 if (PageHighMem(pg)) 545 local_irq_restore(flags); 546} 547 548/* FIXME - should return -1 */ 549int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page) 550{ 551 struct csrow_info *csrows = mci->csrows; 552 int row, i; 553 554 debugf1("MC%d: %s(): 0x%lx\n", mci->mc_idx, __func__, page); 555 row = -1; 556 557 for (i = 0; i < mci->nr_csrows; i++) { 558 struct csrow_info *csrow = &csrows[i]; 559 560 if (csrow->nr_pages == 0) 561 continue; 562 563 debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) " 564 "mask(0x%lx)\n", mci->mc_idx, __func__, 565 csrow->first_page, page, csrow->last_page, 566 csrow->page_mask); 567 568 if ((page >= csrow->first_page) && 569 (page <= csrow->last_page) && 570 ((page & csrow->page_mask) == 571 (csrow->first_page & csrow->page_mask))) { 572 row = i; 573 break; 574 } 575 } 576 577 if (row == -1) 578 edac_mc_printk(mci, KERN_ERR, 579 "could not look up page error address %lx\n", 580 (unsigned long)page); 581 582 return row; 583} 584 585EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page); 586 587/* FIXME - setable log (warning/emerg) levels */ 588/* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */ 589void edac_mc_handle_ce(struct mem_ctl_info *mci, 590 unsigned long page_frame_number, 591 unsigned long offset_in_page, unsigned long syndrome, 592 int row, int channel, const char *msg) 593{ 594 unsigned long remapped_page; 595 596 debugf3("MC%d: %s()\n", mci->mc_idx, __func__); 597 598 /* FIXME - maybe make panic on INTERNAL ERROR an option */ 599 if (row >= mci->nr_csrows || row < 0) { 600 /* something is wrong */ 601 edac_mc_printk(mci, KERN_ERR, 602 "INTERNAL ERROR: row out of range " 603 "(%d >= %d)\n", row, mci->nr_csrows); 604 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR"); 605 return; 606 } 607 608 if (channel >= mci->csrows[row].nr_channels || channel < 0) { 609 /* something is wrong */ 610 edac_mc_printk(mci, KERN_ERR, 611 "INTERNAL ERROR: channel out of range " 612 "(%d >= %d)\n", channel, 613 mci->csrows[row].nr_channels); 614 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR"); 615 return; 616 } 617 618 if (edac_mc_get_log_ce()) 619 /* FIXME - put in DIMM location */ 620 edac_mc_printk(mci, KERN_WARNING, 621 "CE page 0x%lx, offset 0x%lx, grain %d, syndrome " 622 "0x%lx, row %d, channel %d, label \"%s\": %s\n", 623 page_frame_number, offset_in_page, 624 mci->csrows[row].grain, syndrome, row, channel, 625 mci->csrows[row].channels[channel].label, msg); 626 627 mci->ce_count++; 628 mci->csrows[row].ce_count++; 629 mci->csrows[row].channels[channel].ce_count++; 630 631 if (mci->scrub_mode & SCRUB_SW_SRC) { 632 /* 633 * Some MC's can remap memory so that it is still available 634 * at a different address when PCI devices map into memory. 635 * MC's that can't do this lose the memory where PCI devices 636 * are mapped. This mapping is MC dependant and so we call 637 * back into the MC driver for it to map the MC page to 638 * a physical (CPU) page which can then be mapped to a virtual 639 * page - which can then be scrubbed. 640 */ 641 remapped_page = mci->ctl_page_to_phys ? 642 mci->ctl_page_to_phys(mci, page_frame_number) : 643 page_frame_number; 644 645 edac_mc_scrub_block(remapped_page, offset_in_page, 646 mci->csrows[row].grain); 647 } 648} 649 650EXPORT_SYMBOL_GPL(edac_mc_handle_ce); 651 652void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci, const char *msg) 653{ 654 if (edac_mc_get_log_ce()) 655 edac_mc_printk(mci, KERN_WARNING, 656 "CE - no information available: %s\n", msg); 657 658 mci->ce_noinfo_count++; 659 mci->ce_count++; 660} 661 662EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info); 663 664void edac_mc_handle_ue(struct mem_ctl_info *mci, 665 unsigned long page_frame_number, 666 unsigned long offset_in_page, int row, const char *msg) 667{ 668 int len = EDAC_MC_LABEL_LEN * 4; 669 char labels[len + 1]; 670 char *pos = labels; 671 int chan; 672 int chars; 673 674 debugf3("MC%d: %s()\n", mci->mc_idx, __func__); 675 676 /* FIXME - maybe make panic on INTERNAL ERROR an option */ 677 if (row >= mci->nr_csrows || row < 0) { 678 /* something is wrong */ 679 edac_mc_printk(mci, KERN_ERR, 680 "INTERNAL ERROR: row out of range " 681 "(%d >= %d)\n", row, mci->nr_csrows); 682 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR"); 683 return; 684 } 685 686 chars = snprintf(pos, len + 1, "%s", 687 mci->csrows[row].channels[0].label); 688 len -= chars; 689 pos += chars; 690 691 for (chan = 1; (chan < mci->csrows[row].nr_channels) && (len > 0); 692 chan++) { 693 chars = snprintf(pos, len + 1, ":%s", 694 mci->csrows[row].channels[chan].label); 695 len -= chars; 696 pos += chars; 697 } 698 699 if (edac_mc_get_log_ue()) 700 edac_mc_printk(mci, KERN_EMERG, 701 "UE page 0x%lx, offset 0x%lx, grain %d, row %d, " 702 "labels \"%s\": %s\n", page_frame_number, 703 offset_in_page, mci->csrows[row].grain, row, 704 labels, msg); 705 706 if (edac_mc_get_panic_on_ue()) 707 panic("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, " 708 "row %d, labels \"%s\": %s\n", mci->mc_idx, 709 page_frame_number, offset_in_page, 710 mci->csrows[row].grain, row, labels, msg); 711 712 mci->ue_count++; 713 mci->csrows[row].ue_count++; 714} 715 716EXPORT_SYMBOL_GPL(edac_mc_handle_ue); 717 718void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci, const char *msg) 719{ 720 if (edac_mc_get_panic_on_ue()) 721 panic("EDAC MC%d: Uncorrected Error", mci->mc_idx); 722 723 if (edac_mc_get_log_ue()) 724 edac_mc_printk(mci, KERN_WARNING, 725 "UE - no information available: %s\n", msg); 726 mci->ue_noinfo_count++; 727 mci->ue_count++; 728} 729 730EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info); 731 732/************************************************************* 733 * On Fully Buffered DIMM modules, this help function is 734 * called to process UE events 735 */ 736void edac_mc_handle_fbd_ue(struct mem_ctl_info *mci, 737 unsigned int csrow, 738 unsigned int channela, 739 unsigned int channelb, char *msg) 740{ 741 int len = EDAC_MC_LABEL_LEN * 4; 742 char labels[len + 1]; 743 char *pos = labels; 744 int chars; 745 746 if (csrow >= mci->nr_csrows) { 747 /* something is wrong */ 748 edac_mc_printk(mci, KERN_ERR, 749 "INTERNAL ERROR: row out of range (%d >= %d)\n", 750 csrow, mci->nr_csrows); 751 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR"); 752 return; 753 } 754 755 if (channela >= mci->csrows[csrow].nr_channels) { 756 /* something is wrong */ 757 edac_mc_printk(mci, KERN_ERR, 758 "INTERNAL ERROR: channel-a out of range " 759 "(%d >= %d)\n", 760 channela, mci->csrows[csrow].nr_channels); 761 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR"); 762 return; 763 } 764 765 if (channelb >= mci->csrows[csrow].nr_channels) { 766 /* something is wrong */ 767 edac_mc_printk(mci, KERN_ERR, 768 "INTERNAL ERROR: channel-b out of range " 769 "(%d >= %d)\n", 770 channelb, mci->csrows[csrow].nr_channels); 771 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR"); 772 return; 773 } 774 775 mci->ue_count++; 776 mci->csrows[csrow].ue_count++; 777 778 /* Generate the DIMM labels from the specified channels */ 779 chars = snprintf(pos, len + 1, "%s", 780 mci->csrows[csrow].channels[channela].label); 781 len -= chars; 782 pos += chars; 783 chars = snprintf(pos, len + 1, "-%s", 784 mci->csrows[csrow].channels[channelb].label); 785 786 if (edac_mc_get_log_ue()) 787 edac_mc_printk(mci, KERN_EMERG, 788 "UE row %d, channel-a= %d channel-b= %d " 789 "labels \"%s\": %s\n", csrow, channela, channelb, 790 labels, msg); 791 792 if (edac_mc_get_panic_on_ue()) 793 panic("UE row %d, channel-a= %d channel-b= %d " 794 "labels \"%s\": %s\n", csrow, channela, 795 channelb, labels, msg); 796} 797 798EXPORT_SYMBOL(edac_mc_handle_fbd_ue); 799 800/************************************************************* 801 * On Fully Buffered DIMM modules, this help function is 802 * called to process CE events 803 */ 804void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci, 805 unsigned int csrow, unsigned int channel, char *msg) 806{ 807 808 /* Ensure boundary values */ 809 if (csrow >= mci->nr_csrows) { 810 /* something is wrong */ 811 edac_mc_printk(mci, KERN_ERR, 812 "INTERNAL ERROR: row out of range (%d >= %d)\n", 813 csrow, mci->nr_csrows); 814 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR"); 815 return; 816 } 817 if (channel >= mci->csrows[csrow].nr_channels) { 818 /* something is wrong */ 819 edac_mc_printk(mci, KERN_ERR, 820 "INTERNAL ERROR: channel out of range (%d >= %d)\n", 821 channel, mci->csrows[csrow].nr_channels); 822 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR"); 823 return; 824 } 825 826 if (edac_mc_get_log_ce()) 827 /* FIXME - put in DIMM location */ 828 edac_mc_printk(mci, KERN_WARNING, 829 "CE row %d, channel %d, label \"%s\": %s\n", 830 csrow, channel, 831 mci->csrows[csrow].channels[channel].label, msg); 832 833 mci->ce_count++; 834 mci->csrows[csrow].ce_count++; 835 mci->csrows[csrow].channels[channel].ce_count++; 836} 837 838EXPORT_SYMBOL(edac_mc_handle_fbd_ce); 839 840/* 841 * Iterate over all MC instances and check for ECC, et al, errors 842 */ 843void edac_check_mc_devices(void) 844{ 845 struct list_head *item; 846 struct mem_ctl_info *mci; 847 848 debugf3("%s()\n", __func__); 849 mutex_lock(&mem_ctls_mutex); 850 851 list_for_each(item, &mc_devices) { 852 mci = list_entry(item, struct mem_ctl_info, link); 853 854 if (mci->edac_check != NULL) 855 mci->edac_check(mci); 856 } 857 858 mutex_unlock(&mem_ctls_mutex); 859} 860