HDDSuperClone vs ddrescue

GNU ddrescue and HDDSuperClone are the two most-recommended open-source tools for imaging a failing hard drive. Both create a sector-by-sector binary clone of a source disk. Both can pause, resume, and work around bad sectors.

The difference is architectural: ddrescue reads through the Linux kernel's block device layer, while HDDSuperClone sends raw ATA commands directly to the drive controller via pass-through. That distinction determines which tool can handle a specific failure mode and which one will make it worse.

This guide covers when ddrescue is the right choice, when HDDSuperClone's ATA pass-through is required, and when both tools are inadequate and the drive needs professional hardware like the PC-3000 or DeepSpar Disk Imager.

ddrescue

GNU ddrescue (version 1.30, January 2026, GPLv2+) is a multi-pass block imager written by Antonio Diaz Diaz and distributed by the GNU Project. It reads sectors from a failing source device through the Linux kernel block layer (/dev/sdX), copies them to a destination disk or image file, and records the state of every sector range in a mapfile. The algorithm runs in five distinct phases: copying, trimming, sweeping, scraping, and retrying.

The sweeping phase, introduced in 1.30, replaced the old fifth copying pass and recovers drives with a dead head with far fewer read errors than 1.29. ddrescue is not firmware-aware. It cannot issue ATA pass-through commands, has no knowledge of physical head-to-LBA mapping, and cannot power-cycle a locked drive without external hardware such as a YKUSH USB relay or a DeepSpar Disk Imager.

ddrescue is distinct from the older dd_rescue by Kurt Garloff and from the standard dd utility, which aborts on the first read error. On any drive with mechanical symptoms (clicking, beeping, grinding, or repeated SATA bus resets) ddrescue must be stopped and the drive sent to a clean bench; continuing to image a clicking drive scrapes magnetic coating off the platters and forecloses recovery.

Critical ddrescue parameters for failing hard drives

• Mapfile resumability. Always pass a mapfile path as the third argument. ddrescue marks finished sectors as +, non-tried as ?, non-trimmed as *, non-scraped as /, and bad-sector as -. Resuming with the same mapfile re-reads only unresolved ranges, which is what makes a two-pass triage workflow physically safe for a degrading head stack.
• --min-read-rate (-a). When transfer speed collapses to single-digit KB/s because the drive's controller is looping on internal ECC, this flag forces ddrescue to skip ahead and image healthier regions first. A common starting point on a slow drive is --min-read-rate=10M.
• -r N and -R. The retry count defaults to zero. A first pass with -n (no scrape) grabs easy data, then a second pass with -r 3 -R retries failed sectors up to three times reading backwards. Approaching damaged regions from the opposite physical direction can recover sectors the forward pass left as bad-sector entries in the mapfile.

When ddrescue alone is not enough (head instability, stuck busy state, vendor-specific firmware corruption such as Seagate F3 translator damage or Western Digital ROYL Module 32 reallocation loops), escalate to HDDSuperClone/OpenSuperClone for ATA pass-through, and to PC-3000 for service-area firmware repair and clean-bench head swaps. Helium drives are recovered in-house at the Austin, TX lab, including head swaps and helium refill.

What is ddrescue?

GNU ddrescue is a block-level disk imaging tool written by Antonio Diaz Diaz and distributed by the GNU Project under the GNU General Public License. It reads sectors through the Linux kernel's block device layer, copies them to a destination file or disk, and records progress in a mapfile so the run can be paused and resumed.

Its multi-phase algorithm copies the easy data first, then trims, sweeps, scrapes, and retries the unresolved sectors. The -r N flag controls retry passes on bad sectors; the default is 0, and a triage pass on a failing drive typically uses -n first (no scraping) followed by -r 3 on a second run.

ddrescue is not firmware-aware. It does not issue ATA pass-through commands, has no concept of physical heads, and cannot skip a failing head stack. For a technician, ddrescue is the first-line triage tool that decides whether the drive can be imaged at the kernel level or whether it needs to escalate to PC-3000 firmware work or a mechanical head swap in the clean bench.

What is HDDSuperClone?

HDDSuperClone is a disk imaging tool originally written by Scott Dwyer, known on HDDGuru and other data recovery forums by the handle "maximus." Dwyer released the PRO version as freeware in 2022, open-sourced the code under the GNU General Public License, and ended commercial development; the actively maintained fork is OpenSuperClone, hosted on GitHub.

Unlike ddrescue, it uses SCSI/ATA pass-through to send raw ATA commands directly to the drive controller. That gives it the drive's hardware error registers and an adaptive skip that widens while errors keep arriving, so an error-dense region gets stepped over rather than ground through sector by sector. It has no head map, and it never establishes which head produced the errors.

It runs only on Linux, exposes its imaging session as a virtual block device that file-system parsers like DMDE or R-Studio can read, supports YKUSH USB relays for automated power cycling on locked-up drives, and ships in the OSC-Live bootable ISO. The learning curve is steeper than ddrescue.

