← All guides

Reading a miner’s kernel log: error patterns that warn of hashboard failure

Hardware · Published 2026-10-29 · 9 min read

General information only, not financial advice. Log wording varies by model and firmware; the patterns below are the ones published by the manufacturer and repair guides cited in the text, checked 29 October 2026. Power off and unplug a miner before any hardware check.

The common belief is that a kernel log warns you by containing an error. It does not. Healthy miners log errors, a stray CRC line, a fan complaint during a hot afternoon, a chip that misses enumeration once and returns on the next boot. A hashboard on its way out warns differently: the same error, on the same chain, at the same address, growing. The verdict up top, in one line: single lines are noise to record; patterns, by position, by repetition, by trend, are the warning. This guide is the procedure for telling them apart, built for an operator deciding whether a board can keep running or needs the bench.

Capture the log before it changes

The kernel log is the miner’s low-level startup and hardware health report: board detection, chip enumeration, temperature protection, fan checks, and critical faults. It is also perishable evidence. Repeated reboots can hide the first useful error and stress a failing board, so the first diagnostic act is preservation, not rebooting.

Bitmain’s own procedure is the baseline. Log in to the miner’s backend and open Miner Log at the bottom left of the interface. Choose the current log for a machine that is faulty now; choose the historical log for an unstable miner or for analysing a past problem. Select the log from the beginning to the bottom, copy it, and paste it into a plain-text document. Bitmain suggests naming the file after the miner’s IP address, and adding the model and date makes later comparison far easier. Historical logs can also be downloaded as a.zip file for selected dates. On firmware that presents the log through the system menus, the same log is reachable in a browser at the miner’s IP under System > Kernel Log; over SSH, which still works when the web interface will not load, the miner log sits at /tmp/log/bmminer.log and can be filtered for error, chain, temperature, power, and fan lines.

Do this once while the machine is healthy, too. A known-good log, every chain enumerating its full chip count, no protection triggers, is the document every later log gets compared against. Without it, “is this new?” is unanswerable, and most log reading degenerates into guessing which lines were always there.

The diagnostic procedure: from baseline to pattern

  1. Capture first. Save the current log with model, unit, and date in the filename, before any reboot. If the fault is intermittent, pull the historical log for the dates it occurred.
  2. Find the first error, not the loudest one. Work from the timestamp of the first ERROR or shutdown line in the boot sequence. Later lines are usually consequences; the first failure event is the one that names the subsystem.
  3. Confirm enumeration against the spec. Check that every chain is present and compare each chain’s ASIC count with the model’s design count, the spec check. On a standard Antminer S19, each of the three hashboards carries 76 chips, so a full enumeration reports 76 per chain. Counts differ by model; the number that matters is your model’s published count, not a remembered one.
  4. Note the protection lines. Record the fan and temperature entries around the first error. Overheat and fan faults shut a miner down by design, and a board-level conclusion drawn from a log whose real story is a failed fan is a board replaced for nothing.
  5. Classify each error by chain and address. For every recurring error, write down three coordinates: which chain, which chip address or position if the log gives one, and when in the run it appears, at cold start, or minutes in under load. The next two sections are read off these coordinates.
  6. Run the free physical checks before concluding hardware. Power off and unplug. Reseat the data and power cables for the affected chain. A single high-resistance pin on a data ribbon can break a chain exactly like a dead chip, and a sagging power supply is a documented cause of chips dropping out only once a board draws full current, which is why load-dependent errors are not yet a board verdict.
  7. Compare against the baseline and the last log. Same lines as last month, same count: record and monitor. New chain, new address, higher count: that difference is the finding, whatever the error string says.

What success looks like: you can finish this sentence with evidence, “Chain 1 has reported the same three missing chips at the same positions in four logs over two weeks, with no other errors”, or its opposite. A log reading that ends in a named error string instead of a pattern statement is not finished.

Where the errors sit: position patterns

Position is the first pattern, because the chips on a hashboard form a chain: signals pass from chip to chip in sequence, so where reporting stops carries information a raw error count cannot.

