Skip to main contentSkip to navigation

TrueNAS ZFS Pool Import Failure Recovery

A TrueNAS pool can refuse to import when its SLOG is missing, when its last few transactions left it in a state it can't import from, or when a vdev lost more members than its parity covers. We image every drive at our Austin lab through a write-blocker, parse vdev labels and the uberblock ring from raw images, and reconstruct the pool offline. You don't need the original TrueNAS hardware to import the pool, as long as the host's OpenZFS supports the pool's active features. Free evaluation. Mail-in welcome. No diagnostic fees. No data = no charge.

Author
Louis Rossmann
Written by
Louis Rossmann
Founder & Chief Technician
Updated September 2026
13 min read
Before You Do Anything

Before You Do Anything Else

One wrong recovery command can throw away recent transaction groups for good. Read this list before you type any zpool command.

  1. Don't create a new pool on these drives in the TrueNAS UI. Creating a pool writes new vdev labels at the start and end of every member drive.
  2. Don't run zpool import -F or -X on the original drives. If the rewind works, the transactions it rolled back are gone for good.
  3. If there's no verified backup of this data, don't let TrueNAS resilver a degraded vdev until the surviving drives are imaged.
  4. Power the system off. Label each drive with its bay position. ZFS does not require bay-order preservation for cross-host import, but recording it protects the chain of custody if a member is later identified as the failure source.
Failure Anatomy

Why Does a TrueNAS Pool Refuse to Import?

A missing SLOG vdev can stop a pool from importing. So can recent transaction groups that left the pool in a state it can't import from, and so can damaged vdev labels.

When you import a pool, ZFS reads the vdev labels, and each label carries its own uberblock ring. The ZIL doesn't get replayed until later, when the datasets mount, and only on a writable pool.

Missing SLOG vdev

A dedicated NVMe or SSD log device disappears. ZFS refuses to import without confirmation. The actual data loss is bounded: only sync writes since the last txg commit.

Uberblock Corruption

The rotating uberblock ring on every vdev label points to past transaction groups. At import, ZFS skips any uberblock that fails verification and uses the valid one with the highest txg. If the pool won't import from that one, it needs a rewind to an older txg.

Vdev Label Damage

Each member keeps four copies of its label, L0/L1 at the front of the drive and L2/L3 at the back.

Slow DDT Load After Import

This one doesn't stop the import. Holding the dedup table in ARC takes roughly 1 to 5 GB of RAM per 1 TB of deduplicated data. The table is read on demand from disk, so an undersized host still imports the pool. Loading it on demand can take days.

dRAID Vdev Topology

dRAID is a distributed-parity vdev type that arrived in OpenZFS 2.1. Its layout is declustered, which means data, parity, and spare capacity are permuted across every member. You set the topology when you create the pool, with a vdev spec string:

draid2:4d:11c:1s

#   parity   = 2   redundancy level per redundancy group (1, 2, or 3)
#   4d       = 4   data devices per redundancy group
#   11c      = 11  total member devices in the vdev
#   1s       = 1   distributed spare (sliced across all children, not a whole drive)

The vdev label on each member doesn't store that string. The geometry sits in separate integer fields instead. OpenZFS writes several of them, including nparity, draid_ndata, draid_nspares and draid_ngroups.

The distributed spare is spare capacity that's allocated ahead of time, then sliced and interleaved across all the children in the same permutation. That spare isn't a drive sitting idle as a dedicated hot-spare.

When a member fails, the sequential resilver writes the reconstructed data into those distributed-spare positions across the surviving drives, not onto one separate replacement disk. That's why a dRAID resilver restores redundancy faster than a RAIDZ healing resilver. It's a fixed-width sequential rebuild that reads from all children at once.

Fault tolerance is still the parity level and nothing more. A draid2 vdev survives two lost members; lose a third before the resilver finishes and the vdev FAULTS and the pool goes offline, same math as raidz2.

We image every member through a write-blocker and read the dRAID geometry fields off the labels. The declustered layout takes the same enterprise TrueNAS handling covered on our TrueNAS server recovery workflow.

DDT RAM Reality

How Long Does a Deduplicated Pool Take to Settle After Import?

When dedup is enabled, holding the Deduplication Table in ARC (RAM) takes roughly 1 to 5 GB of RAM per 1 TB of deduplicated data. The DDT is stored on disk and read on demand, so zpool import still completes on a host short on RAM, but iXsystems documents that loading the table on demand can take days after an import or reboot.

ZFS deduplication is not free. Every deduplicated block is tracked in the Deduplication Table, and every deduplicated write or deletion becomes a random disk read while the table is being read in.