Disk Imaging Is Not Data Recovery

A common error in DIY recovery attempts is running file-recovery software (Recuva, EaseUS, Disk Drill) directly on a failing drive. These programs issue random, non-sequential read requests across the entire disk surface. On a drive with unstable heads or degrading media, that access pattern accelerates mechanical failure.

Disk imaging is the first phase of any recovery: reading sectors sequentially from LBA 0 to the last sector and writing them to a healthy destination. File-system parsing happens on the cloned image, not on the original drive. ddrescue and HDDSuperClone are imaging tools. They output a raw binary image or a cloned disk. They do not output readable files.

GNU ddrescue: Kernel Block Device Imaging

GNU ddrescue is a GNU Project tool that reads from the standard Linux block device interface (/dev/sdX). It issues POSIX read() calls, and the kernel handles the actual SCSI/ATA command translation via the host bus adapter driver.

ddrescue's strength is its multi-pass algorithm. As of version 1.30 (January 2026), five phases handle progressively harder sectors:

1. Copying: Reads large contiguous blocks. On error, skips a large region and continues forward, extracting all the easy-to-read data first.
2. Trimming: Revisits skipped regions and narrows down the exact boundaries of each bad sector cluster by reading inward from both edges.
3. Sweeping: A forward pass with skipping disabled to delimit large error areas and produce good starting points for the scraping phase.
4. Scraping: Reads the remaining unresolved sectors one at a time.
5. Retrying: Multiple passes over confirmed bad sectors, relying on the probability that the head aligns correctly on a retry to recover marginal sectors.

The mapfile (formerly logfile) records the state of every sector range as non-tried, finished, non-trimmed, non-scraped, or bad-sector. If the process is interrupted by a crash or a drive dropping offline, ddrescue resumes from the mapfile without re-reading finished sectors.

Where ddrescue works well

Drives with stable, functioning read/write heads but scattered bad sectors from media degradation. The heads can still read the majority of the platter surface; the bad sectors are localized defects in the magnetic coating. ddrescue extracts the good data first, then methodically narrows down the bad regions.

Where ddrescue fails

When a physical read/write head is weak or intermittently failing, ddrescue has no mechanism to detect which head is responsible. The Linux kernel treats the drive as a single block device.

If a bad head hangs the drive controller, the kernel waits for its I/O timeout (30+ seconds by default) before returning an error. During that wait, the failing head is forced to keep attempting reads, accelerating its degradation. ddrescue cannot issue a hardware reset or skip the failing head's sectors because it does not know physical heads exist.

HDDSuperClone: ATA Pass-Through Imaging

HDDSuperClone, originally developed by Scott Dwyer, uses SCSI/ATA pass-through to bypass the Linux kernel's block device layer and send raw ATA commands (such as READ SECTORS EXT) directly to the drive controller. This gives the software access to the drive's hardware error registers rather than the generic “read failed” response the kernel returns.

Head-skipping algorithm

A hard drive maps logical block addresses (LBAs) to physical platters and heads, and HDDSuperClone never sees that mapping. Its self-learning head skipping algorithm works from read errors: the first error triggers a skip of --skip-size (4096 LBA by default), and the skip grows as errors continue until reads succeed again or until it reaches --max-skip-size. On a drive with one bad head, that behavior clears the region that head serves in roughly seven read errors, without the software ever learning which head it escaped.

The practical effect is that everything readable gets cloned first and the error-dense region is left for a later, slower pass. That is a blunt approximation of what the PC-3000 does at the firmware level, where the operator works from the drive's real head map instead of an error pattern.

DMA vs PIO mode selection

Standard data transfer uses DMA (Direct Memory Access), where the drive controller writes data directly to system memory at full interface speed. On a degrading drive, DMA timeouts can crash the controller, requiring a full power cycle. HDDSuperClone allows switching to PIO (Programmed Input/Output) mode, where the host CPU polls the drive for each data word. PIO is slower but eliminates DMA timeout crashes, reducing stress on a mechanically unstable drive.

Virtual disk mode

HDDSuperClone can present the imaging session as a virtual block device to the host operating system. File-recovery software (DMDE, R-Studio) can then target specific structures like the Master File Table. If the requested sectors have already been cloned, HDDSuperClone serves them from the image file. If not, it reads them from the source drive and caches them. This prevents any sector from being read twice, allowing targeted file recovery without completing a full-disk clone.

OpenSuperClone: the actively maintained fork

HDDSuperClone's original developer (Scott Dwyer) released the source code and stopped active development. The project continues as OpenSuperClone, maintained under the ISpillMyDrink GitHub organization. The core ATA pass-through imaging engine is functionally identical. OpenSuperClone adds OSCDriver with DKMS support for Linux kernels, a community-maintained live ISO (OSC-Live), and integrated USB relay control for automated hardware power cycling.

Western Digital ROYL firmware: the slow-responding drive problem