Pattern in the logWhat it points toFirst move
Missing chips clustered at the tail of one chain, the documented example reads ASIC=57 with failures at positions 58–60A break near the tail of that chain: the chips before it still enumerate, the signal stops thereTreat as that board’s fault line; cable and connector checks for that chain first, then board-level diagnosis
Failures scattered across all three chains at onceEnvironment, not three simultaneous chip failures: heat, power, or grounding affecting the whole machineCheck fans, airflow, ambient temperature, power supply, and grounding before touching any board
CRC errors repeating on one chip addressThat chip, its solder joints, or its voltage domain, addresses are assigned sequentially, so a flagged address indexes into the chainRecord the address across logs; a fixed address that recurs is a board-level finding
CRC errors scattered across a chainCable, clock, power, or a cold joint near the head of the chainSwap the signal cable with a known-good chain’s; if the fault follows the cable, the board is cleared
One full chain reports “find 0 asic”No chips detected on that board: board failure, unstable power to that board, damaged connectors or cables, or a short on the boardReseat, then swap cables; if the error stays with the board after swaps, the board is the suspect

Two single-board signatures deserve naming because they bypass the pattern table. An EEPROM error means the miner cannot read the board’s stored data; if only one board produces EEPROM errors, that is a board-level issue by itself. And “ERROR_SOC_INIT: soc init failed” means startup initialization failed, often triggered by a hashboard fault, including a short. The isolation test decides it: if SOC init fails only when one specific board is connected, that board is the prime suspect.

When the errors move: time patterns

The second pattern is time, and it separates three situations that a single log cannot.

Cold start versus hot soak. Errors present from the first minute of a cold boot point at enumeration, connectors, and dead components, things that are broken at rest. Errors that appear only about twenty minutes into a run are thermal until proven otherwise: a joint or heatsink interface that holds when cold and opens when hot. A log captured only at boot will miss the second class entirely, which is why the capture step specifies a log taken after the failure, under the conditions that produce it.

Marginal versus dead. A chain can sit between the two. The documented frequency test makes the distinction: if CRC errors vanish at a lower frequency step and return at the nameplate frequency, the chain is marginal rather than dead, weakened, still communicating, and a candidate for planned repair rather than an emergency. Marginal is not stable, though. It is a direction of travel.

The growing count. This is the pattern that warns of failure most reliably, and it is invisible without dated logs. A board missing the same few chips, at the same positions, across weeks of logs is a stable partial loss. A missing-chip count that is larger this week than last, or a chain that progresses from CRC errors under load, to missing chips at enumeration, to repeated power-off events during startup, is a cascade in progress. The log repeatedly powering a board off at startup is itself a stop signal: stop forcing reboots and diagnose, because each restart stresses the board and overwrites the evidence.

Monitor, or bench it now?

The decision framework, stated as plainly as the sources allow:

Monitor, with dated logs: a small, stable missing-chip count at fixed positions; a single CRC episode that does not recur; an overheat trigger with an identified environmental cause that is then fixed. Monitoring means a capture schedule, not a feeling, a log a week, compared line by line, so that stability is demonstrated rather than assumed.

Bench it now: repeated power-off hashboard events on the same chain; SOC init failures that persist after the one-board isolation test; one board repeatedly reporting find 0 asic, EEPROM errors, or CRC errors after cable swaps; overheat triggers that fire quickly in a cool environment, which point at heatsink or thermal-interface failure rather than weather. Add the hard stops that end all home diagnosis regardless of logs: a burned smell, a melted connector, a tripped breaker, corrosion, liquid exposure, or repeated loss of the same hashboard after basic cable, power, firmware, and airflow checks.

After any fix, the burden of proof flips. Run the miner long enough to confirm stable accepted hashrate, fan behaviour, chip temperature, reject rate, and pool-side reporting, a dashboard that looks normal for five minutes is not evidence for a recurring power, heat, or hashboard fault. The repaired board graduates when a full-load log, captured hot, matches the healthy baseline: full chip count, no recurring address, no protection triggers. Until then it is a suspect under observation, and the logs, dated, named, kept, are the observation record.

, Dex Carter, Tech Writer