The sizing guidance is roughly 1 to 5 GB of RAM per 1 TB of deduplicated data to keep the table in ARC. A recovery host that does not meet that threshold still imports the pool; what it loses is speed, because the table is then paged in from disk on demand within whatever zfs_arc_max allows. Because the DDT is not needed to read existing data, a strictly read-only import is the recovery path on undersized hardware.

We provision the recovery host with RAM sized for the DDT. The import itself stays read-only:

# Read-only forensic import on a host sized for the DDT
zpool import -o readonly=on -N <pool-name>

# Same import, restricting device discovery to stable /dev/disk/by-id paths
zpool import -o readonly=on -N -d /dev/disk/by-id <pool-name>

Read-only import never writes to the pool and never replays the ZIL. It is the right starting point on any TrueNAS pool that failed to import on its production host.

SLOG Reality

Does Losing the SLOG Destroy the Pool?

No. A dead SLOG loses only the in-flight synchronous writes since the last transaction-group commit; everything in a committed TXG already lives on the main pool vdevs. The pool imports with zpool import -m. "Dead SLOG = dead pool" is a myth.

No. The SLOG is not where your data lives.

The SLOG is a Separate Log: it holds the ZFS Intent Log (ZIL) entries for synchronous writes only, and only for the seconds between the write and the next transaction group commit.

When a SLOG fails or is removed, the loss is bounded to in-flight synchronous writes since the last txg commit. OpenZFS defaults to a maximum of 5 seconds between TXG commits (configurable via zfs_txg_timeout). NFS sync commits and database fsync writes during that window are lost; everything that was already part of a committed TXG is on the main pool vdevs.

The import command for a pool with a missing log device is:

# Authorize import despite missing log device
zpool import -m -o readonly=on -N <pool-name>

The -m flag explicitly authorizes import without the log device. The -o readonly=on -N flags keep the operation forensic.

L2ARC is even less critical. L2ARC is a read cache backed by SSD; losing it never affects pool integrity. The pool imports normally without an L2ARC device.

Uberblock Rollback

How Does Uberblock Rollback Work?

ZFS keeps a ring of historical uberblocks on every vdev label. If the pool won't import at its newest valid uberblock, we pick an older transaction group from the ring and rewind with zpool import -T <txg>. That runs against cloned images, never the original drives.

Every vdev label holds a 128 KiB uberblock ring. The pool's ashift sets the slot size, so the number of slots varies from pool to pool. Each uberblock is a snapshot of the pool's root pointer for one transaction group, and it records the TXG number, a timestamp, and the MOS root.

At import, ZFS skips any uberblock that fails verification and loads the valid one with the highest TXG. If the pool won't import at that state, we walk the ring backward to an older uberblock whose referenced blocks are intact.

# List the labels and uberblocks on one member device
zdb -lu <device>

# Then rewind to an older TXG
zpool import -T <txg> -o readonly=on -N <pool-name>

The -T flag targets a specific historical TXG. -F authorizes bounded rewind (ZFS picks an older TXG within a reasonable window). -X authorizes extreme rewind, walking the ring as far back as needed.

We never run -F or -X against original drives. The rewind operations write new TXGs to the pool.

If the rewind picks the wrong TXG, the previous state is unrecoverable. All rewinds run against cloned images on a forensic host.

Process

How We Recover a TrueNAS Pool That Will Not Import

Every step runs on write-blocked clones at the Austin lab: image each member, parse the vdev labels and uberblock ring with zdb, select the highest valid TXG, run a read-only forensic import on hardware sized for the DDT, then extract datasets and zvols with checksum verification.

Every step operates on cloned images. No reconstruction runs against original drives. All work happens at the Austin lab.

  1. Intake and topology documentation: We record the TrueNAS version (CORE or SCALE) and the pool topology (mirror, RAIDZ1, RAIDZ2, RAIDZ3, or multi-vdev). We also note the dedup state, whether there's a SLOG and L2ARC, the encryption (native ZFS or GELI), and the host RAM at the time of failure.
  2. Write-blocked imaging: We image every member through a write-blocker. When a drive has bad sectors, we image it with head maps and conservative retry parameters. If a drive has a mechanical fault, we do a head swap on the 0.02 micron ULPA clean bench before we image it.
  3. Vdev label parsing: We read all four label copies (L0, L1, L2, L3) from each member image. Labels contain the pool GUID, the vdev tree as nvlists, and the uberblock ring. Labels are cross-referenced across members to build a complete topology even if some members have label damage.
  4. Uberblock ring analysis and TXG selection: The ring on each label is parsed with zdb. We find the highest TXG with a valid uberblock. If the pool won't import at that TXG, we walk the ring backward to the most recent consistent state.
  5. Read-only forensic import on adequately sized hardware: We import the reconstructed pool with zpool import -o readonly=on -N from cloned images on a host sized for the DDT. The -N flag prevents automatic dataset mounting. The readonly property is what prevents ZIL replay and leaves the on-disk state untouched.
  6. Dataset and zvol extraction: We extract datasets, zvols, and snapshots. We verify every block against its ZFS checksum. We mount zvols that back VMs as block devices and verify their guest filesystems independently.
  7. Delivery: Recovered data is transferred to your target media.