Western Digital drives using the ROYL firmware architecture maintain a background defect reallocation list in Module 32 of the Service Area. When widespread media degradation triggers continuous reallocation, the drive's microcontroller overloads and transfer speeds drop to single-digit KB/s. ddrescue has no mechanism to address this; it reads through the kernel and receives the same throttled data rate.

A drive in this state needs professional hard drive data recovery with firmware-level repair using PC-3000 DE (Data Extractor).

Automated power cycling with USB relay hardware

Severe read instability can lock a drive controller so completely that ATA soft resets and bus resets both fail. The only way to reestablish communication is cutting 5V/12V electrical supply. OpenSuperClone integrates with the YEPKIT YKUSH 3 switchable USB hub: when the software detects a total SATA bridge lockup, it commands the relay to cut power, waits for spin-down, and restores power automatically. This makes multi-day imaging sessions on severely degraded drives possible without manual intervention.

Side-by-Side Comparison

Why Windows Is the Wrong Operating System for Disk Imaging

Windows aggressively attempts to mount, index, and parse every connected storage device. When a failing hard drive is connected via USB or SATA, Windows will issue random read requests across the disk surface for file-system indexing, thumbnail generation, and drive health checks. These non-sequential reads stress the failing heads in the same way file-recovery software does.

Both ddrescue and HDDSuperClone run on Linux, which can be configured to avoid auto-mounting. For drive imaging, the source drive should never be mounted. Linux distributions booted from a USB stick (such as Ubuntu or SystemRescue) provide a controlled environment where the imaging tool is the only process accessing the drive.

Is There a Windows Version of OpenSuperClone?

OpenSuperClone is a Linux program. So was HDDSuperClone, the abandoned tool it forks from. Neither project ships a Windows installer, so there is nothing to install under Windows. For a Windows user with no Linux machine, the path is a Linux live USB.

OSC-Live is that image. Write it to a USB stick, boot the machine from the stick, and the imaging environment comes up on its own; the numbered OSC-Live boot sequence covers the driver load and the destination-drive requirement.

Booting that stick doesn't install anything onto the Windows machine and doesn't modify the Windows installation on its internal disk. The whole environment runs off the USB stick. The failing drive is attached as the source and is left unmounted. The clone lands on a separate healthy drive of equal or greater size. Never a partition on the source.

What ties the tool to Linux is the same thing that lets it beat ddrescue on a dying drive. In its Direct AHCI mode, OpenSuperClone leaves the kernel block layer and talks to the storage controller through its own driver module, which puts per-command timeouts and reset handling under the operator's control instead of the operating system's storage stack. That module is a Linux kernel module, built by DKMS against the running Linux kernel.

A Windows build with that capability wouldn't be the same program rebuilt for a different target. It would have to be a kernel-mode storage driver taking the place of the Windows storage stack, which is a different piece of software from the Linux module doing that job today. The capability and the platform dependency are the same thing.

ddrescue sits differently against Windows, because it reads through the ordinary block device layer rather than driving the controller. Its imaging path has no driver module of its own.

A live USB changes the host, not the drive. If it clicks or grinds, booting Linux instead of Windows buys nothing. That is a mechanical or firmware fault, and no imager gets a usable read until it is fixed; a head swap runs on the 0.02µm ULPA-filtered clean bench. That work runs in-house at our Austin, TX lab, and the published pricing for a mechanical hard drive recovery covers the head swap and the imaging that follows it.

When Both Tools Fail: The Physical Failure Boundary

• Clicking or clacking: The heads cannot find the servo tracks on the platter surface. They swing outward, fail to lock onto a track, and retract to the crash stop. Each cycle risks contact between the head slider and the platter.
• Beeping: Hard drives contain no speakers. Beeping is the acoustic resonance of the spindle motor stalling because the heads are stuck to the platter surface (stiction) or the motor bearing has seized.
• Head crash debris: If a head has contacted the platter, microscopic debris contaminates the airflow channel. Software imaging drives the surviving heads through this debris field, causing cascading head failures.
• Firmware corruption: If the drive's Service Area is damaged, the drive may report 0 bytes capacity, show a ROM-mode identity instead of its real model, or fail to spin up entirely. Software imaging tools cannot access or repair the Service Area.

What professional tools do differently

When a drive crosses this physical failure boundary, recovery requires opening the drive in a 0.02µm ULPA-filtered clean bench for head swaps with a firmware-revision-matched donor, or connecting via the PC-3000's diagnostic terminal for firmware repair. The PC-3000 can restrict the maximum head number in ROM and edit the RAM head map so the drive initializes without selecting a crashed head, then image the surviving platters using the Data Extractor utility.

That firmware-level head control is the capability that separates professional hardware from any software imaging tool.

If your drive exhibits any of the symptoms listed above, mail-in recovery is the next step. We charge no fee if the data is unrecoverable.

Choosing the Right Approach

