$ guides / nvme / nvme-namespace-sector-size ▌

Operations Guides

NVMe namespaces and the 512e vs 4K sector-size trap

A namespace formatted for 512-byte logical blocks (512e) while the workload, filesystem, or encryption layer assumes 4K blocks produces no errors, no SMART warnings, and no kernel log entries. It just makes the controller do more work per host write than it should. This is one of the genuinely silent NVMe failure modes: everything looks healthy while write amplification quietly burns endurance and adds latency.

The trap is a provisioning-time decision with runtime consequences. Many drives ship formatted 512e for compatibility. Someone creates a filesystem, a LUKS volume, or a ZFS pool on top, and the mismatch is locked in until the namespace is reformatted, which destroys the data on it.

This article covers how the amplification happens, how to check what format your namespaces are running, how to change it safely, and why the problem gets worse on multi-namespace drives where all namespaces share the same NAND, spare blocks, and garbage collection bandwidth.

Namespaces in brief

An NVMe namespace is a logical address space exposed by the controller, roughly analogous to a SCSI LUN. A drive can expose one namespace or many. Each namespace is formatted with an LBA format chosen from a list the controller supports: typically 512-byte and 4096-byte data sizes, sometimes with metadata variants.

Two terms matter:

512e (512-byte emulated): The logical block size is 512 bytes, but the underlying NAND works in larger pages. The controller emulates small blocks on top of big ones.
4Kn (4K native): The logical block size is 4096 bytes, matching how the flash is actually written.

Controllers advertise a relative performance hint for each supported format. On many drives the 512-byte format is marked as degraded or merely good, while 4K is marked best. That hint is the vendor telling you the emulation is not free.

How the 512e amplification works

NAND cannot be rewritten in place. The controller’s flash translation layer (FTL) maps logical block addresses to physical pages and handles erase-before-rewrite through garbage collection. When the logical block size is smaller than the granularity the NAND prefers, writes that are not aligned to the physical granularity force the FTL into read-modify-write cycles: read the surrounding data, merge in the new 512-byte sector, write the combined result somewhere new.

The consequences compound:

Extra NAND program/erase cycles per host write. The host sees one logical write; the NAND sees more physical work. This is write amplification that never appears in host-visible counters.
Faster endurance consumption. Percentage used climbs faster than the host write volume would predict.
More garbage collection pressure. GC competes with host I/O for controller resources, so latency variance grows, especially as the drive fills.
Invisible in standard telemetry. NVMe SMART data units written tracks host-visible I/O, not NAND-level writes. True write amplification factor requires vendor-specific log pages, so a 512e mismatch will not show up as an obvious counter anywhere.

flowchart TD
  A[Application issues writes] --> B{Namespace LBA format}
  B -->|4Kn native| C[One NAND operation per write]
  B -->|512e emulated| D[Read-modify-write in the FTL]
  D --> E[Extra program/erase cycles]
  E --> F[Higher write amplification]
  F --> G[Faster spare consumption + GC pressure]
  G --> H[Latency variance rises as drive fills]
  G --> I[On multi-namespace drives: shared spares starve other namespaces]

Where the mismatch shows up in production

Several common layers make their own sector-size assumptions, and each has its own failure flavor.

dm-crypt / LUKS. If the LUKS segment uses a 512-byte sector size on a device whose physical granularity is 4K, every 4K encrypted write triggers read-modify-write in the encryption layer. There is a documented case of a roughly 50% write performance penalty from a hardcoded 512-byte LUKS sector size. Cryptsetup 2.4.0 and later auto-detects 4096 bytes for 4K and 512e devices; older versions require --sector-size=4096 at format time.
ZFS. A pool created with ashift=9 (512-byte blocks) on a 4Kn or 512e drive causes severe write amplification. These drives need ashift=12. The ashift is fixed at vdev creation, so getting it wrong means recreating the pool.
LVM. Operations such as pvmove, lvconvert --merge, and extending a volume group have been reported to fail when the underlying block devices have mismatched sector sizes, for example mixing a 512e namespace and a 4Kn namespace in the same VG.
The kernel’s view. Since kernel 5.3, the kernel computes physical_block_size for NVMe from the logical block size plus namespace hints such as the preferred write granularity. A 512e namespace typically reports a 512-byte logical block size with a 4096-byte physical block size. Layers that align to the physical size behave well; layers that only look at the logical size do not.

One more caution: some drives that claim 4K support exhibit sporadic instability after being reformatted to 4K, especially under heavy random read load. Test a reformatted drive under realistic load before trusting it with data.

How to check your namespaces

All of these are read-only and safe to run on production systems.

# List supported LBA formats, data sizes, and relative performance hints.
# The "(in use)" marker shows the active format.
nvme id-ns -H /dev/nvme0n1 | grep "Relative Performance"