Pricing

How Much Does TrueNAS ZFS Pool Recovery Cost?

You pay for two things. We image each hard drive member on our standard HDD tiers, and then there's the array reconstruction fee of $400-$800. There is no diagnostic fee, and no data means no charge.

TrueNAS recovery pricing has two parts: per-member imaging based on each drive's physical condition, plus the array reconstruction fee. We never charge a diagnostic fee. If we can't recover usable data, you pay nothing.

Recovery workDescriptionPriceNote
Per-Drive ImagingLogical or firmware issuesFrom $250; $600–$900 if firmware work is required
Pool ReconstructionZFS-specific rebuild and extraction$400-$800Vdev analysis, uberblock ring walking, DDT-sized import handling, dataset and zvol extraction.
Mechanical Drive RepairClean-bench head swap per drive$1,200–$1,50050% deposit required. CMR: $1,200-$1,500 + donor. SMR: $1,500 + donor.
Rush ServicePriority queue placement+$100+$100 rush fee to move to the front of the queue

No Data = No Charge. If we cannot recover usable data from your pool, you owe nothing. See our no-fix-no-fee guarantee for full details.

Glossary

What Do the ZFS Recovery Terms Mean?

DDT (Deduplication Table)
The on-disk index that maps every deduplicated block to its checksum and reference count. It is read on demand rather than loaded up front, and holding it in ARC costs roughly 1 to 5 GB of RAM per 1 TB of deduplicated data. A host without that RAM still imports the pool; the table then loads from disk over time.
ARC (Adaptive Replacement Cache)
The primary ZFS read cache, held in system RAM. It stores recently and frequently used blocks, and it is where the DDT is cached once read. ARC size is bounded by zfs_arc_max; when the table does not fit, dedup lookups fall back to on-demand disk reads and a dedup-heavy pool stays slow for a long time after import.
SLOG (Separate ZFS Intent Log)
A dedicated fast device that holds the ZFS Intent Log for synchronous writes only. It is not where your data lives. Losing it costs only the in-flight sync writes since the last transaction-group commit; the pool still imports with zpool import -m.
Uberblock
The root pointer for a transaction group, recording the TXG number, a timestamp, and the MOS root. ZFS keeps a ring of them in every vdev label, and how many slots that ring has depends on the pool's ashift. That ring is what lets you rewind to an earlier valid state.
Scrub vs Resilver
A scrub reads all data in the pool and verifies each block's checksum. On mirror, raidz and dRAID vdevs it also repairs any damage it finds. A resilver examines only data ZFS knows is out of date, such as the contents of a replacement device.
raidz1 / raidz2 / raidz3 Parity Tiers
ZFS parity vdev levels. raidz1 tolerates one drive lost per vdev, raidz2 tolerates two, and raidz3 tolerates three. Exceeding a vdev's parity count marks that vdev FAULTED and takes the pool offline, which is when forensic image-and-reconstruct work begins.
dRAID (Distributed RAID)
A declustered parity vdev introduced in OpenZFS 2.1, described by a config string such as draid2:4d:11c:1s (parity level, data devices per group, total children, distributed spares). Unlike RAIDZ with a separate whole-drive hot spare, a dRAID distributed spare is spare capacity sliced and interleaved across every child; a rebuild resilvers into those slices rather than onto one replacement disk. Fault tolerance is still the parity level.
FAQ

TrueNAS ZFS Pool Recovery Questions

The questions below cover what TrueNAS administrators ask before shipping drives: DDT memory math, missing SLOG semantics, uberblock rollback commands, cross-host import portability, and the difference between -F, -X, and -T rewind. For broader OpenZFS architecture and other ZFS host environments, see our QNAP QuTS hero ZFS recovery page and the broader server data recovery workflow, including our enterprise TrueNAS / FreeNAS recovery page for ZFS pools backing VMware and Hyper-V.