If the drive spins up, is recognized by the BIOS, and produces no abnormal sounds, start with GNU ddrescue. It is simpler to configure, media-agnostic, and handles scattered bad sectors efficiently. Use a Linux live USB, connect the source drive via SATA (not USB, which adds a bridge controller that masks ATA errors), and image to a destination drive at least as large as the source.

If ddrescue stalls repeatedly on the same regions, or the drive intermittently drops offline, the likely cause is a weak read/write head. Switch to HDDSuperClone and enable its head-skipping algorithm. If the drive is connected via direct SATA and still hangs during DMA transfers, enable PIO mode.

If the drive clicks, beeps, grinds, shows 0 bytes in BIOS, or fails to spin, stop. No software will help. The drive needs physical intervention in a professional lab.

Where Does DeepSpar Disk Imager Sit Between OpenSuperClone and PC-3000?

DeepSpar Disk Imager (DDI) is a dedicated imaging appliance rather than a general-purpose software tool. It sits between OpenSuperClone and the PC-3000 on the capability axis: more hardware-level control than any software imager, less firmware-editing depth than the PC-3000 Data Extractor.

DDI connects the source drive through a dedicated PCI-e card or USB 3.0 adapter that exposes hardware-controlled timeouts and a power-relay line to the drive's SATA power. Unlike a host-bus adapter feeding the Linux kernel, the DDI adapter surfaces ATA command status in real time and can issue COMRESET or cut 12V/5V independently from host OS state.

That isolation means a drive lockup cannot freeze the imaging session; the appliance recovers the link without rebooting the host.

DDI builds a heads map during imaging, and DeepSpar documents per-head strategy: heads with different levels of degradation can be imaged using different algorithms and configuration parameters to get the most out of each platter surface.

OpenSuperClone's head-skipping algorithm only reacts to where errors cluster. DDI gates commands at the hardware layer, which keeps a degrading head off the platter surface more reliably when the drive is close to total mechanical failure. Neither appliance performs firmware surgery: a drive that needs translator rebuild, SA module patching, or MR-Head Shift still goes to PC-3000.

How Do SMART Attributes Inform Imaging Strategy?

Before starting any imaging session, read the drive's SMART attributes with smartctl -A. Four attributes change the imaging strategy directly:

• Reallocated Sector Count (ID 5): sectors the drive has already swapped out to the defect list. A high raw value on a drive that is still mostly readable means media degradation is advanced but the heads are tracking. ddrescue with a small cluster size works here.
• Current Pending Sector Count (ID 197): sectors the drive has flagged for reallocation but has not yet rewritten. Every read attempt on a pending sector triggers an internal ECC retry loop that can stall the controller for tens of seconds. On a drive with a high pending count, reduce the ddrescue --min-read-rate threshold or lower OpenSuperClone's skip timeout so the imager jumps past pending sectors on the first pass and returns to them only after the healthy regions are safely cloned.
• UDMA CRC Error Count (ID 199): cable or bridge errors, not platter errors. A rising UDMA CRC count during imaging means the SATA cable, backplane, or USB bridge is corrupting data in transit. Stop, replace the cable, and re-seat the drive. Imaging through a degrading cable silently corrupts the destination image.
• Spin Retry Count (ID 10): rising values indicate spindle bearing wear or head-platter stiction. At this point software imaging is unsafe; the drive needs a controlled power sequence through a hardware imager like DDI or PC-3000.

The operator should read these attributes before starting a session, not during it. Professional hardware like DDI disables the SMART subsystem entirely once imaging starts to prevent the drive from executing background SMART logging or defect scans that compete with host reads for actuator time.

ddrescue does not read SMART because it operates at the kernel block device level; the operator has to poll it manually in a parallel shell between passes. OpenSuperClone exposes SMART logging in its GUI but treats SMART as advisory, not as a trigger for automatic session abort.

Imaging Parameter Tuning for Failing Drives

Both ddrescue and OpenSuperClone accept parameters that control how aggressively they pursue unreadable sectors. Default settings assume a mostly healthy drive. A failing drive with weak heads or degrading media requires parameter tuning matched to the specific failure mode, or the imaging process itself accelerates the damage.

ddrescue parameter strategy

The --min-read-rate flag sets a floor transfer speed (in bytes per second). If the read rate drops below this threshold, ddrescue skips ahead to the next untried region.

Setting --min-read-rate=10M prevents the tool from grinding on sectors where the drive's internal ECC correction loops are stalling the controller. Without this flag, ddrescue waits for the kernel I/O timeout on every bad sector, holding the heads in the degraded zone for 30+ seconds per read attempt.

The --reverse (or -R) flag reads the drive from the last LBA backward toward LBA 0.

The -c flag controls cluster size (the number of sectors read per I/O request). For a first pass on a degraded drive, combining -n (no-scrape) with a reduced cluster size extracts the maximum safe data before any aggressive retry behavior begins.

Direct I/O mode for unbuffered reads

