22 Jul, 2007

1 commit

  • Background:
    The MCE handler has several paths that it can take, depending on various
    conditions of the MCE status and the value of the 'tolerant' knob. The
    exact semantics are not well defined and the code is a bit twisty.

    Description:
    This patch makes the MCE handler's behavior more clear by documenting the
    behavior for various 'tolerant' levels. It also fixes or enhances
    several small things in the handler. Specifically:
    * If RIPV is set it is not safe to restart, so set the 'no way out'
    flag rather than the 'kill it' flag.
    * Don't panic() on correctable MCEs.
    * If the _OVER bit is set *and* the _UC bit is set (meaning possibly
    dropped uncorrected errors), set the 'no way out' flag.
    * Use EIPV for testing whether an app can be killed (SIGBUS) rather
    than RIPV. According to docs, EIPV indicates that the error is
    related to the IP, while RIPV simply means the IP is valid to
    restart from.
    * Don't clear the MCi_STATUS registers until after the panic() path.
    This leaves the status bits set after the panic() so clever BIOSes
    can find them (and dumb BIOSes can do nothing).

    This patch also calls nonseekable_open() in mce_open (as suggested by akpm).

    Result:
    Tolerant levels behave almost identically to how they always have, but
    not it's well defined. There's a slightly higher chance of panic()ing
    when multiple errors happen (a good thing, IMHO). If you take an MBE and
    panic(), the error status bits are not cleared.

    Alternatives:
    None.

    Testing:
    I used software to inject correctable and uncorrectable errors. With
    tolerant = 3, the system usually survives. With tolerant = 2, the system
    usually panic()s (PCC) but not always. With tolerant = 1, the system
    always panic()s. When the system panic()s, the BIOS is able to detect
    that the cause of death was an MC4. I was not able to reproduce the
    case of a non-PCC error in userspace, with EIPV, with (tolerant < 3).
    That will be rare at best.

    Signed-off-by: Tim Hockin
    Signed-off-by: Andrew Morton
    Signed-off-by: Andi Kleen
    Signed-off-by: Linus Torvalds

    Tim Hockin
     

03 May, 2007

1 commit

  • Background:
    We've found that MCEs (specifically DRAM SBEs) tend to come in bunches,
    especially when we are trying really hard to stress the system out. The
    current MCE poller uses a static interval which does not care whether it
    has or has not found MCEs recently.

    Description:
    This patch makes the MCE poller adjust the polling interval dynamically.
    If we find an MCE, poll 2x faster (down to 10 ms). When we stop finding
    MCEs, poll 2x slower (up to check_interval seconds). The check_interval
    tunable becomes the max polling interval. The "Machine check events
    logged" printk() is rate limited to the check_interval, which should be
    identical behavior to the old functionality.

    Result:
    If you start to take a lot of correctable errors (not exceptions), you
    log them faster and more accurately (less chance of overflowing the MCA
    registers). If you don't take a lot of errors, you will see no change.

    Alternatives:
    I considered simply reducing the polling interval to 10 ms immediately
    and keeping it there as long as we continue to find errors. This felt a
    bit heavy handed, but does perform significantly better for the default
    check_interval of 5 minutes (we're using a few seconds when testing for
    DRAM errors). I could be convinced to go with this, if anyone felt it
    was not too aggressive.

    Testing:
    I used an error-injecting DIMM to create lots of correctable DRAM errors
    and verified that the polling interval accelerates. The printk() only
    happens once per check_interval seconds.

    Patch:
    This patch is against 2.6.21-rc7.

    Signed-Off-By: Tim Hockin
    Signed-off-by: Andi Kleen

    Tim Hockin
     

13 Feb, 2007

1 commit

  • When a machine check event is detected (including a AMD RevF threshold
    overflow event) allow to run a "trigger" program. This allows user space
    to react to such events sooner.

    The trigger is configured using a new trigger entry in the
    machinecheck sysfs interface. It is currently shared between
    all CPUs.

    I also fixed the AMD threshold handler to run the machine
    check polling code immediately to actually log any events
    that might have caused the threshold interrupt.

    Also added some documentation for the mce sysfs interface.

    Signed-off-by: Andi Kleen

    Andi Kleen