My TrueNAS pool will not import and shows an I/O error. Is the data recoverable?
Here's what we do with a pool like that: we image every member through a write-blocker, parse the uberblock ring with zdb, and reconstruct the pool offline from cloned images.
TrueNAS reports a missing SLOG vdev. Have I lost the entire pool?
No. The SLOG holds the ZFS Intent Log for synchronous writes. If the SLOG disappears, you lose only sync writes that had not yet been flushed to the main pool at the last transaction group commit. The pool itself is intact. We import it with zpool import -m, which authorizes import without the log device.
Does TrueNAS deduplication require special handling at recovery time?
Yes. ZFS deduplication keeps a Deduplication Table (DDT), and holding it in ARC takes roughly 1 to 5 GB of RAM per 1 TB of deduplicated data. The DDT lives on disk and gets read on demand, so the pool still imports on a recovery box that doesn't have the RAM to hold the table. According to iXsystems, loading the table that way can take days after an import or reboot. You don't need the DDT to read existing data. So we import the pool read-only, and when we have hardware sized for the table, we use it.
Can a TrueNAS pool be imported on a different machine, or do I need the original hardware?
ZFS pools are fully self-describing through their vdev labels. You don't need the original TrueNAS chassis, HBA, or motherboard, as long as the importing host's OpenZFS supports the pool's active features. Cross-host import uses zpool import -d /dev/disk/by-id. Vdev ordering does not matter. The pool finds its members by GUID.
What does zpool import -T do, and when is it the right tool?
zpool import -T <txg> rewinds the pool to a specific historical transaction group. ZFS keeps a rotating ring of uberblocks on every vdev label, each referencing a past TXG. If the pool won't import at its newest valid uberblock, we list the uberblocks on each member with zdb -lu, then rewind with -T to the most recent consistent one. Writes between the chosen TXG and the failure are lost.
Should I run zpool import -F or zpool import -X to force the import?
Not without imaging first. -F authorizes a bounded rewind, and -X authorizes an extreme one. Both can write new transaction groups to the pool, which destroys the metadata required to recover the previous state if the rewind fails. We never run -F or -X against original drives. We run them on cloned images on a forensic host.
Why should ZFS run on an HBA and not on hardware RAID?
ZFS provides its own checksumming, parity, and self-healing. A hardware RAID controller hides individual member drives from ZFS and presents a single virtual disk. When a member returns a bad block, ZFS cannot see which drive is at fault and cannot self-heal from the parity copy.
Can I import the pool read-only for forensic recovery without committing changes?
Yes, and it is the right default for any non-trivial failure. The full read-only forensic incantation is zpool import -o readonly=on -N <pool>. The -N flag prevents automatic dataset mounting. The readonly property is what prevents ZIL replay and leaves the on-disk state untouched while datasets are extracted.
Can you recover a TrueNAS pool after someone ran zpool destroy?
If no new data has been written to the drives after the destroy, the original uberblocks and metadata trees are still on disk.
Can you recover a TrueNAS dRAID pool from drive images?
Yes. We handle a dRAID vdev the same forensic way as any other ZFS pool. We image every member through a write-blocker, then read the dRAID geometry from the vdev labels. The pool was created with a spec such as draid2:4d:11c:1s (parity level, data devices per group, total children, distributed spares), but the label doesn't store that string. The geometry sits in separate integer fields instead. OpenZFS writes several of them, including nparity, draid_ndata, draid_nspares and draid_ngroups. A dRAID distributed spare is spare capacity interleaved across all children, so a resilver writes into those slices instead of onto one disk. Fault tolerance is still the parity level.
How is TrueNAS ZFS pool import recovery priced?
We image each hard drive member on the same HDD tiers we use for other multi-drive jobs. We bill pool reconstruction as the array reconstruction fee, $400-$800. If we can't recover usable data, you owe nothing, and there's no diagnostic fee.
Reviews

Data Recovery Standards & Verification

Our Austin lab operates on a transparency-first model. We use industry-standard recovery tools, including PC-3000 and DeepSpar, combined with strict environmental controls to maintain drive integrity. This approach allows us to serve clients nationwide with consistent technical standards.

Transparent History

Serving clients nationwide via mail-in service since 2008. Our lead engineer holds PC-3000 and HEX Akademia certifications for hard drive firmware repair and mechanical recovery.

Media Coverage

Our repair work has been covered by The Wall Street Journal and Business Insider, with CBC News reporting on our pricing transparency. Louis Rossmann has testified in Right to Repair hearings in multiple states and founded the Repair Preservation Group.

Aligned Incentives

Our "No Data, No Charge" policy means we assume the risk of the recovery attempt, not the client.

LR

Technical Oversight

Louis Rossmann

Our engineers review all lab protocols to maintain technical accuracy and honest service. Since 2008, his focus has been on clear technical communication and accurate diagnostics rather than sales-driven explanations.

We believe in showing the bench rather than just describing it. Open-drive work runs on a 0.02 micron ULPA-filtered laminar clean bench, and we filmed it.

See the particle counter test at the bench

As Featured In

TrueNAS pool will not import? Start a free evaluation.

Ship your drives or walk in at our Austin lab. No diagnostic fee. No data = no charge.

(512) 212-9111Mon-Fri 10am-6pm CT
No diagnostic fee
No data, no fee
4.9 stars, 1,837+ reviews