ddrescue's --idirect (short -d) makes the input use direct disc access, bypassing the operating system's buffer and page cache; --odirect (short -D) does the same for the output. That matters on a failing drive.

The kernel cache can return a previously cached, possibly stale block instead of forcing a fresh physical read, and it adds a caching layer between ddrescue and the drive. An unbuffered path reflects the drive's true current state, and a hardware read error isn't masked by a cached copy. Direct access has an alignment constraint: reads must align to the sector or block size, so on some USB bridges it can fail or need a matching --sector-size.

Direct I/O still runs through the Linux kernel block layer. It does not make ddrescue firmware-aware. It can't issue ATA pass-through commands, can't detect or skip a failing physical head, and can't power-cycle or firmware-reset a hung drive. A clicking, beeping, or head-degraded drive still needs hardware imaging on a PC-3000 Portable III or DeepSpar Disk Imager, and where the heads are gone, a clean-bench head swap in our Austin, TX lab.

OpenSuperClone parameter strategy

OpenSuperClone's skip threshold controls how long (in milliseconds) the tool waits for a sector read before marking it as slow and skipping ahead.

For drives that respond slowly due to media degradation but are not mechanically failing, raising this threshold allows the controller time to complete its internal ECC retry cycle. For drives with intermittent head failures that lock the controller on bad sectors, lowering the threshold forces faster skipping and limits head exposure to damaged zones.

In Direct AHCI mode (bypassing the kernel entirely via OSCDriver), soft and hard reset timeouts are independently tunable.

For drives that hang frequently, a shorter soft reset timeout triggers faster recovery from controller stalls. The hard reset timeout controls how long OpenSuperClone waits before issuing a full COMRESET to the SATA port. If the drive requires a full power cycle to recover, the integrated USB relay (YKUSH 3) triggers automatically when both soft and hard resets fail.

How to install and run OpenSuperClone

1. Download the OSC-Live ISO from the OpenSuperClone project and write it to a USB stick.
2. Boot the target machine from that USB stick.
3. Load the OSCDriver DKMS kernel module so Direct AHCI pass-through is available. DKMS builds the module against the running kernel.
4. Connect the source drive by direct SATA where possible, then launch the imaging session, writing to a healthy destination of equal or greater size.
5. Let it build a domain log, then export a ddrescue-compatible mapfile from that domain log. That mapfile lets the run be paused and resumed, or handed to ddrescue for the final scrape and retry passes.

This path only applies to a drive that still images. If the drive clicks, beeps, grinds, or reports 0 bytes, no software imager helps; the heads or firmware have failed and the drive needs the 0.02µm ULPA-filtered clean bench and a PC-3000, not another imaging attempt.

Head Instability Detection and Adaptive Imaging

Head instability is the most dangerous failure mode for software imaging. A weak read/write head can still return data on some sectors while destroying the platter surface on others. Detecting which head is failing before it causes irreversible damage separates a successful imaging session from a catastrophic one.

HDDSuperClone does not identify the failing head. Its self-learning head skipping algorithm reacts to read errors: it skips forward on the first error, widens the skip as errors keep arriving, and by design steps out of the region a bad head serves in about seven read errors. Nothing in that process records a head number, a head boundary, or a zone.

What the operator gets is still worth having. The imager clears an error-dense band quickly instead of dwelling on it, secures everything that reads on the first forward pass, and returns to the skipped ranges once the easy data is already on the destination drive. The tool bought the drive time; it did not diagnose the head.

ddrescue skips on error too, but it waits out the kernel I/O timeout first, and it never sees the ATA error register that says why a read failed. The Linux kernel block device abstraction presents the drive as a flat sequence of logical blocks with no physical geometry information.

When ddrescue encounters bad sectors, it retries them without distinguishing whether the errors come from media defects (safe to retry) or a failing head (dangerous to retry). A weak head forced through its zone can score the platter, creating concentric scratch rings that destroy data stored on all heads sharing that platter surface.

PC-3000 reaches a layer neither software tool can: the head map itself. Restricting the maximum head number in ROM and editing the RAM head map starts the drive with a reduced head set, which both narrows down which head is damaged and keeps the drive from selecting it during imaging. MR-Head Shift is a separate operation in the same family: it adjusts the dynamic part of the translator when a head is damaged, so the drive's LBA mapping stays coherent and the remaining heads can be read without swapping the head stack assembly. Neither operation is reachable from the ATA command set, which is why no software imager performs either one.

Combining ddrescue Mapfile Semantics and HDDSuperClone Skip Behavior on Degrading PMR/CMR Drives

On a Perpendicular Magnetic Recording (PMR) or Conventional Magnetic Recording (CMR) drive with one weak head and otherwise healthy platters, the choice between ddrescue and HDDSuperClone is not exclusive. The two tools track imaging state through fundamentally different data structures, and a lab workflow uses each one where it is safe.

ddrescue mapfile state machine