# Logical and physical sector sizes as the block layer sees them.
lsblk -td /dev/nvme0n1

# The same values from sysfs.
cat /sys/block/nvme0n1/queue/logical_block_size
cat /sys/block/nvme0n1/queue/physical_block_size

What to look for:

In nvme id-ns output, a 512-byte format marked “(in use)” while a 4096-byte format is available and rated better is the trap, armed.
A 512e device shows LOG-SEC 512 and PHY-SEC 4096 in lsblk -td.
If a namespace shows 512/512 (logical and physical both 512), the drive is presenting true 512-byte blocks and there is nothing to fix at the namespace layer.

For multi-namespace drives, enumerate what exists before assuming a 1:1 controller-to-namespace mapping:

# Namespaces attached to this controller
nvme list-ns /dev/nvme0 --all
nvme list

Changing the format

The fix is nvme format with the target LBA format index. The index is the number in the nvme id-ns output, not the data size. On many drives index 1 is the 4K format, but always confirm against your own id-ns output.

This command destroys all data on the namespace. There is no undo. Verify backups, verify you are targeting the right device, and expect the namespace to be wiped.

# DESTRUCTIVE: reformats the namespace to LBA format index 1 and erases its data.
nvme format --lbaf=1 /dev/nvme0n1

Two known obstacles:

Format not supported. Some controllers do not support the Format NVM command at all. Check nvme id-ctrl /dev/nvme0 | grep oacs; bit 1 of the OACS field must be set for format support. If it is not, you cannot change the LBA format on that drive.
ACCESS_DENIED. Drives that have been in use sometimes refuse a format with an access-denied status. A suspend/resume cycle or a full reboot commonly unlocks the firmware enough for the format to proceed.

After reformatting, recreate the upper layers with matching assumptions: cryptsetup luksFormat --sector-size=4096 if you are on an older cryptsetup, ashift=12 for ZFS, and 4K-aware partition alignment (modern partitioning tools align to 1 MiB by default, which covers both cases).

Multi-namespace drives: shared spares, shared pain

Namespaces are logical partitions over one physical device. The NAND, the spare block pool, the wear leveling, and the garbage collection bandwidth are all shared. The controller can still wear level and share spare area across namespace boundaries.

That means one namespace’s write abuse is everyone’s problem. A namespace formatted 512e under a write-heavy workload consumes spare blocks and GC bandwidth at an inflated rate, and the other namespaces on the same controller inherit the consequences: their latency variance rises, their share of GC bandwidth shrinks, and the drive’s overall endurance runway shortens. Nothing in per-namespace host I/O counters will point at the neighbor as the cause.

This changes the triage habit: when one namespace on a shared drive shows unexplained write latency variance or the drive’s available spare is declining faster than expected, check the LBA format and write behavior of every namespace on that controller, not just the noisy one.

Unexpected namespace management events are also a security and integrity signal, not just a configuration detail. Namespace create, delete, attach, and detach events that were not planned are ticket-worthy, and any unexpected format or sanitize command is a potential data destruction event worth paging on.

Signals to watch in production

Signal	Why it matters	Warning sign
LBA format in use (from `nvme id-ns`)	The root cause; 512e with a 4K-assuming stack is the trap	512-byte format in use while a better-rated 4K format exists
Percentage used rate	Endurance consumption accelerates under hidden write amplification	Growing faster than host write volume explains
Data units written vs. percentage used	Divergence between host writes and wear rate is the observable shadow of amplification	Wear climbing much faster than host write volume justifies
Available spare and its trend	512e abuse consumes shared spares faster; the last stretch of spare depletes nonlinearly	Steady decline, or approaching the vendor threshold from above with a steepening slope
Write latency variance	GC pressure from amplified writes shows up as tail latency before anything errors	Periodic write latency spikes with normal temperature and no media errors
Namespace management events in kernel log	Create/delete/attach/detach and format commands change what your data means	Any event outside a planned change window

How Netdata helps

Netdata tracks percentage used (nvme.device_estimated_endurance_perc) and data units written (nvme.device_io_transferred_count) per device, so you can spot endurance consumption that outruns host write volume, the main observable symptom of hidden write amplification.
Available spare (nvme.device_available_spare_perc) is charted against the vendor threshold, so accelerated spare consumption from a misbehaving namespace shows up as a trajectory change, not a surprise threshold crossing.
Media and error log rates (nvme.device_media_errors_rate, nvme.device_error_log_entries_rate) confirm whether the wear is progressing into active degradation.
Per-block-device I/O throughput and latency charts let you compare namespaces on the same controller and see whether one namespace’s write pattern coincides with latency variance on the others.
Kernel log monitoring for NVMe format, sanitize, and namespace change events closes the integrity loop on unexpected configuration changes.