The ddrescue mapfile (renamed from logfile in version 1.20) is a plain-text record of every byte range on the source drive and its current status. The state machine uses five single-character status codes:

• ? non-tried: ddrescue has not yet attempted these blocks; the copying phase targets them first.
• + finished: blocks already read successfully and copied to the destination; never re-read from the source on resume.
• / failed block non-scraped: blocks that survived the trimming phase and await sector-by-sector scraping.
• * failed block non-trimmed: blocks that failed the initial copying phase and have not yet had their edges trimmed inward sector by sector.
• - failed block bad-sector: blocks that failed the scraping phase. These are the targets of the retry passes (-r3 requests three retry passes); in fill mode they can be overwritten with a marker string to identify which files lost data.

The mapfile also stores a status line with the current byte offset, current operation character, and current pass number, so a session interrupted by a crash, a kernel panic, or a drive dropping offline resumes at the exact pass and direction it was running. The mapfile is sequential and head-blind: every status entry refers to a contiguous byte range with no awareness of which physical head services that range.

Reading ddrescue mapfiles with ddrescueview

ddrescueview is a graphical viewer that parses a ddrescue mapfile and paints every block onto a grid, coloring each cell by its status code. An operator sees at a glance where finished (+), non-tried (?), non-trimmed (*), non-scraped (/), and bad-sector (-) regions cluster across the LBA space, rather than reading the raw text log by hand.

Its read-only design is the safety-critical part. ddrescueview never opens, mounts, or sends a command to the source drive; it reads the mapfile text and nothing else, so it is safe to open repeatedly during or after a run while the failing drive stays powered off or idle. Where the unread ranges sit in the LBA space is what tells the operator where to aim the later passes.

HDDSuperClone domain log and adaptive command timeout

HDDSuperClone (and its actively maintained fork OpenSuperClone) records imaging state in a domain log. Each entry carries the starting LBA of a block, its size in LBAs, its status, and the skip and error detail behind that status. There is no head field, because the software never establishes one.

The self-learning head skipping algorithm feeds that log. On a read error it skips forward by the current skip size and keeps enlarging it while errors continue, which clears the region a bad head serves in about seven read errors. Later passes work from the same record: a forward pass with skipping, a backward pass with skipping, a pass that skips on read rate rather than read errors, and a final sweep of whatever was never tried.

The second architectural difference is timeout granularity. When ddrescue issues a kernel read, the request is governed by the Linux SCSI error handler. The default block-device I/O timeout is 30 seconds.

If the timeout fires, the SCSI error handler runs its own reset escalation before the read returns to user space, which adds more time the imager cannot control.

While ddrescue waits, the drive is internally retrying the sector: the voice coil motor sweeps the head across the platter to reacquire the servo signal, the read channel re-runs ECC correction loops, and on a drive with a weak head, each of those retries adds mechanical wear. ddrescue cannot interrupt that wait through the kernel.

HDDSuperClone, running in Direct AHCI mode through OSCDriver, sets its own skip timeout, soft reset timeout, and hard reset timeout independently of the kernel. The skip timeout can be lowered on a drive with intermittent head failure to limit how long the failing head dwells on damaged media on each attempt.

The soft reset timeout can be lowered on a drive that hangs frequently, so the imager triggers an ATA soft reset and resumes faster than the kernel error handler would. If the soft reset fails, the hard reset (COMRESET) timeout controls when HDDSuperClone escalates to a full SATA bus reset.

If both resets fail to revive the drive, integration with a switchable power relay (a YEPKIT YKUSH 3 controls USB VBUS for 5V-only 2.5" drives; for 3.5" drives the YKUSH 3 is paired with an external 12V relay board so both rails drop together) lets the imager cut power, wait for spin-down, and restore power without operator intervention. None of these escape paths exist for a tool reading through the kernel block layer.

Why this matters on a degrading PMR or CMR drive

PMR and CMR drives map LBAs across heads in a serpentine zone pattern, so a weak head's damage concentrates inside its zones while neighboring zones, served by healthy heads, read at full interface speed. ddrescue treats the LBA space as flat and a long sequential pass will drag the failing head through its entire zone before reaching the healthier neighbors.

Each 30-second wait on a failed sector inside that zone is a 30-second mechanical stress event for the weakest head on the head stack. HDDSuperClone skips out of the error-dense band quickly, images what reads on the first pass, and only returns to the skipped ranges once the safe data is secured.

How a lab actually sequences the two tools

The PC-3000 Portable III and DeepSpar Disk Imager sit upstream of either software imager. Before any sustained imaging begins, a firmware-aware pre-imaging stage handles work neither ddrescue nor HDDSuperClone can: disabling SMART self-tests during imaging so the drive does not spend actuator time on internal housekeeping, suppressing background defect reallocation, and on PC-3000 specifically, restricting the maximum head number in ROM and editing the RAM head map so the drive initializes with a reduced head set that leaves the damaged head unselected.

That hardware stage stabilizes the drive enough that any subsequent software imaging is operating on a known head map rather than on an error pattern.

With the drive stabilized, HDDSuperClone runs its skipping passes through ATA pass-through, accumulating a domain log of which ranges read, which were skipped, and what error triggered each skip. The output is a binary clone on a destination drive, plus that log recording which LBA ranges remain unread and why.

The readable ranges are already imaged, so that data is secured on the destination clone and never needs to touch the patient drive again. OpenSuperClone can export a ddrescue-compatible mapfile from its domain log, which means ddrescue can resume with full knowledge of which LBA ranges are finished and which are still bad.

The unread sectors only exist on the platters, so ddrescue runs its final scrape and retry passes against the powered-on patient drive, targeting only those remaining bad ranges. ddrescue's strengths, -r3 retry passes, --reverse direction changes, and the trim/scrape state machine, are aimed only at the unresolved sectors so the failing drive spends its limited runtime reading data that is still missing rather than re-reading sectors already safe on the clone.

A drive that needs this sequenced workflow has crossed past simple media degradation into partial head failure. Pricing for hard drive data recovery at the head-swap tier starts at $1,200–$1,500; donor drive cost is additional (Donor drives are matching drives used for parts. Typical donor cost: $50–$150 for common drives, $200–$400 for rare or high-capacity models. We source the cheapest compatible donor available.). +$100 rush fee to move to the front of the queue is available when timing matters.

How Does PRML Read Channel Tuning Recover Marginal Sectors?

When a bad-sector-dense drive with head weakness refuses to return data, the question is not whether the imaging tool will retry; it is whether the drive's analog read channel can be persuaded to decode the signal on a different set of rules. This is the layer ddrescue cannot reach and the reason mechanical hard drive data recovery paired with PC-3000 Data Extractor pulls data that open-source imagers abandon.

The read channel pipeline

Every modern HDD runs incoming flux through a fixed signal chain: the MR/TMR head preamplifier raises the microvolt-level signal, an Automatic Gain Control loop and Variable Gain Amplifier normalize amplitude, a Continuous Time Filter (CTF) performs anti-aliasing and pulse-slimming, an ADC samples into the digital domain, an equalizing Finite Impulse Response (FIR) filter shapes the sampled waveform to match a target polynomial (PR4, EPR4, EEPR4), and a Viterbi maximum-likelihood sequence detector walks a trellis of branch metrics to pick the most probable bit sequence.

An LDPC or Reed-Solomon decoder handles whatever residual errors remain. This is the Partial Response Maximum Likelihood (PRML) architecture; modern drives use extended variants (EPRML, EEPRML) to handle the inter-symbol interference that comes with high areal density.

Why ddrescue retries fail on head-weakness damage

ddrescue's retry loop reissues the same block-layer read through the kernel. It changes nothing the drive uses to decode the sector; the read channel re-adapts to the same degraded signal on every attempt.

If the drive's internal decoder could not resolve the sector on the first attempt, the analog noise profile on the second attempt is not meaningfully different, and the Viterbi detector fails to establish a valid path again. The heads keep sweeping the damaged zone on each retry; each sweep adds mechanical wear without changing the decoding math.

How multi-pass imaging changes the physical read margin

HDDSuperClone and OpenSuperClone do not alter the read channel directly, but the head-skip and reverse-direction options change the approach velocity and track-seek direction before each read attempt.

A sector that failed on one pass sometimes reads on a later pass after the heads have seeked away and back.

DeepSpar DDI pushes this further by gating commands at the hardware layer.

PC-3000 retunes the read-channel adaptives per head

PC-3000 Data Extractor reaches the adaptive parameters the drive normally keeps private. On Western Digital ROYL drives, Module 47 holds the per-head microjog and servo adaptive parameters.

The technician can retune the FIR equalizer taps so a degraded waveform still resolves against the target response, raise the VGA gain on a weak head, or alter the read channel's adaptive tracking parameters. Sectors the stock parameters return as unreadable come back as data on a head that is producing marginal but still-informative flux.

One more command belongs in this family, and it is routinely oversold. Read Ignoring ECC, the old ATA READ LONG, returns whatever the drive pulled off the platter on its first attempt instead of returning an error. No correction is applied by the drive or by anyone else, no analog samples cross the SATA cable, and the command is LBA28, so it cannot address past the first 128 GB of the drive. Modern drives frequently refuse it. Anything it does return has to be validated against the surrounding sectors before it goes into a customer's image.

That per-head analog adaptation is why a drive ddrescue writes off as uncorrectable still images cleanly on a PC-3000-paired workflow.

Drive-Family-Specific Imaging Strategies

Different HDD families have unique firmware behaviors that determine which imaging tool is appropriate. A parameter configuration that works on one drive family can cause permanent data loss on another. The following pathologies are common enough that anyone imaging drives regularly will encounter them.

Seagate F3 translator damage

Seagate drives using the F3 firmware architecture store their LBA-to-physical translator in System File 0x1C of the Service Area. When this system file corrupts, the drive reports 0 GB capacity to the BIOS. Neither ddrescue nor OpenSuperClone can image a drive with no valid LBA mapping because there are no addressable sectors to read.

PC-3000 connects to the Seagate diagnostic terminal (a serial interface on the drive's PCB) and regenerates the translator using vendor-specific commands. If the drive's defect list contains conflicting entries, the translator regeneration fails and the defect list requires manual editing before the translator can rebuild. This is firmware surgery that no software imaging tool can perform.

Seagate Rosewood SMR complications

The Seagate Rosewood family (including the ST2000LM007) uses Shingled Magnetic Recording with a Media Cache Management Table (MCMT) stored in System File 348. When a shingled band migration is interrupted by power loss or firmware crash, the MCMT corrupts and the drive enters a degraded state where reads stall intermittently.

The critical danger with Rosewood drives is the legacy F3 translator regeneration command (m0,6,2,,,,,22). On non-SMR Seagate drives it safely rebuilds the translator, but on Rosewood it ignores the Non-Resident G-list and wipes the MCMT, destroying the mapping between the media cache and the final data bands.

A Rosewood drive in that state goes to firmware repair rather than a terminal command. The background firmware activity is stopped through Service Area intervention before the imaging pass starts, so the drive does not attempt to complete the interrupted band migration during the session.

Western Digital encrypted external drives

Western Digital external drives in the Spyglass family (e.g., WD40NMZW) integrate the USB 3.0 interface and a Self-Encrypting Drive (SED) AES engine directly into the drive's main Marvell microcontroller unit. There is no separate bridge chip, and the native USB PCB has no SATA connector, so a plain board swap does not by itself produce a readable drive.

ddrescue and OpenSuperClone can image the drive over USB, but they see the encrypted data stream produced by the native SED engine. Recovery requires PC-3000's Western Digital module to access the drive through vendor-specific firmware modes (typically via a micro-soldered SATA bypass to the native PCB) and apply the SED key during imaging to produce a decrypted image.

When PC-3000 Data Extractor Is Required

When software imaging tools reach their architectural limits, professional hardware provides firmware-level access that no software can replicate. The following failure modes require PC-3000 intervention because the drive's own firmware blocks access to the data at a level below the operating system.

Self-encrypting drives with the key in the Service Area

A locked self-encrypting drive returns ciphertext to any standard imaging tool, and there is no generic credential-less bypass that covers these drives as a class. What exists is vendor-specific. On WD Marvell drives, PC-3000's Western Digital module locates the encryption key in the Service Area (module 38, or a module backup taken beforehand) and applies it during imaging through Data Extractor's decrypt option, with the WD utility left running for the whole session. WD SMR families gained a SED unlocking option in PC-3000 7.1.x. A locked Seagate F3 Rosewood drive needs a patch that restores technological access, which is not a decryption of user data. Outside those documented paths the drive stays encrypted, and no imager changes that.

Thermal asperity and degraded read heads

A thermal asperity event occurs when a read head's magnetoresistive element makes intermittent contact with the platter surface, generating heat spikes that distort the read signal. PC-3000 can retune the read-channel adaptives on the affected head, and sectors that the stock parameters cannot resolve sometimes read afterwards.

Diagnostic port locks on Seagate F3 drives

Newer Seagate F3 families ship with the diagnostic terminal locked, so the T> prompt does not accept commands. PC-3000 dumps the SPI ROM and injects a volatile RAM-resident Tech Mode unlock patch, which restores diagnostic-terminal access for Service Area repair. It does not decrypt user data and it does not bypass SED or ATA password locks.

Head map editing on a drive with a dead head

A drive with one destroyed head on its head stack assembly can still hold every byte the customer needs on the surviving surfaces, and the obstacle is that the firmware keeps selecting the dead head. PC-3000 restricts the maximum head number in ROM and edits the RAM head map, so the drive initializes with a reduced head set and does not address the damaged head during imaging. That same session narrows down which head is bad: the operator starts with fewer heads and changes the maximum head number to see which configurations come up. Where the translator has to stay coherent while the remaining heads are read, MR-Head Shift adjusts the dynamic part of the translator instead. Neither operation exists in ddrescue or OpenSuperClone; both need vendor-specific firmware commands.

If your drive exhibits any of these firmware-level failures, professional hard drive recovery with PC-3000 hardware is the only viable path. Attempting software imaging on a drive with an active SED lock, diagnostic port lock, or shorted head element produces no data and risks making the failure permanent.

Frequently Asked Questions

If your drive has crossed the boundary where software imaging tools fail, professional hard drive data recovery or SSD data recovery starts with a free diagnostic. Drives exhibiting the SATAFIRM S11 firmware failure or WD slow-responding symptoms that resist OpenSuperClone's RAM patches require PC-3000 hardware intervention. We charge no fee if recovery isn't possible; HDD head swap recovery starts at $1,200–$1,500.