Changelog
This page is hw/femu/docs/CHANGELOG.md at FEMU d8b29b1e0 (2026-11-16), licensed GPL-2.0-or-later. Send corrections to the FEMU repository.
User-visible changes to FEMU. Each entry names the commits it comes from;
git show <hash> has the details.
Unreleased (since femu-v9.0.1)
655 commits after the femu-v9.0.1 tag (2024-06-20), dated 2024-08-07 to
2026-10-01, plus the documentation and script fixes that close this list.
Tests, CI-only changes, internal refactoring and wording fixes are not
listed one by one.
QEMU base
- FEMU now builds on QEMU 10.1.0 instead of 9.0.1, with device registration moved to the current QEMU APIs (eafddfdd0).
- Two QEMU TCG fixes are carried from upstream QEMU. Without them a vCPU could resolve a stale memory section after a device was unplugged and stop QEMU with an assertion (ef516ed58, c66409e3b).
- Two QEMU CXL fixes are carried: the background command timer is freed with its CCI, and a CXL Type 3 device releases its mapped backends when realize fails (43040a04c, 6153becf8).
- QEMU's network block drivers are left out of the FEMU build, which fixes compilation against libnfs 6 (81c4385fc).
New devices, modes and features
CXL SSD (new device)
- New
femu-cxl-ssddevice: a CXL memory device whose accesses go through a DRAM buffer cache and FEMU's FTL and NAND timing (bb9aea670, a8627fcf9, 7777c0d53, 6ffe34f17). - The buffer cache gained runtime controls, scalable associativity, per-page pin and remove, and NAND geometry properties for larger capacities (f5ba3ff12, 38b314181, 76f180b9d).
- Direct mapping modes
der=memslotandder=cylonmap hot pages straight into the guest, with configurable direct mapping ratios and LSA mailbox commands to control them (80803505b, b3e042a84, 1f26fb2df, 8266a291e, a1e550885). - A CXL caching API is served on BAR5, with a guest library, the
ccactltool and a guest self-test (924714c18, 1235e87d2, ec3af4ba4, 0a357d11e, defd999b8). - Cache misses to different pages wait for the media together, by default only while a direct mode is active, and long media waits sleep instead of spinning (b72d14dbe, 64d424dd2, 133c553ca, 145fcfe4b).
- A bbssd NVMe controller can share a
femu-cxl-ssdmedium throughcxl_ssd=<id>, with writes, deallocates and flips kept consistent between the two front ends (146a240dc, d73a5b780, a7a3c5678, 353bbe107, 287e5c885, 6783d50af). - A runtime
fast-loadswitch onfemu-cxl-ssdlets warmup and data loading skip the wait for modelled media time while the FTL, cache and counters still run. Switching it off leaves the queued NAND work on the timelines and reports it infast-load-drain-ns; a harness polls the newnand-idle-nsuntil it reads 0 before it measures. - With
der=cylonon a host kernel that hasKVM_CAP_CYLON_FAULT_EXIT, an instruction KVM cannot decode (VEX, EVEX, most SSE with a memory operand) on an unmapped page no longer hangs its vCPU: FEMU fills and maps the page and the guest runs the instruction natively, or stops the VM with a report when the page cannot be mapped or the instruction makes no progress (100,000 consecutive refills at one RIP by default; the new propertycylon-fault-stopsets the bound, and 0 only warns, because the bound counts exits, not instructions, and a healthy loop over more pages than the cache holds can reach it). Instruction fetches from an unmapped page (for example a shared library cached on the CXL node) are mapped, not emulated, so code such asendbr64runs natively. New propertycylon-emul-exitand countersder-emul-exit,der-emul-fills,der-emul-fetch-fillsandder-emul-failures. - With version 2 of
KVM_CAP_CYLON_FAULT_EXIT, KVM does not emulate accesses to coldder=cylonpages: it exits with the exact access type and FEMU maps the page, so every instruction runs natively. New propertycylon-never-emulatedefaults toauto, which turns version 2 on when the host kernel reports it and otherwise warns once and uses version 1;onwarns when the kernel lacks version 2, andoffkeeps version 1. Pages FEMU cannot map go back to the emulator. The pages kept in the cache for an instruction bind other vCPUs' fills for only 1 ms, so a vCPU that stops faulting cannot close a cache set to the others. An instruction whose pages do not fit in their cache set is completed by the emulator, or mapped outside the cache when the emulator cannot run it, instead of refilling its pages for ever; new countersder-fault-conflictsandder-fault-overflows. New countersder-emul-v2,der-fault-reads,der-fault-writes,der-fault-fetches,der-fault-page-walks,der-fault-emulatedandder-fault-unprotected.der=cylonnow refuses a machine withoutsmm=off, which it always required. - With version 2 on, an eviction that must flush the VM's TLBs also revokes the mappings of the next pages the cache evicts, so up to
cylon-revoke-batchpages (default 64, at most 256) share the two flushes. On a d760 run with random reads, 64 gave 8 vCPUs 111.7k operations per second against 104.2k at 32 (bf2197a37). Version 2 maps every filled page and the guest then uses it, so nearly every eviction needed the two flushes, and with several busy vCPUs they serialized all vCPUs. The pages revoked ahead stay cached; an access maps them again as a hit. New countersder-revoke-flushes,der-revoked-aheadandder-ahead-remaps. - With version 2 on, FEMU serves the fault exits of cold
der=cylonpages without the BQL, under a lock of its own, so misses of different vCPUs no longer queue for the BQL. A fill also waits out its media time and checks the frame it maps while that lock is released. On the R0 pilot with 8 vCPUs the exits waited about 90 us of a 136 us miss for the BQL. New counterder-fault-bqlcounts the exits that still needed the BQL (28f80da22). The lock becomes a mutex only when version 2 is on; until then its holders hold the BQL, so version 1 MMIO pays nothing for it. - A
femu-cxl-ssdwith the FTL on no longer goes uncached when its NAND is full. Realize refuses NAND that leaves less than 7% of the media as spare beyond the forced collection reserve and two working lines. The error names the smallestblocks-per-planethat meets the rule, and automatic sizing meets it. A write at the forced threshold now waits until the collection erases end on every LUN, counted in the newgc-stallsandgc-stall-ns;gc-stall-max-nsis the longest wait, and a wait over one second warns once per device. A program that still finds no page loses only its timing and counts inmedia-full; it no longer stops an eviction or an insert.run-cxlssd.shpresets for 48G and 96G use the least NAND the rule accepts (867 and 1732 blocks per plane). - A device that copies into
femu-cxl-ssdmemory from its own MMIO handler or bottom half, such as QEMU's NVMe controller when the guest page cache is on the CXL node, no longer loses doorbell writes. The copy used to release the BQL while that device's re-entrancy guard was engaged, so a vCPU's doorbell write was refused ("Blocked re-entrant IO on MemoryRegion: nvme") and the guest timed out. Such copies, and NIC receive copies, now complete without releasing the BQL and queue their media time instead, without waiting for a garbage collection in progress, and the FTL worker still lets waiting accesses in between them; new countersdma-accesses,dma-media-opsanddma-media-time-ns. Devices that run in an IOThread are not covered.nand-idle-nsstays above 0 while these operations are queued. - The
femu-cxl-ssdFTL worker wakes only the access whose request it finished, instead of every waiting access. On ader=cylontest with 8 and 16 vCPUs doing random reads that all miss a 256-page cache, throughput rose about 40% (65k to 91k and 70k to 98k accesses/s), because waiters no longer wake for other requests. der=cylonalso accepts slot tables that the host kernel maps as refcounted pages (mmin/proc/self/smaps), not only as raw PFNs (pf). A Cylon kernel that maps them this way can free the tables of a deleted slot once FEMU unmaps them.
New modes and data placement
- Flexible Data Placement (FDP) on a new
femu-subsysdevice, with reclaim unit handles, FDP log pages, I/O Management commands and several GC strategies (c966d341a, 6df00de01). - FDP placement features can be read and enabled by a Linux host, and the host sees its active reclaim unit and remaining space (8f00c7117, 9a66fe52d).
- FDP accepts
trim_lat_nsandecc_retention_sec. A deallocate pays the same time per range as without FDP. The age of a reclaim unit counts from its retirement and starts again when collection frees it. - FDP accepts
read_reclaim_limitandretention_limit_sec. A read queues the reclaim unit of its line. The next write moves the valid pages of that unit to where collection would move them. The moves count in MBMW and in the C0h refresh counters. - FDP accepts
gc_policy. Each name picks the reclaim unit version of its policy:cost-benefitandrandomaregc_strategy1 and 2,fifotakes the unit retired first, andd-choicethe fewest valid pages of 4 random units. A name other thangreedyneedsgc_strategy=0. - FDP accepts
mapping=dftl. A placed write charges the translation page of each page it programs, as a write without FDP does. - FDP accepts
buffer_size. Each held page keeps the placement handle of its last write and goes to that handle's reclaim unit when it is written back. RUH Update, Flush and disabling the volatile write cache write the buffer back first, and fail with Capacity Exceeded if a page finds no room. - FDP still refuses
hot_cold_sepand thehybridandfastmappings, and the message now says why: they write host data through pointers of their own, past the unit the placement handle names. - New
namespace_phlsproperty: a placement handle list for each FDP namespace. Placement handleiselects entryi. A handle no list names is reported unused in log 21h. Unset, every namespace gets every handle, as before. - FDP takes more than one namespace. The reclaim units of an endurance group are shared, so every bbssd namespace of the controller places into one FTL; NoSSD namespaces report their lists only. Namespaces that share a handle keep one format, and events from collection name the namespace of the data they moved.
- query-femu reports the placement handle list of each FDP namespace (
placement-handles). It also reports the namespace whose FTL holds the units (ftl-nsid).femu-stat.pyandfemu-config-check.pyshow both, and the latter counts over-provisioning over the namespaces that share one FTL. - FDP HBMW and the host bytes of each handle count the logical blocks the host wrote, as Base 2.3 Figure 293 defines HBMW. A 512-byte write on a 4 KiB page now adds 512, not 4096; MBMW still counts the programmed page.
- FDP takes more than one reclaim group (
fdp.nrgup to 128). On bbssd and CSD a group is a set of dies: whole channels, or LUNs of one channel. A reclaim unit is one block of each plane of each die of its group, so RUNS is a line divided by the group count. Each handle has an active unit and a collection unit in every group. Collection, pads and refreshes stay in their group. - With more than one reclaim group, a write without placement goes to the group with the most free units. Each group must hold the whole namespace, since a host may place all of its data in one. A logical block must be whole NAND pages.
- Under FDP, a buffered write that finds the write buffer full of pages with no room programs its page at once when its own handle has room, instead of failing with Capacity Exceeded. RUH Update writes back only the held pages of the handles it names.
- query-femu lists the reclaim groups of an FDP namespace (
groups) with their dies and free units;femu-stat.pyandfemu-config-check.pyshow them. - Computational Storage Drive mode (
femu_mode=4) with program load and execute commands, routed through the bbssd FTL (eb01bb73b, 50b65ca91). - CSD
nr_cuandcsf_runtime_scalenow take effect (202ab7afb). - A CSD runtime shorter than the program's own run on the host cannot be reached, since the completion carries the result; QEMU now warns once when that happens (b8e8d6b45).
- Opt-in
csd_pausestops the guest while a CSD program runs on the host. Under KVM the kvmclock and the TSC skip the stop. The controller times its I/O on a clock that stops too, so the guest sees the modelled run time.csd_pause_max_msbounds a stop. - Key-value SSD mode (
femu_mode=5) with store, retrieve, list, delete and exist commands (e72465909). - Every KV namespace has its own command set and key space, the KV command set is advertised to the host, and the KV Configuration feature is served (39664d242, e62db84f2, e4949509c).
- Opt-in KV workload-mix timing (
kv_timing=model): Store and Retrieve take their time from the Samsung KVSSD emulator fit over the last 16 of them, or from coefficients inkv_model_coeffs. A device with no KV namespace refuses both. - Opt-in LSM-tree key index for KV namespaces (
kv_index=lsm), after PinK (ATC '20): a DRAM memtable, levels bykv_lsm_size_ratio,kv_lsm_pinned_levelsheld in DRAM. Lookups read a meta page per unpinned level, and merges load the NAND in the background. Value GC puts moved keys back in the memtable, and List returns keys in byte order. The default hash index is unchanged. LSM knobs withoutkv_index=lsm, andkv_index=lsmwith no KV namespace, are refused. query-femureports the LSM-tree key index of a KV namespace withkv_index=lsmin anlsmmember: the memtable, each level, merges and meta page I/O.femu-stat.pyandfemu-config-check.pyshow it.query-femureports KV value packing in apackmember: the open page, packed pages, pad bytes, GC moves of values and the host bytes.femu-stat.pyprints it, andfemu-config-check.pyshows whether packing is on.
Namespaces
- Multiple namespaces per controller via
namespacesandnamespace_sizes(140b2891e, 2e25897fe). - Namespaces on one controller can run different modes via
namespace_modes(053fd8936). - Opt-in Namespace Management and Attachment (
ns_mgmt=on) for NoSSD and bbssd, with a bbssd namespace cap (bbssd_ns_limit) (b12bc8754, d9c9f2251, b48799800, e0fa92f19, 42369e0bd). - Namespace attribute changes are reported through AER and log page 04h, and recorded in the Persistent Event log (3630d6fa0, cc9e271b4).
- Namespaces can be created with protection information (c213b120c).
- Shared namespace management across controllers of one
femu-subsys,ns_mgmt=on, with the subsystem owning namespace storage (ca80e3dc5, 23844afaa, feebe635c, 76cc58f63, 97fc6ae0a, 349f12d40).
Metadata, protection information and Streams
- Separate LBA metadata (
meta,mc) on bbssd and NoSSD namespaces (62d149dd5). - Metadata interleaved with data (extended LBAs,
extended=1or Format with MSET) (ba36f0f68). - Opt-in protection information formats (
pi=on), with generation and checking on Read, Write, Verify, Compare, Write Zeroes and Copy (bb2f3fb06, d1d8e1593, 617f09c10, 1854c1940, f6dc00f46, 98fcaedea, 8f7382c2a, 9661e5adb). - Opt-in Streams directive (
streams,streams.max), with stream writes placed on separate bbssd write frontiers (623637942, 8e7387268, cb459a65b, e3529d48f).
NVMe commands, features and log pages
- With
csd_slm_size, CSD mode adds an NVMe Subsystem Local Memory 1.2 namespace. It takes Memory Read, Write, Fill and Copy. Withcsd_cp=on, CSD mode also adds an NVMe Computational Programs 1.2 namespace. It takes Load Program, Program Activation Management, Memory Range Set Management and Execute Program. Two device-defined programs (copy and a 64-bit FNV-1a hash) and the CEMU shared-library and eBPF programs run on it. - The memory and compute namespaces of
csd_slm_sizeandcsd_cpwork in afemu-subsys, so FDP and these namespaces can run together. The controller must be alone in its subsystem, because Reachability Reporting on one controller needs it on all of them. - A Copy with descriptor format 4h moves memory namespace bytes to a block namespace. The CEMU commands stay on (guide).
- With those namespaces the controller reports Reachability Reporting: the Reachability Groups (1Ah) and Reachability Associations (1Bh) log pages, CRCAP and RGRPID (log pages).
- SGL data transfers (
sgl), now honoured on every I/O command that carries data (1fa43530d, d24705851). - DULBE and Write Zeroes with Deallocate report deallocated blocks (98247b96f).
- TRIM (Dataset Management deallocate) on bbssd (d749928e9).
- Verify command (e8c2c8933).
- Copy command, including copies between namespaces (descriptor format 2) (b16b3b3ae, 04b3da484).
- Device Self-test and its log (b3e5965d4).
- Sanitize block erase and the Sanitize Status log (4997dbdd9).
- Telemetry Host-Initiated and Controller-Initiated logs (d859ad4d6).
- Get LBA Status and the LBA Status Information log (bfc02d6a3).
- Timestamp feature (5323f363b).
- Persistent Event log, with format, sanitize, telemetry, error and Set Features events, optionally kept across runs in
pel_file(87ea8154c, 93dddf1d2, 276c93e23, 3a368e984). - Asynchronous Event Requests are accepted and events are reported (7d5d2f84f, b53ec7122).
- Supported Log Pages (log 00h) and the I/O Command Set Profile feature are answered (1b15f38df, 481eb6df2).
- SMART reports host data units and command counts, available spare (with an optional
nand_bad_blocksmodel), percentage used (from the cell type orpe_cycles_rated) and media errors (f07d117f1, a20d9ac94, a8a28d451, df8a3492a, e25ddf7be). - The Endurance Group log is filled in (074b63f4f).
- Media counters (write amplification, host and relocated pages, write buffer hits, read reclaims, retention refreshes) are reported in vendor log page C0h (e57448e41, 4cb1f9ba7, e9746f6bf, e7f182b87).
- Interrupt Coalescing (Feature 08h) now holds I/O completion interrupts until the threshold or the aggregation time is reached. Feature 09h Coalescing Disable, the admin queue and error completions are not held. The default settings leave it off.
- Opt-in I/O stage times (
io_stages): the QMP commandquery-femu-stagesreturns histograms of the submit, FTL, hold, post-delay and total time of each I/O command. post-delay shows how far completions land after the model's time. - A QMP command,
query-femu, reports the geometry, write counters, line counts and per-line state of bbssd namespaces to the host. The FTL thread copies the state between two requests (reference). query-femualso reports zoned namespaces: the zone geometry, the zone counts per state and, with kindzones, the state, write pointer and capacity of each zone. The main loop copies them under the zone lock, so a zoned namespace needs no enabled controller. Each namespace entry now carries only the members of its mode.query-femureports the NAND bus timing of each namespace in amediamember. It gives the page transfer and the command, status and burst phases after their fallbacks. It also gives the multi-plane gaps, the ONFI mode and the ordering rules. CSD, KV and OCSSD namespaces now report this member only (reference).query-femualso reports FDP namespaces: the reclaim group geometry, unit counts per state, and the host and media bytes of each reclaim unit handle. Kindreclaim-unitslists the state, handle, valid pages and wear of each unit. The handle byte counters sum to the FDP Statistics log.- Opt-in power loss model (
power_loss) that drops data still held in the volatile write buffer and records the event in SMART and the event log (46602b0e7, 303c77aef, 7679c443d). - TCG Opal groundwork (
x-opal=on, experimental, off by default): Security Send (81h) and Receive (82h), with OACS bit 0. It answers Level 0 discovery and the protocol list. ComID 1000h has its state machine, STACK_RESET and the Session Manager Properties method. Sessions reach the Admin SP: MSID, SID and PSID, Activate, Revert and transactions, with Block SID and TPER_RESET. - TCG Opal locking (
x-opal=on): the Locking SP has 8 ranges, keys, users, ACEs, MBR control, the MBR table and the DataStore. Read, Write, Write Zeroes, Write Uncorrectable, Compare, Verify, DSM and Copy check the locks and fail with Access Denied. GenKey and a range change erase the LBAs that change owner or key. The MBR shadow serves Reads until MBR Done. Format is refused on a write-locked LBA, and Sanitize while the Locking SP is active. See TCG Opal. - Format NVM accepts a cryptographic erase (SES 010b) when
x-opal=onorcrypto_mbpsis set; FNA bit 2 reports it. The data goes as with a user data erase. Withx-opal, every range also gets a new key, and so does a Sanitize Crypto Erase.
ZNS
- Write buffer and FTL for the ZNS SSD, and zone reset charged with erase time (0326ab489, b3272c013).
- Configurable zone resource limits (
zns_max_active,zns_max_open) and zone descriptor extension size (6404dd233). - Optional conventional zones (
zns_num_conv_zones) (6e7395b55). - Configurable zone width (
zns_chnls_per_zone) (e04e4e901). - A zone can span fewer LUNs (
zns_luns_per_zone), andzns_zone_order=lunfills a zone LUN first instead of channel first. The defaults keep the full-width, channel-first zone. - Zone Random Write Area support (
zns_zrwa_*) (b18f56b2b, 9f51854d7). - An injected write fault (
err_write_fail_ppm) takes the zone read only and lists it in the Changed Zone List (ccdae5d3b). - Changed Zone List log page (569608a41).
- Configurable reads across zone boundaries (
zns_cross_zone_read) and Zone Append size limit (zns_zasl_bs) (78caee058, bca834133). - ZNS takes NAND timing from the shared media layer, with configurable read, program and erase times and an opt-in channel bus (3d6056020, 34bbe45fa, 2a4ebc2cb).
- Configurable write cache count (
zns_num_wc) (66f432117). - Optional program/erase suspend for reads (
zns_pe_suspend,zns_tsusp_ns) (9ec423985). - Optional LUN contention (
zns_lun_contention): the planes of one LUN run their operations one at a time, and a zone reset erases each LUN's planes in one multi-plane operation. Off by default, so the timing does not change. - Optional zone reset by fill (
zns_reset_by_fill): a zone reset erases only the blocks that hold programmed pages, so its time and the SMART wear follow the zone's fill. Off by default, so a reset of a non-empty zone still erases every block. - Opt-in ZNS read timing by page type (
zns_page_types) and ECC read time by block wear (zns_ecc_step_ns). The page types keep the mean read latency of the flash type. - ZNS Reset Zone Recommended (
zns_rzr_sec,zns_rrl_sec, off by default). A zone Full forzns_rzr_secseconds of guest time gets RZR at the next check, and Identify reports RRL. With a nonzero RRL, the controller refreshes the zone itself at the first check once RZR has been set for RRL seconds. It clears RZR, and the zone ages again. RRL 0 means no refresh. Both changes enter the Changed Zone List; a host Reset clears RZR with no event.
BlackBox SSD (bbssd) and NAND media
- NAND operation timing moved into a shared media layer used by bbssd and ZNS (46cb582c9, 711d537bc).
- Pluggable GC victim selection (
gc_policy: greedy, random, cost-benefit, fifo, d-choice) (7222d6744). - Opt-in DRAM read cache (
read_cache_mb,cache_evict) (3b21542de, fc5d3ded0). - Pluggable L2P mapping (
mapping: page, dftl, hybrid, fast) with a modelled mapping cache (mapping_cache_mb) (64a19a6f3, 46e4261f9, 0f9b6aeab). - Write amplification accounting, and a
debug_ftlswitch that prints page-state violations found on the GC path (e57448e41). - Optional cell-type NAND timing (
nand_cell_type,cell_pages,pgtype_lat, ONFI phase times,ecc_step_ns) (e405dbcbc). - Optional modelled TRIM time (
trim_lat_ns) and explicit over-provisioning (op_pcent) (1027eb240, 6a4559ee4). - DRAM write buffer (
buffer_size,buffer_thres_pcent) with Flush, FUA and volatile write cache support (6a8daec7a, d4d03f127, 0ee6d211b). - Hot/cold separation of overwritten pages (
hot_cold_sep) (4ded2e928). - Log page C0h counts NAND pages that host writes cover only in part, whose read-modify-write the model does not charge (c80a23e88).
- Log page C0h counts plane reads, programs and erases and, with
energy_read_nj,energy_prog_njandenergy_erase_nj, their energy (1f5620a1e). - Firmware time per opcode (
fw_read_ns,fw_write_ns,fw_other_ns) and on several firmware cores (fw_cores) (8370f6f59). - Log page C0h counts host writes that waited for forced collection or a full write buffer, and completions held for a full completion queue (5631b3c07).
- Opt-in paced collection (
gc_pace): the victim line is copied a few pages per host page written instead of in one pass, so a write waits for about one copy instead of a whole line (ff5e4b5ce). - Opt-in copyback for line and FDP collection (
gc_copyback, off by default). A page moves on its die when the destination shares its channel, LUN and plane, so the move puts no data on the channel. Collection then takes victim pages in the order of the destination dies. A copyback skips ECC, so on a real SSD its bit errors are not corrected and can add up; FEMU models no bit errors, so only timing changes, and pages with extra ECC time and refresh moves stay off-chip for that reason. Log page C0h offset 248 counts the pages moved this way. - Opt-in ONFI 6.0 bus timing (
onfi_mode0 to 26, withonfi_mts,onfi_spare_bytesandonfi_tccs_ns) for bbssd, CSD and KV. The timing mode sets the page transfer, and the ONFI command, status and burst times set the other bus phases. Status comes before a read's data out and after a program, and a page register holds its LUN to the end of the op. The array times stay withpg_rd_lat,pg_wr_latandblk_er_lat. - With the ONFI profile, an op with an older start time can use an idle bus gap before the latest start time on its channel. The channel keeps about 1024 past bus windows for this. An op older than those starts no earlier than the end of the newest dropped window.
onfi_param_pageloads an ONFI 6.0 parameter page image. It turns the ONFI profile on and gives the mode, the spare bytes and the address cycles. Realize refuses a page with a bad CRC or one that does not match the device geometry and features.query-femureports the address cycles.onfi_sca=1selects the ONFI SCA protocol. Commands, addresses and status use a separate CA bus per channel, and the channel bus carries only the data bursts. A burst owns the channel bus from its SCE packet to the hold after its SCT packet.query-femureportsscaand the burst times.onfi_cache_read=1reads the pages of one read command that land on one LUN as an ONFI read cache sequence. It sends 31h for the next page of a block, 00h-addr-31h for any other page, and 3Fh after the last.trcbsy, which had no effect, now sets the busy time of each copy. The array reads the next page while the bus moves the current one.- With
onfi_cache_read, a LUN group reads as plain reads when a read cache sequence would end later on an idle LUN. Mode 26 with 4 KiB pages reads 8 pages in 332328 ns, not 345912 ns. The choice uses only timing fields, so it is the same for every run. - Opt-in program disturb terms for the ECC read time (
pd_edge_wls,pd_edge_tiers,pd_open_tiers,pd_open_age) in bbssd, CSD, FDP and KV. Reads of bottom wordlines and of part-programmed blocks pay extra tiers, and open data can age from its first program. The tier counts are chosen values for sensitivity studies. - Opt-in program disturb actions in bbssd, CSD and FDP:
pd_open_read_limitrewrites a line or reclaim unit whose part-programmed block takes too many reads, and takes it out of its write frontier first, andpd_open_close_secpads and closes one left open too long. Log page C0h counts both at offsets 256 to 279, and pad pages count in the write amplification. Under FDP the pad gives the handle a fresh unit and logs event 1h. - Opt-in thermal model (
thermal_tau_ms,thermal_r,idle_mw,thermal_step_ms): the SMART composite temperature follows the NAND energy and idle power through a first-order model, and crossing a threshold raises the SMART temperature warning and event (eda6b6ffe). - Opt-in static wear levelling (
wl_spread): the least worn full line moves into the most worn free line, without a write pointer of its own (2e1ef35ba). - Read reclaim (
read_reclaim_limit) and retention refresh (retention_limit_sec) (7f9b4f6af, 4e09c4797, e7f182b87). - Data age feeds the ECC read model (
ecc_retention_sec) (f9433e9ab, 13f2b85de). age_scaleages data faster than wall time for retention refresh and the ECC retention tier, so a retention study runs in minutes (9988153d3).- More than one plane per LUN (
pls_per_lun) in bbssd, FDP and KV, with a line's planes erased in one operation (0f554fb7d, 3699e980d, 9c8228d28, 7276af2d8). - Channel bus phases (
cmd_addr_lat,pg_xfer_lat,status_lat,ch_xfer_lat) are added to the timing when set (c274ba7d9). - A read can suspend an in-flight program or erase (
pe_suspend,tsusp_ns) (9ec423985, 6a5c498a8). - Opt-in multi-plane program and read (
mp_program,mp_read, withpls_per_lun > 1): host programs or reads of the same page on several planes of a LUN take one array time, plustplpbsyortplrbsybetween planes. Placement and page counts do not change. The defaults leave the timing unchanged, FDP is not affected, and a negative busy time is refused. - Opt-in
plane_firstmakes bbssd and CSD write pointers fill the planes of a LUN before the next channel. Withmp_program, pages in a row then form one multi-plane program. - Optional debug logging to study whether deleted data remains on the device (18ba6557c, 45e61ae41).
- Opt-in block erase limits (
blk_pe_limit,blk_pe_spread,blk_pe_seed): a block past its limit stays in service, is counted in log page C0h and sets SMART critical warning bit 2 (12f1c582c). The block's line leaves service while enough lines remain (af99ecb21).spare_linesholds lines back whose blocks replace worn-out ones, and SMART Available Spare follows what is left (ee6afccd4). Crossing into either warning raises a SMART asynchronous event when the host enabled it (c9b3d3ad8). SMART Percentage Used then counts against the blocks' limits, andquery-femureports retired and spare lines (b6af86af1). - With
blk_pe_limit, the neweol_read_only(on by default) keeps erased reserve lines for the writes in flight at the end of life. Each write takes credits for the NAND pages it may program before it changes data, and waits in its queue while the reserve is full.query-femureports the reserve lines and the credits. - With
eol_read_only, the media goes read-only when no block can replace a worn-out one, as on a real SSD. Writes, Write Zeroes, Write Uncorrectable, Copy and a deallocating Dataset Management fail with Attempted Write to Read Only Range (182h) and change nothing. Reads, Flush, Format NVM and Sanitize still run, and the writes in flight finish from the reserve. SMART shows critical warning bit 3 and Available Spare 0, the Endurance Group log bit 3, and Identify Namespace NSATTR bit 0. A SMART event with information 00h follows when the host enabled bit 3. Format NVM fails with Command Sequence Error while admitted writes wait for the FTL. - FDP takes
blk_pe_limitwitheol_read_only=off. A worn-out block retires its reclaim unit while the unit's group keeps the units the namespaces and placement need. Otherwise the block stays in service with SMART critical warning bit 2. SMART and the Endurance Group Information log report the warnings, Available Spare (the worst group) and Percentage Used, andquery-femushows retired units. FDP still refuseseol_read_only=on,spare_linesandfdp_trim_erase_allwith it. - FDP also takes
eol_read_only(on by default withblk_pe_limit). Each reclaim group holds erased units for the writes in flight, the media goes read-only when no unit can replace a worn-out one, and writes then fail with 182h. Collection, refresh and padding stop then, and RUH Update fails with Capacity Exceeded. - Opt-in pSLC tier in front of MLC, TLC or QLC NAND. The properties
tier_mode,tier_static_mb,tier_full_policy,tier_pslc_read_ns,tier_pslc_prog_ns,tier_pslc_erase_nsandtier_pslc_pe_cyclescontrol it. Host writes go to a static pool of pSLC lines first. A fold moves the oldest full pool line to the dense lines. The tier is off by default, and with it off nothing changes. See tiered NAND. tier_mode=dynamiclets the pSLC pool borrow free dense lines while the device has room, withtier_max_mbas a cap andtier_shrink_pctas the fill where the pool starts to shrink. A borrowed line goes back to the dense free list after its fold, and the dense lines always keep room for every valid page. See tiered NAND.tier_idle_mslets the pSLC tier fold pool lines in idle time, one bounded step at a time, so the next burst finds free pool lines.tier_lazy_pctfolds only while the pool use is above a percent. Both are off by default. See tiered NAND.- The pSLC tier now works with
buffer_size. A write-back places buffered pages in the pool. The idle write-back runs no fold; when the pool is full, the idle FTL thread folds one bounded step at a time until a pool line is free. See tiered NAND. - The pSLC tier now works with
mp_program. A fold first charges the multi-plane programs still held, so it never reads a page before its program. - The pSLC tier now works with
mapping=dftl. Translation pages stay on dense lines and do not count as host data in the pool's fill rules. Idle and upkeep folds write the translation pages they change, at most as many as there are LUNs a step. - The pSLC tier now works under FDP with
tier_mode=static: each reclaim group keeps pSLC reclaim units that persistently isolated handles write first, and a fold collects a full one into its handle's dense collection unit. See tiered NAND. events_fileruns ANA state changes and power cuts at fixed or seeded times after the first enable, andquery-femu-eventsreports each one. See timed actions.die_slow=onand the runtime propertydie-slowmake one LUN slow: its array time grows by a percent, so later ops on it wait.events_filecan do it at set times withslow=. See a slow die.ready_msandrecovery_msdelay CSTS.RDY after CC.EN, the longer time on the first start after a power cut. Admin commands sent before ready run at ready. See ready and recovery time.- The Arbitration Burst of feature 01h now limits how many commands a poller takes from one submission queue per sweep. The reset value of feature 01h is 0x1f0f0707 (AB 7, no limit), so the default path is as before.
wrr=onadds weighted round robin with an urgent class (CC.AMS 001b): the queue priority of Create I/O SQ and the weights of feature 01h choose which queue the poller serves next. It needs one poller.die_stats=oncounts, for each LUN, the array bookings, the ones that waited for a busy LUN, the wait and the array time;query-femukinddieslists them. See waits per die.- bbssd: a Write or Write Zeroes that fails with Capacity Exceeded no longer counts the pages it did not place as host pages, so the WAF denominator holds only pages the device took, as under FDP.
- With
rber_ppb, a codeword that no decode corrects now fails the read with Unrecovered Read Error at every Read Recovery Level, as on a drive;rber_timing_only=onkeeps the earlier rule, which charges the time only. - Enabling a SMART event in Asynchronous Event Configuration now sends it at once when its warning (spare, reliability or read-only) is already set (Base 2.3, 5.2.26.1.5).
- A failed die under
rain_paritysets SMART Critical Warning bit 2 (reliability degraded); a failure at run time also raises the SMART event. - With
rain_parity, SMART Available Spare falls with each failed die; below its threshold it sets Critical Warning bit 0. query-femureportsfailed-dies,rebuild-lines-leftandrebuild-pageswithrain_parity.rain_rebuild=onmoves the lines from before a die failure into lines without that die; dies can then fail one at a time underrain_parity.- With
rain_parity=1a die can fail (failed_die): lines opened after the failure leave the die out, and a read of the failed die reads the other dies of its stripe. rain_parity=1keeps one parity page in each stripe of a line, as RAIN on a datacenter drive: the parity page rotates over the dies and takes space, so the spare space drops and WAF counts one parity program per N - 1 data pages. See FTL.durable_at_done=on(withpower_loss) makes a written page durable when its NAND program ends, not when it is booked. A power cut restores the pages whose program had not ended, and Flush, a cache disable and shutdown wait for the last program. DSM, Write Zeroes with DEAC, Write Uncorrectable, Format and Sanitize work with it; Copy and Write Zeroes without DEAC work too, except on a namespace with metadata. At its bound a write waits for a program to end, it does not fail. See FTL.plp=on(withpower_loss) models power-loss protection: a cut keeps the write buffer, FUA and Flush complete without the media, andvwc=0keeps it on. A check at enable and every C6h minutes readsplp_health(C0h Capacitor Health). Below 1 the protection fails with Critical Warning bit 4 and a SMART event. Thenplp_fail_modeor OCP Feature C2h (DP-CFG-6 A) picks read-only, write-through or normal. See FTL.awupf_lbas=N(withpower_loss) makes a Write, Write Zeroes or Copy of at most N blocks that spans pages one transaction. A cut or a failed placement then finds it all old or all new, and AWUN and AWUPF report N - 1. See FTL.sdc=on(withpower_loss) injects media faults that leave wrong data: a flipped bit, a lost write or a misdirected write. Withe2e_check(on by default) a read of a spoiled block fails with 81h and counts in C0h Detected Errors. With it off, the read returns the wrong data. Not withawupf_lbas. See FTL.persist_ftlnow keeps the aging state, so an aged drive goes on after a clean restart. It takesblk_pe_limit,spare_lines,wl_spread,read_reclaim_limit,retention_limit_sec,ecc_retention_secandrber_ppb. The file keeps erase limits, used spares, retired and reserve lines, read-only media, the queued rewrite, levelling and the RBER generator. Data ages do not grow while QEMU is down. Files of the old format still load into a device without an aging model. See FTL.- Opt-in block death beyond the erase limit: an early-life cohort with low erase limits (
blk_early_ppm,blk_early_pe) and erase failures that kill a block (erase_fail_ppm). A dead block takes the spare, retirement and read-only paths of a worn-out one; statistics log byte 328 counts erase failures. See FTL. - A deallocate (Dataset Management, Write Zeroes with Deallocate) unmaps only the NAND pages it covers in full. A page that keeps some of its LBAs keeps its mapping, so their reads still cost a NAND read. FDP event 80h no longer counts the deallocated blocks of such a page. See FTL.
- A DSM range of 0 blocks at LBA 0 no longer hangs an FDP controller. The deallocate walked about 2^52 pages, because the range end wrapped below its start.
rain_read_only=on(withrain_parity): a die failure that leaves no spare or no room for GC is accepted, and the media goes read-only with its data readable, as a real drive does. Off by default; such a failure is refused then. See FTL.- Get and Set Features answer LBA Status Information Attributes (15h): LSIPI 1 s, LSIRI settable down to LSIPI. See NVMe frontend.
- Log 0Eh lists each attached namespace with tracked blocks and their runs, and LSGC steps only when the page lists a block the last host read did not. A RAE=1 read freezes the page until a RAE=0 read. It used to give only an estimate, also for detached namespaces. See NVMe frontend.
- The LBA Status Information alert (Notice 05h, AEC bit 13): after LSIRI, or at once for a component failure, with the page captured at the post. A read with RAE=0 clears it; a reset sends an unread one again. Get LBA Status no longer reports a run of 2^32 blocks when a write clears the run's first block during the scan. See NVMe frontend.
persist_filekeeps the LBA Status Information state (LSGC, the last alert and host read, a pending component failure) in a new section, version 3 flag 2. Files from older FEMU still load, with that state empty. A file saved now needs this FEMU.rain_paritynow works withblk_pe_limit. A failed die takes no erase (also without the wear model) and leaves the wear counts. Retirement keeps the lines the namespace needs at the line size after the last failure. Available Spare is the lower of the wear and RAIN spare, and with an end of life a spare of 0 sends the media read-only. See FTL design.rain_loss=on(withrain_read_only): a die failure is accepted while old lines hold data. Data pages in stripes with two failed members are lost: their blocks read Unrecovered Read Error until a write, Get LBA Status lists them (001b), a failed read adds a media error, and Notice 05h reports the component failure. query-femu reportslost-pagesandlost-blocks. See FTL design.- OCP event 0016h (NAND Die Offline) now works with
rain_parity: the die leaves reads only, and its pages read from the other members of their stripe. Set Features accepts the event while each live stripe keeps one lost member at most. See FTL. stage_ns=on(withio_stages) times the Read and the write commands of each namespace apart, for NSID 1 to 8.query-femu-stageswithnsidreturns them asreadandwrite. See query-femu.- When namespaces share one FTL (
shared_ftl, or FDP with several namespaces), query-femu reportsnamespace-countersfor each namespace: its host, NAND and GC pages and its WAF. A page counts for the namespace whose slice holds it. See namespaces. shared_ftl=onputs every bbssd namespace on the FTL and NAND array of namespace 1, each in its own slice of the logical pages. Writes and GC of one namespace then slow the I/O of another, as in a shared SSD. Format of one namespace drops only its slice. query-femu reportsshared-ftl-nsid. See namespaces.cancel=onadds Cancel (I/O 18h): it aborts commands of its own submission queue, one by CID or all of a namespace. A command past its FTL step completes with Command Abort Requested at once and counts in CMDA. A command before that step runs it, then completes with that status, and counts in CEDA. See features.sanitize_ns=on(withsanitize_ops) adds Sanitize Namespace (8Ch): a crypto erase of one namespace, while I/O to it fails with Sanitize Namespace In Progress and other namespaces keep working. Log 81h reports each namespace by NSID, with the Namespace Data Erased bit, and log 7Fh lists the namespaces in progress or erased. See features.- A command with a nonzero FUSE field (a fused operation) now fails with Invalid Field. FEMU reports no fused operation (FUSES 0); before, it ran each half alone, so the Write of a Compare and Write pair ran after a miscompare.
ns_wp=onadds Namespace Write Protection (feature 84h): a protected namespace refuses every command that would change it with Namespace Is Write Protected, and keeps the state across resets and power cuts. bbssd and NoSSD. See features.power_limit=on(withpower_states) adds Power Limit (TP4190, feature 23h): a host limit prohibits the power states above it, renumbers the rest in Identify, 02h and 0Ch, and moves the controller out of a prohibited state. Saveable; off withocp. See features.power_meas=onadds the Power Measurement capability (TP4199): log page 25h and feature 25h, with the power estimated fromidle_mwandenergy_*_njonce a second. See power measurement.maint_idle=on(withgc_idle_ms) runs the queued read reclaim and a bounded retention scan in idle time, so a read-only workload and unread data are refreshed too. See maintenance in idle time.- Shutdown follows NVMe more closely: an abrupt shutdown (CC.SHN 10b) also flushes the write buffer before SHST reads complete; clearing CC.SHN keeps SHST until a reset or the next enable; a system reset ends a shutdown; a failed KV flush sets CSTS.CFS; and a power cut after a completed shutdown counts no unsafe shutdown.
shutdown_msholds CSTS.SHST at 01b (in progress) for a set time after a shutdown, then reports it complete.gc_frontier=onwrites the pages garbage collection copies to lines of their own, apart from host writes, as real drives do; under a skewed overwrite this lowers the pages copied. Off by default; refused with FDP,cxl_ssd,gc_pace, Streams, andretention_limit_secwithoutpd_open_close_sec.nand_profile=FILEreads a versioned NAND profile: the base read, program and erase times and the bus phases of a chip, in one format for bbssd, CSD, KV and ZNS. ZNS programs a wordline, so it takes the page program time times the pages of a wordline.query-femureports the times the media uses and the profile. Two profiles inhw/femu/profiles/give today's defaults. Off by default.- Controller-initiated telemetry: a SMART warning that begins, the temperature condition starting, or autonomous thermal protection captures the FEMU statistics once into log 08h (TCDA 1, TCDGN up, a reason). The Telemetry Log Changed notice follows when AEC bit 10 is set, also when it is set later. A read without RAE hands the capture over. A reset keeps it; a QEMU restart does not. Off with
ocp=onuntil the OCP layout exists. - OCP Hardware Component log (C6h) with
ocp=on: the emulated components, serial number, hardware revision and born-on date, at UUID index 0 and 1. - I/O trace export: the
femu_cqetrace point carries the opcode, LBA and length of each completion, andfemu-trace2csv.pyturns a trace log into CSV. - Mapping lookup cost (
l2p_dram_ns, 0 by default): the controller DRAM time of each logical-to-physical lookup. A read starts its NAND read after it. femu-prom.py: a Prometheus exporter of thequery-femucounters of a running VM.- Indirection unit (
iu_pages, 0 by default): a write that covers part of a unit reads the unit's other mapped pages and programs them again. Small writes to a large-IU drive then cost NAND writes and read time, as on QLC drives. reference/combinations.md, generated bygen-combinations.pyfrom the refusal messages: for each property, the combinations realize refuses. CI checks that it follows the code.- With
ocp=on, the PCIe function has Function Level Reset, Advanced Error Reporting and the Device Serial Number capability. An FLR is a Controller Level Reset. - With
ocp=on, OCP features C3h, C6h, C8h and CAh answer Get and Set Features with current, default and saved values. FEMU stores the values; it models no PLP circuit or idle mode. gen-property-docs.py --schema FILEwrites a JSON Schema of the device properties from the binary, for tools that write device lines.dram_hit_ns(bbssd, CSD, 0 by default): the controller DRAM time of a page that the write buffer or the read cache answers, in place ofpg_rd_lat / 16.- CI runs QEMU's checkpatch on each new commit (
check-patches.sh);femu-compile.sh --werrorbuilds with--enable-werror. - I/O trace export (
io_trace=FILE, off by default): one CSV line per completed I/O command, with its submit and completion times, range and status, in every mode. mode=NAME(ocssd, bbssd, nossd, zns, csd, kv) sets the emulated SSD type by name;femu_modekeeps taking the number.- Read Recovery Levels (
rrl, off by default, withrber_ppb): Feature 12h sets level 4, 9 or 15 (Fast Fail), which bound the retry and soft decode of host reads; a read the level leaves uncorrected fails. persist_ftl(off by default):persist_filealso keeps the bbssd FTL state of a page-mapped drive (mapping, page and block state, lines, write pointer, counters), so a restarted drive continues aged. A load checks every record first; other FTL properties fail realize.- OCP Event Injection (Feature C0h,
ocp=on): event 0016h takes dieinject_dieoffline at runtime. With die parity, reads of the die take its stripe, and log C0h counts them as XOR recoveries; without it, they fail with Unrecovered Read Error. - Inline encryption engine (
crypto_mbps, off by default): the data every command reads or programs passes one engine of that throughput, which caps the bandwidth of a self-encrypting drive. - Host Memory Buffer (
hmb_mb,hmb_ns, off by default): a DRAM-less bbssd with mapping=dftl asks the host for an HMB. While the host has it enabled, the mapping table lives there and a lookup costs one PCIe round trip instead of translation page reads. - QMP
femu-save-datawrites a checkpoint of a running bbssd or NoSSD device in thepersist_fileformat; a later run starts from it. - Data persistence (
persist_file, unset by default): bbssd and NoSSD keep their data in a host file across QEMU runs. Realize loads it; unplug or the end of QEMU saves it. The FTL state is not kept. - Telemetry Data Area 4 (
telemetry_da4, off by default): with ETDAS set by the host, a telemetry capture adds one counter block per namespace. Log 07h also takes the Maximum Created Data Area field. - Die parity (
die_parity,parity_xor_ns,failed_die, all off by default): each full stripe of one page per die books a parity program on a rotating die, which costs die time and counts in WAF. A read of a failed die reads the rest of its stripe in parallel. - Two-pass program (
prog_pass2_ns,prog_pass2_lag, both 0 by default): the program time is the coarse pass, and a fine pass of each wordline runs on the die once later wordlines are programmed. Until then a read of that wordline comes from the controller buffer, as on QLC drives. - Read priority (
read_prio, 0 by default): a read goes ahead of the programs and erases queued on its die. It waits only for the one that runs, and the queued ones slide by its array time. - Suspend limits (
pe_suspend_max,tresume_ns, both 0 by default): a program or erase allows that many suspensions, then reads wait for it; each resume addstresume_nsto it. - Background write-back (
buffer_low_pcent, 0 by default): an idle FTL thread writes buffered pages back, one per die once all dies are free, until the buffer is at the low watermark. Writes then find room, and reads meet the die time the write-back used. - QEMU trace points for FEMU (
hw/femu/trace-events): I/O and admin commands, completions with their modelled time, events, garbage collection victims, block erases, sanitize and power states. Turn them on with-trace femu_*or QMPtrace-event-set-state; off, each costs one branch. query-femukindblocks: the erase count, P/E limit and overworn state of every flash block of a BlackBox namespace, paged withoffsetandlimit.- PCI power management (
pci_pm=on, off by default): a PM capability with D0 and D3hot. Outside D0 the BARs are off; back in D0 the controller keeps its state (No_Soft_Reset). - 64-bit guard protection information (
pif=2withpi=on, default 0): 16-byte tuples with a CRC64 guard and 48-bit reference tags. CTRATT.ELBAS is set and CNS 05h reports the extended LBA formats, so Linux reads the 64-bit tuples. Copy is refused on those namespaces. - Sanitize in the background (
sanitize_ms, 0 by default keeps today's behaviour): the operation runs for that long, I/O and most admin commands fail with Sanitize In Progress meanwhile, and its end sends Sanitize Operation Completed.sanitize_ops=onadds Crypto Erase and Overwrite, with the data each leaves under No-Deallocate. - ANA reporting (
ana=on, off by default): one ANA group per namespace, log 0Ch, CMIC bit 3 and the ANA Change notice. The runtime propertyana-statesets a group's state through one controller, so a multipath guest sees a path become inaccessible (I/O status 302h) or lost (301h). - Power states (
power_states=on, off by default, bbssd and CSD): four power states, where PS1 and PS2 cap power by stretching NAND array time and PS3 is non-operational. An I/O command wakes PS3 with its 5 ms exit latency. Autonomous Power State Transition (feature 0Ch) moves an idle controller to PS3. - Reservations (
reservations=on, off by default): Reservation Register, Report, Acquire and Release on every command set but Open-Channel, the access rules of Base 2.3 Figure 703, features 81h, 82h and 83h, and log 80h with its event. A host with Host Identifier 0 is one controller until its next reset. A simulated power loss keeps the state only with PTPL set; a QEMU restart clears it. - Command and Feature Lockdown (
lockdown=on, off by default): the Lockdown command (24h), log 14h and OACS bit 10. The host can prohibit admin commands other than queue, Identify, log, Get Features, Abort, AER and Lockdown, and any changeable Feature Identifier. The admin queue then refuses them with status 23h. A reset keeps the state; a QEMU restart clears it. - The Telemetry Controller-Initiated log (08h) reports its scope in byte 381, as Base 2.3 Figure 220 asks; byte 380 is reserved there. It put the scope in byte 380, the host log layout.
plane_reads=on(bbssd and CSD, plain channel model) lets reads on different planes of one die overlap; a program or erase still waits for every read on its die and holds the whole die. Off by default; the timing with it off is unchanged.throttle=on(bbssd and CSD, with the thermal model) slows NAND array time when the device is hot. The host sets the light and heavy levels with feature 10h (HCTM); SMART bytes 216 to 231 count them. Autonomous protection (hot_k, or 77 C and 75 C withocp=on) runs apart from HCTM; withocp=onit raises and clears the temperature warning, and C0h bytes 96 and 97 report it.- With
ocp=on, log C4h (Device Capabilities) reports what FEMU supports, and feature C7h selects a DSSD power state; it and Power Management (02h) are saveable, and CAP.CPS reports NVM subsystem scope.ps_max_watts(default 25) sets the Maximum Power of power state 0, the only one; FEMU does not cap its modelled power at it. - Write Zeroes with Deallocate clears the Write Uncorrectable mark of its blocks, so they read back zeros (OCP 2.7 NVMe-IO-6).
fw_slots(default 1, or 3 withocp=on) adds Firmware Image Download and Firmware Commit. Slot 1 is read only. FEMU checks a small image format (header, revision, security version, CRC-32) and refuses an image below the security version floor. Activation works now, without a reset, or at the next Controller Level Reset; a Persistent Event log entry records each Commit. Sanitize waits until a pending activation runs. Images stay in memory only.- With
ocp=on, the Persistent Event log holds 5 MiB (PELS 80), as OCP 2.7 STD-LOG-22 asks; otherwise it stays 64 KiB. - With
ocp=on, the OCP 2.7 latency monitor runs: feature C5h configures it and log C3h reports it. Read, Write and Deallocate commands that take longer than threshold A count in four buckets, with the measured latency and a stamp per bucket and command. The active set moves to a static set at each timer interval. The debug log and persistence across QEMU restarts are not there yet. - With
ocp=on, NUSE counts the blocks that hold data: a write allocates a block and a deallocate frees it. C0h Total NUSE is the same sum. ocp_profileholds the OCP 2.7 device profile: A or B for each of DP-CFG-1 to DP-CFG-13. The default, BAABABAAAABAB, picks the settings FEMU meets. B for DP-CFG-7 turns on Write Uncorrectable. FEMU refuses A for DP-CFG-1, 4, 6, 11 and 13. Withocp=on,lba_indexmust be 0: the factory sector size is LBA format 0.- With
ocp=on, Get and Set Features take a UUID index, and OCP feature C9h (DSSD Asynchronous Event Configuration) answers: error reporting AENs on by default, not saveable. Enabling Media Ready AENs reports the DSSD Media Ready event once per Controller Level Reset, as a One-Shot event. FEMU has no error event to report, and C1h says so. - With
ocp=on, the values OCP 2.7 fixes win over the base NVMe choices: CAP.CSS has only the NVM command set, NSFEAT.DAE and LPA bit 0 are clear, WCTEMP is 77 C and CCTEMP 85 C, DULBE and SMART per namespace are refused, and the Timestamp survives a controller reset. CSD memory and program namespaces refuseocp. ocp=onreports the OCP 2.7 SMART / Health Extended log (C0h) and the Error Recovery log (C1h) of a bbssd or CSD controller. The UUID List (CNS 17h) names the OCP UUID at index 1 and a FEMU UUID at index 2. C0h at UUID index 0 or 1 is the OCP page, and the FEMU counters move to index 2. Off by default.femu-subsys,rotational=onreports endurance group 1 as rotational media. Its namespaces set NSFEAT bit 4 in CNS 08h and 1Fh, log 09h sets EGRMEDIA, and log 16h and Spinup Control (Feature 1Ah, fixed off) answer. Linux then marks the disk rotational. Timing does not change. Off by default.query-femu-stagesaddsbands: per bucket of total time, the count, total sum and past-due sum.femu-stat.pyshows the past-due share of the p50 to p99.9 bands, so a tail that is past due is told apart from a slow model.perf_hintsreports the optimal write and deallocate granularity of a bbssd namespace as one flash page, and NOWS as one stripe. A guest then aligns writes and discards to them. Off by default; refused with FDP andns_mgmt.atomic_write_lbasreports a namespace atomic write unit (NSFEAT bit 1, NAWUN and NABSN). The range locks already cover each whole command; the power-fail unit stays one block. Off by default. See data copies and write atomicity.rber_ppbadds a read-retry and soft decode model to host reads. Each ECC codeword draws a decode outcome from a raw bit error rate that grows with wear, data age and read disturb. Each failed attempt costs one more page read on the LUN. Off by default; log page C0h counts the outcomes. See read retry and soft decode.- With the host link model on, a write to bbssd, FDP, CSD or NoSSD with no write buffer now books its link transfer before its media, as on a real drive. Before, the transfer came after the programs.
pcie_write_first=offkeeps the old order. Reads are not changed. See host link and firmware CPU. femu-config-check.py --manifest FILEwrites an experiment manifest. It holds the configuration report, the host, and the QEMU build and source commit. Each femu property gets its value and source: given, default or derived. See record an experiment manifest.gc_idle_mslets the device collect lines in idle time, one victim at a time, so the next burst finds free lines.gc_idle_pcentsets how many lines idle time frees. Off by default; the first version takes one bbssd namespace with page mapping. See idle collection.
Timing and fault models
- Fault insertion (
err_read_unc_ppm,err_write_fail_ppm), a host link model (pcie_bandwidth_mbps,pcie_prop_delay_ns) and a controller CPU model (fw_cpu_ns), now also applied to NoSSD (7bfac4c3a, 2cdd55c52).
Open-Channel SSD
- Opt-in OC 1.2 channel transfer timing (
oc12_channel_timing) (d174f9551, 5cf3996c0). - Opt-in OC 2.0 page type timing (
oc20_page_types): reads and programs take the time of their page type, as on OC 1.2, instead of the lower page time. - OC 2.0 gets media timings, chunk resets are charged as erases, an unwritten block reads as the predefined pattern, and a host can reset a chunk it has not filled (b652c3d87, 9d176f891, 00daad11c, 90ff859c1).
NoSSD
- Poller threads decoupled from queues (
poller_ratio), and I/O counters kept per poller (0b192893b, 6b1592746). - The backend memory can be bound to or interleaved across NUMA nodes with
FEMU_MBE_INTERLEAVE(3594d27c6). - Under FDP a NoSSD namespace counts its writes: HBMW, MBMW and the RUAMW of its reclaim units, per handle and per endurance group. It logs event 03h for an invalid placement identifier. Write Zeroes with Deallocate and Write Uncorrectable count in HBMW only. A unit fills by the blocks written, and RUH Update logs event 00h only for a part-written unit. A logical block larger than
fdp.runsis refused. - ZNS Finish Zone Recommended and Zone Active Excursions (
zns_fzr_sec,zns_frl_sec, off by default). A zone written but not finished gets FZR afterzns_fzr_secseconds of guest time. FRL seconds later the controller finishes it and sets ZFC. Both changes enter the Changed Zone List.
Configuration changes and new refusals
A command line that ran before may stop at realize, with a message naming the property. Each of these was accepted before and then ignored, or failed a check without saying so. Nothing here changes a configuration that was already being honoured. If one of these stops a run, remove the property: it was not doing anything.
Refused at realize (previously accepted and ignored)
| Property | Why it is refused | Commits |
|---|---|---|
| any violated controller constraint | The check ran but returned silently, leaving QEMU up with no FEMU PCI device and no namespaces. The reason is now reported. | 9716c0a9f |
mpsmax below mpsmin or above 15 | The test used to be inverted, so mpsmax=1 was rejected and mpsmin=1,mpsmax=0 accepted, advertising CAP.MPSMIN above CAP.MPSMAX. | 9716c0a9f |
meta with dpc or dps, with nlbaf above 8, or without a matching mc | Metadata is implemented for NoSSD and bbssd (separate buffer or interleaved with the data), but not together with the legacy protection settings; use pi for protection information. Before metadata was implemented, any non-zero meta was refused. | d589ce2b8, 62d149dd5, ba36f0f68, bb2f3fb06 |
cell_pages above 5 | Indexed past the page-type multiplier table. | d589ce2b8 |
nand_cell_type with pgs_per_blk above 512 | Read past the page-type latency tables. | d589ce2b8 |
gc_strategy outside {0,1,2,4} | Other values silently fell back to greedy or never collected at all. | d589ce2b8 |
gc_policy other than greedy with femu_mode=5 | KV reclaims by taking the emptiest line off the shared victim queue; another policy reorders that queue (fifo by a close order KV never records), so KV took a line that was not the emptiest. | |
zns_flash_type 0, 6 or above, or MLC/PLC without explicit latencies | 0 gives a zero-length write cache and an endless flush loop; 6+ indexes past the timing tables; MLC and PLC have no built-in figures, so every NAND operation cost nothing. | b234d27c8 |
femu_mode above 5 | No mode registers command handlers for it (6 was a SmartSSD placeholder), so the controller came up with none. | c3b8e88ef |
multipoller_enabled other than 0 or 1 | Values above 1 started several pollers that each swept every queue, so two pollers could run and complete the same command. | de5fcd972 |
lver other than 1 or 2 with femu_mode=0 | No Open-Channel handlers were registered for it. | 498afdd7a |
flash_type outside 1 to 4 with femu_mode=0 | OCSSD 2.0 indexed the SLC to PLC timing tables with it unchecked, so 6 or above read past them; 0 and 5 have no built-in figures. OCSSD 1.2 already refused them. | 4891d870e |
zns_num_plane above 8, zns_num_ch above 128, or a page count above 65536 | Wrapped and aliased onto lower indices in the PPA. | b234d27c8 |
zns_chnls_per_zone that does not divide zns_num_ch | Was silently replaced by the full channel width. | b234d27c8 |
bbssd knobs under FDP: buffer_size, hot_cold_sep, read_reclaim_limit, retention_limit_sec, ecc_retention_sec, trim_lat_ns, non-default mapping or gc_policy | FDP keeps its own write and reclaim path; none of these reach it. | d589ce2b8 |
Other new refusals
- Invalid bbssd and zoned geometries, and a bbssd namespace with no room left for garbage collection; CSD and KV, and every mode a controller serves, now run the same checks (b4bbd93e0, 1ac931d86, ceb2b5bf7, 5ccbe3f24, bf8961b9b, 0b82aa58a).
- Invalid ZRWA configurations, page sizes ZNS cannot serve, and more write caches than zones (b89cde46d, 154775e62, fcfa0d581).
- Unknown
mappingorgc_policynames, and a negative suspend overhead (29c397f38, 2ae58aa55). - A CSD controller with more than one namespace (b425007c2).
- FDP with more than one reclaim group, and other placement configurations the device cannot serve (f08762450, 8ed17a495).
- ZNS and OCSSD namespaces in an FDP subsystem, and the memory and compute namespaces of CSD. An FDP endurance group holds NVM command set namespaces only (Base 2.3, 8.1.10). They were accepted, and placement had no effect.
fdp.nrgabove 128, andfdp.nruhabove 16366, whose configuration descriptor would not fit the 16-bit size field of log 20h.- An FDP namespace larger than what is left once each handle has a reclaim unit open, each Persistently Isolated handle one to collect into, and forced GC its free units. Such a namespace was accepted and then failed most random writes. A partly exposed last page now counts as a whole one in this check, with or without placement (89f34939f).
- Open-Channel namespaces on a controller in another mode, and OCSSD geometries the timing model cannot index (8cd92eec5, 598498e93, f4e85634a, 707d8c8c1).
- Controller memory buffer settings that do not fit, including any CMB BAR other than 2 (1c3a5a2a2, 9d6e13cd3).
- Queue entry sizes other than 64 and 16 bytes (23b21cc38).
- A format with protection information but no metadata room for it (1c9808bcd).
- On
femu-cxl-ssd, a direct ratio without DER, andder=memslotunder TCG (34b9f8f9e, d03b0606e, f1182b72e). - On
femu-cxl-ssdwith the FTL on, NAND with less than 7% of the media as spare beyond the forced collection reserve and two working lines. The old rule counted the reserve as spare. At the old 96 GiB preset (1644 blocks per plane), collection had 1.6% to work in. A request could then wait minutes for queued line copies. The refusal names the new least value (1732 at 96 GiB, 867 at 48 GiB). - A
dpcproperty with bit 3 set is refused, except on OCSSD. NVM 1.1 does not allow protection information in the first bytes of metadata.
Accepted with a warning (still no effect)
serial,ms,ms_max,dlfeat, and the CSDnr_thread,time_sliceandcontext_switch_timeare still accepted, but nothing reads them, so a value other than the default now prints one warning at realize naming the property; formsit points tometa(03da6e9d2).tplpbsyandtplrbsywere on this list; they now set the multi-plane program and read busy times, and warn only when set withoutmp_programormp_read.trcbsywas on it too; it now sets tRCBSY and warns only withoutonfi_cache_read.
Behaviour changes (still boots, numbers move)
- Small KV values share NAND pages, as real KV-SSDs pack them (
kv_pack=on, the default). A Store goes to an open page in controller DRAM and costs the DRAM time. The Store that does not fit, or that fills the page, programs it and waits for it. Flush with a volatile write cache, clearing WCE and shutdown program the open page (Base 2.3, 5.2.26.1.4 and 7.2). A packed Retrieve reads one page, GC moves values one by one, and log C0h counts host pages from value bytes.kv_pack=offgives the old model, one value or more per page (KV value packing). - With
kv_pack=on, the key limit (MNK) of a KV namespace is the number of 1-byte values its usable flash holds, at most 4194303. Small values are no longer held to two keys for each 4 KiB of value space. The index takes up to about 341 MiB of host DRAM, only as keys use it. New propertykv_max_keyssets the limit (KV mode). - A device with
blk_pe_limitkeeps reserve lines out of service, so it needs one or more lines more. It also refusesmdts=0, reports WZSL equal to MDTS with ONCS bit 3 (NVMWZSV) clear, and limits MCL so a Copy writes no more than MDTS.eol_read_only=offgives the old model. - With
blk_pe_limit, the Persistent Event log records the spare, reliability and read-only warnings when the FTL sees them start. The event carries the warning byte of that moment. Before, the log recorded them only when the host next read the SMART log. - With
blk_pe_limit, the media goes read-only at the end of life by default. A worn-out block with no replacement no longer stays in service with critical warning bit 2. With spare lines, a line no longer retires while the media stays writable. The worn line retires only as the media goes read-only.eol_read_only=offgives the old behaviour. - A device with
blk_pe_limitkeeps reserve lines out of service, so it needs one or more lines more. It also refusesmdts=0and reports WZSL equal to MDTS with ONCS bit 3 (NVMWZSV) clear. MCL keeps a Copy within MDTS, or within one block of the largest LBA format when that is larger.eol_read_only=offgives the old model. - KV value GC collects one victim line at a time when the free lines fall to the GC threshold, with both key indexes. It replaces the old compaction, which rewrote every live value when the value arena filled: emulator memory set that trigger, not the NAND. The arena now packs its bytes with no NAND time. A Store leaves free a reserve for GC, so a full device returns Capacity Exceeded sooner.
FEMU_KV_CHECKchecks the owner of every page. - With
kv_index=lsm, meta pages are real NAND pages in lines of their own. Merges program them and value GC moves them. The health log and log C0h count them, so the WAF includes the index. An old value stays valid on flash until a merge drops its record or value GC finds it stale (PinK, section 4.5). Commands pay only the flash the tree reads, with no hash base read. Thus a memtable hit takes no NAND time. - With
kv_index=lsm, a Store keeps room for a merge of every record. When it finds no room, the device merges every level down, so Deletes give back their space.query-femuaddsgc-meta-pages,gc-stale-value-pages,valid-value-pagesandversions. - Compare, Write Zeroes, Verify and Copy are on by default: the
oncsdefault is now 0x19d instead of 0x14. A guest that sees Write Zeroes in ONCS can send it, and on bbssd the FTL programs the range unless Deallocate is set.oncs=0x14gives the old set. Write Uncorrectable still needs bit 0x2. - Compare and Verify take the NAND read time of a Read on bbssd, CSD and ZNS namespaces, also after a miscompare. Before, both completed with no media read.
- A Copy on bbssd issues its destination write when its source reads end. On one LUN, a one-page Copy took the read time twice: 600 ms instead of 500 ms with a 100 ms read and a 400 ms program.
- A zone write cache holds one program unit for each die of its zone. A cache sized from the whole device made a narrow zone (
zns_chnls_per_zonebelowzns_num_ch) program each of its dies several times in series per flush. Full-width zones keep their timing. - A zoned namespace counts the block erases of Zone Reset. SMART Percentage Used (and the Endurance Group log) now reports them against
pe_cycles_rated, or the rating ofzns_flash_type; it used to stay 0. Each block passes its erase count to the media layer. - Log 20h reports MAXPIDS as MIN(128, NRG x NRUH) - 1, below NRG x NRUH as Base 2.3 Figure 287 asks. It was 127 for every configuration; four handles in one group now report 3, and RUH Update still takes that many identifiers.
- A RUH Update of a handle whose reclaim unit is empty keeps the unit and logs no event 00h. It used to log one, which says that the handle moved.
- The FDP Statistics log keeps 128-bit sums, which stop at the 128-bit maximum, instead of 64-bit ones.
- FDP HBMW also counts Write Zeroes with the Deallocate bit and Write Uncorrectable (NVM Command Set 1.2, 4.1.4.6). MBMW does not, since no page is programmed.
- The default placement handle list of an FDP namespace holds the first 128 handles when
fdp.nruhis larger: a list holds at most 128 (NVM Command Set 1.2, Figure 125). - A CSD namespace now goes through its FTL, so reads and writes take NAND time instead of completing instantly. A pure-CSD device previously timed out on its first I/O and the kernel disabled the controller (50b65ca91).
- A namespace whose mode differs from the controller's is routed by its own mode. A bbssd namespace on a NoSSD controller no longer completes inline (50b65ca91).
pcie_bandwidth_mbps,pcie_prop_delay_nsandfw_cpu_nsnow apply to NoSSD. Setting any of them takes the request off the inline completion path, which costs throughput; leaving them unset keeps the previous path (2cdd55c52).cmd_addr_lat,pg_xfer_lat,status_latandch_xfer_latnow add channel bus time on bbssd. The bundled run scripts pass 0 and are unaffected (c274ba7d9).zns_cmd_addr_lat,zns_pg_xfer_latandzns_status_latadd the same channel bus to ZNS. They default to 0, which leaves ZNS timing exactly as it was; a negative value is refused at realize (2a4ebc2cb).- Temperature threshold Set Features accepts only TMPSEL 0 and Fh; other selectors are rejected rather than stored as part of the value (c7eaa6b4a).
- An aborted command completes as Command Abort Requested rather than Invalid Opcode (03a4eee3c).
- FDP RUAMW counts down in LBAs, so it drains at the documented rate and reaches zero; cost-benefit victim selection now orders by age and utilisation rather than insertion (9a66fe52d).
- The CEMU admin commands of CSD mode moved to vendor specific opcodes: 0x21 to 0xc9, 0x22 to 0xc5, 0x23 to 0xc8 and 0x25 to 0xcd. NVMe Base 2.3 gives 0x21, 0x22 and 0x25 to fabrics commands and reserves 0x23, and 0x22 declared the wrong data direction. The old opcodes now fail with Invalid Command Opcode;
csd_legacy_opcodes=onrestores them for old tools. - The data plane starts when the host enables the controller rather than on Doorbell Buffer Config, so hosts that never send that command (SPDK, FreeBSD, Windows, older Linux) now work (04f04b86e).
- Failure to lock the backend memory is a warning instead of a fatal error (847864637).
- The media counters moved from the SMART log's temperature fields to vendor log page C0h (4cb1f9ba7).
- The register BAR is at least 16 KiB (01c79c442).
- Under FDP, forced GC keeps at least one reclaim unit free unless
gc_thres_pcent_highis 100. Below 20 units the watermark rounded to none, and a pass that filled its destination part way had no unit to go on with (89f34939f). - With
hot_cold_sep, Streams, or ahybridorfastmapping, forced GC keeps at least one line free. Below 20 lines, where the watermark used to round to zero, such a namespace can expose one line less (5a81d02cd). - OC 1.2 Identify no longer advertises hybrid commands, and unsupported OC 1.2 block opcodes are rejected (f5fc7d573, 6b5081821).
mapping=dftlwithout FDP keeps its translation pages on flash, in lines of their own. Collection moves them, and dirty evictions and the changes that collection and deallocate make program them. FDP keeps the timing-only model.- Log page C0h (bytes 280 and 288) and
query-femucount the translation page programs and reads ofmapping=dftl, and the write amplification factor includes the programs. Realize keeps lines for these pages, so the largest namespace a geometry exposes is smaller than before.x-ftl-checkadds the translation page checks. - With
mapping=dftland no FDP, a read starts its media read when its translation is ready. So a CMT miss adds the translation read to the page read; before, the two overlapped. Withhot_cold_sepa write also waits for its translation. - With
mapping=dftland no FDP, DSM Deallocate and Write Zeroes with Deallocate write the translation pages they change once each, and charge that to the command. Write Zeroes without Deallocate pays the translation of each page, as a write does. Format and Sanitize drop the translation pages with no write-back. - With
mapping=dftlandeol_read_only, read-only media opens no new translation page line, so the reserve lines stay for the writes in flight. - ZNS: a zone Finish, by the host or by the controller (
zns_frl_sec), programs the pages the zone's write cache still holds. A host Finish completes after these programs. - The
run-*.shlaunchers name QEMU's threads (-name ...,debug-threads=on), sops -Tandtop -Hshowfemu-poller,FEMU-FTL-ThreadandCPU N/KVM(e29fe6ee2).
The shared namespace model behind femu-subsys,ns_mgmt=on is described in
namespace management.
- Identify CNS 06h, DPC with
pi=onand the Error Information entries return other bytes on a default command line; the lines under Spec conformance give each change.
Fixes
Crashes, memory safety and teardown
- A
der=cylonguest that onlines the CXL memory in a normal zone, which guest memory auto-online does by default, no longer ends with "KVM internal error. Suberror: 3". Its page tables, stacks and descriptor tables land on cold pages, and version 2 used to hand a page that could not keep a cache way to KVM's emulator; the MMIO entry this leaves cannot pass an interrupt delivery. Version 2 now maps such a page outside the cache and emulates only data accesses to pages the caching API keeps uncached; a guest page walk or an event delivery maps even those. A marked page gets its leaf back to zero whenCACHE_ENABLEor an unpin makes it admissible again. A vCPU keeps up to 64 pages outside the cache for one instruction (was 16), and an instruction that needs more stops the VM aftercylon-fault-stopcycles instead of looping. New countersder-fault-forced,der-fault-deliveriesandder-fault-marker-refused;der-fault-conflictsnow leads toder-fault-overflowsinstead ofder-fault-emulated. Version 1 keeps every cold page as an MMIO entry, so it needs the CXL memory online as movable; FEMU warns once when the VM runs without version 2. The host kernel side, which exits withKVM_CYLON_FAULT_DELIVERYinstead of ending the VM, is Cylon kernel candidate 3 (e3c51d264). - Fixed a memory leak and build errors from the previous release (b11ce9631, 1c2d358c1).
- Fixed ZNS plane allocation and the DSM buffer size (f863d7a8e, 805b9c8e6).
- Fixed a submission queue setup race and a poller use-after-free on controller reset or guest reboot (7100e6179, ac89117b2).
- Fixed priority queue heap repair, which affected FDP victim selection (e2d5413ff, 66067fabc, a4ed1d8c9).
- I/O past the device geometry is refused instead of accessing out of bounds (8848d724d).
- Widened bbssd and ZNS physical address fields so large channel, LUN and plane counts no longer alias (2e4c7fe82, d7c5aff58).
- Fixed an out-of-bounds write in ZNS zone reset with a narrow zone width, and ZNS backend addressing within a namespace (02a11cc51, 316ecf9df, cba095fb5).
- Fixed OCSSD writes past the backing store and many OCSSD bounds checks on vector lists, chunk info, bad block tables, offsets and addresses (fca17a8c6, f2ccb06ab, e8d415a07, 11aafda03, b37e7dd58, ff6e8bb4b, 58ba9f515, 98641558d, d44f0c4c1, 761f78757, 42ae8360e, 1f135b961, d5a5b788b, 91412b74d, 3838cf6bf, 1c9f737fe, 0d6d5926f).
- The FTL thread and pollers are stopped and every mode's state released on device removal, controller reset and failed realize (da76e206a, 06c7579b2, 81fa5697a, b3608d3f4, d0998ea16, 5a4107c14, 6610ecba1, f050a8bce, 3ba1ddec4, 42ba3cf4a, 817d34363, 36d1ef4b0, 52a579830, 8e8dc4431, 8c1fb192f, 0b7c53826, 9b0dd6eb0).
- Fixed leaks of aborted requests, DSM range lists, PRP lists and dropped command lists (03a4eee3c, f3fdbe7c0, 1c498adad, 10aaf11e2, c501af95e).
- A host address is no longer written into guest memory when setting up a non-contiguous queue, and Identify transfers the structure rather than a whole memory page (037d9c9c2, 14f4224d3).
- Queues with 64 KiB pages no longer crash QEMU, and queues are mapped by their length in bytes (cbebe5e10, 49880d0a0).
- Shadow doorbell values are bounds-checked as ring positions and the buffers are one page each (e082da2c1, b95d305b5, 33584d6b8).
- Controller DMA from device threads is restricted to directly reachable memory, which avoids a VM hang on data pointers into device registers (fbfe674c2, 60e4b2d5d).
- Report and log buffers are bounded and their lengths checked before transfer (608749b8d, 40656e5a1, 062bcdb02, 0ddcc33bd, 3106c1205).
- CSD program loads are bounded and confined to
csd_program_dir(f1d5f3736). - A CSD controller with no CSD namespace (
femu_mode=4,namespace_modes=nossd) no longer crashes QEMU on a CEMU admin command with valid fields. It has no program tables, so it now refuses the commands with Invalid Command Opcode and log 05h does not list them. - CSD programs run on
nr_cucompute unit threads (femu-csd-cu) instead of the poller, so a long program no longer stalls I/O on every queue or the vCPU that sends a CSD admin command; a loaded program can no longer be reloaded in place while it runs, and deleting a queue or resetting the controller under a running program drops its result safely (4596ba498). - Running out of lines refuses the write instead of aborting, and FDP reports device full instead of asserting or following a null reclaim unit (49ada8834, e1c4e9174, 59128ab66, e7913d89c, c0ae29cb4, cbda78bf6, 37b9b84f9, f05f128a9).
- Zone state is locked, reset zones are erased on the media thread, and asynchronous events are raised from the main loop (fe8e931e3, 5001ae15c, 89e1c4b04).
- FDP event rings are serialized and the written and uncorrectable bitmaps are updated atomically across pollers (645424c86, daaa6a3db).
- The BlackBox flip command applies to every namespace of the controller (3b7d88d63).
femu-cxl-ssdno longer advertises that unmapped pages read as zeros (3c85bfd86).- Switching
femu-cxl-ssdfast-loadoff no longer sleeps out the NAND backlog on the QEMU main loop. After a fast fill the backlog can be minutes, and the guest's boot disk, served by the main loop, timed out and the guest lost its root file system. The switch now returns at once and the backlog stays on the NAND timelines; the newnand-idle-nstells a harness when the NAND is idle. The switch does not wait for the FTL mutex either, which the worker can hold for a whole forced collection. Device DMA work queued before the switch books its NAND time before any later access, linked NVMe requests included, andfast-load-drain-nsincludes it once it is booked. - A QEMU NVMe read into
femu-cxl-ssdmemory no longer stops the QEMU main loop for the media time of the CXL pages it fills. The block layer completes such a read on the main loop, outside any re-entrancy guard, so the copy took the waiting path and slept up to the whole NAND backlog. Accesses from the main-loop thread now queue their media time as guarded device DMA does; an IOThread's copies, and those of other threads such as RCU's, which also hold the BQL, keep the full model. - An Open-Channel SSD no longer runs or advertises Dataset Management, Write Zeroes, Compare, Verify, Copy or Write Uncorrectable. Their common handlers used the sparse Open-Channel address as a flat LBA. The default
oncsallowed Dataset Management, and a deallocate of a high address zeroed memory past the backing store and stopped QEMU. Flush is still accepted. - Many
femu-cxl-ssdlifecycle, decoder and mapping fixes, including teardown while callers wait on invalidation, little-endian forwarding, and keeping stores when NAND has no page for write-back (9e0223c19, bb7e28722, 51c420143, d31c48d92, ec8b1ac7d, 02a872661, 4505cd9a7, 86ba15078, 842d4ff72, b322efb8f, 2d0c1404e). - Device threads copy guest memory through the translation they checked. A guest that mapped a ROM over a buffer between the check and the copy could make a poller wait for the BQL while a pause held it.
- A ZNS zone report is built under the zone lock and sent after the lock is released, to directly reachable memory only. A report into ROM used to hang the VM when a Changed Zone List read waited for that lock.
Data correctness
io_trace,io_stagesand the OCP latency monitor now share one completion time, taken right after the CQE write. Before, each read the clock later, so one could count the bookkeeping of another.hmb_mb: when the host turns the Host Memory Buffer off, or a reset does, the translation pages changed while it was on are written again. Before, their flash copies stayed stale with no record of the change.- Write buffer: a page leaves the buffer only after it finds a place on the media. Before, a failed placement dropped the page. An FUA write or a Write Zeroes whose page finds no place now fails with Capacity Exceeded.
- Write buffer: a Flush now waits for the programs of the idle write-back, and it fails when a page finds no line. Disabling the volatile write cache writes back the buffer first.
- A CXL memory device (
cxl-type3andfemu-cxl-ssd) disables its media while a Sanitize command runs, as the CXL specification says. The media check read the first mailbox register instead of the memory device status, so media was never disabled; it now reads the status atomically, sofemu-cxl-ssdfault exits without the BQL read it without a data race. - With more than one poller, a read no longer sees a write, a Copy destination or a Write Zeroes range half done. Each NVMe access to the memory backend now holds the locks of the 4 KiB granules it touches, so a write is atomic as AWUN 0 promises. CXL.mem accesses of a
femu-cxl-ssdmedium do not take these locks. - Compare reads the stored data instead of a zeroed buffer (7589ee012).
- FDP TRIM honours the requested LBA ranges instead of erasing the whole device (0cc20e897).
- Fixed FDP victim accounting, foreground GC under write pressure, the initial reclaim unit, and the FDP Events log offset (cee9670a5, 247151a16, f9fc94d4f, 438e485a1).
- bbssd maps blocks by their real size, so 4 KiB formats no longer share logical pages (bb63df5a3).
- Fixed ZNS zone append, Zone Append bounds, zone open on write, zone resource counts, multi-zone reset, and zone write caches keyed by zone (07acf491a, 27949b51f, 3fd4f34e6, 8129cfd16, 340522142, 99ce4fb2b, 9a3449362, 347a8a691).
- A ZNS zone whose write cache is evicted before it fills now continues its next flush on the first free plane, not on plane 0. With more zones written at once than write caches, plane 0's block ran past its last page and reads of those blocks finished faster than tR (8bcaa0623).
- A ZNS write refused for its data pointer no longer moves the write pointer (6343c4d22).
- FDP Write Zeroes is placed by its own directive fields and counted in HBMW and MBMW, instead of reusing the placement of an earlier command (834abe2cb).
- Under FDP, the Directive commands report the Data Placement Directive, and the host can enable it per namespace. The enabled state survives a controller reset.
- Write Zeroes and deallocate address the backend per namespace, program the media where required, and drop buffered copies (f44ce6499, 9005cf952, 373de039b, 783131b7d, 22988e07b).
- The write buffer no longer resurrects deallocated pages and is bounded (d4d03f127, 0ee6d211b).
- A Format rebuilds per-block state (a79474e73, 7e7e36161).
- Writes clear the invalid status set by Write Uncorrectable (026eb0ef0).
- A KV Retrieve or List that returns less than the host buffer holds follows the PRP layout of the whole buffer. A transfer of 4 to 8 KiB into a larger buffer took PRP2, a list pointer, as a data pointer, and wrote the data over the host's PRP list.
- CSD and KV commands address the namespace they name, and each namespace gets its own mode state (a93de9d54, aa6a5a8f7, d2a770601, ce5ad913f).
- A KV command completes when its last NAND operation does: a Store that compacts no longer counts the compaction wait twice, and still pays for it when it then fails. The per-command index read is charged on a LUN chosen by the key's hash instead of always on the LUN at address 0, which had every KV command queue on one LUN (4ca11c2a0, 1e5385ae4).
- Vendor admin command 0xEE sets an Open-Channel controller's read, program, erase and channel times; it used to write fields nothing read. Other modes refuse it with Invalid Field (949d01eb9, cdbd5bb36).
namespace_sizesmay add up to all ofdevsz_mbwhen the namespace count does not divide it, and each size is rounded down to whole logical blocks, so TNVMCAP counts only addressable capacity (d8cdd4d22).- A CSD controller in an FDP subsystem refuses the same knobs as a BlackBox one and reports the superblock as its reclaim unit size, instead of 96 MiB (207bb12d4).
- bbssd GC no longer erases a line it could not empty, which left mappings pointing at erased pages and made every later write fail. Forced GC runs before every page a command programs, so a large write on a device with fewer than 20 lines no longer runs it out of space (5a81d02cd).
- FDP GC moves all of a reclaim unit's pages before erasing any block, retires each moved page's old copy, and runs foreground GC per page. A pass that stopped part way used to leave the unit with erased blocks counted again later (c7b373186).
- FDP GC takes a new unit for a collection destination that was dropped when it filled with nothing free, and collects a unit with no valid pages without one. GC used to stop for good once the destination was gone, so a full device stayed full even after the host deallocated everything (22a0fc5ee).
- An FDP handle whose last unit filled with nothing free reports no room in RUH Status. It used to report the room of its retired unit, which GC could free and give to another handle (4e7a06666).
- FDP RUAMW counts every page programmed into a reclaim unit, also the pages that collection or a refresh moves into the active unit of an Initially Isolated handle. That unit used to report the room of the moved pages as free. A Format keeps the programmed pages, so RUAMW no longer returns to a full unit after it.
- RUH Update on a CSD namespace moves the handle to a fresh reclaim unit, as on a BlackBox one. It used to reset only the RUAMW, while the FTL went on writing into the old unit.
- The
randomandd-choiceGC policies and FDP's random reclaim strategy draw victims from a generator seeded by the newgc_seedproperty instead of the wall clock andrand(), so the same configuration and workload give the same victims and WAF on every run.fifofinds its victim at the top of a queue ordered by close order instead of scanning every line, with the same victims as before (04ba1c0aa). - FDP background GC counts the pages a unit never wrote as reclaimable. A unit that RUH Update retired holding a few valid pages had none invalid, so each background pass took it from the top of the victim queue, refused it and stopped; units behind it were collected only under the foreground watermark (beb9878ac).
- FDP cost-benefit GC ages a unit retired with no page invalidated from its retirement. It used to count from time zero, so a part-written unit left by RUH Update outscored every other victim; with few pages to free, background GC refused it on every pass and collected nothing. (a9e0e1af6)
- FDP RUH Update runs foreground collection first, as a write does, while the reclaim group is at or below its forced watermark. It used to take the last free units, so collection had no unit to move pages into, and a write that fit the namespace failed with Capacity Exceeded.
- FDP RUH Update gives a handle with no reclaim unit an empty one, or fails with Capacity Exceeded when collection frees none. A handle is left with no unit when its last unit fills with nothing free. The update used to succeed and leave the handle with no unit (Base 2.3, 7.4.1.1).
- FDP cost-benefit GC measures a unit's utilization against all its pages at every invalidation, as it already did at retirement. The first overwrite in a part-written unit used to measure it against the pages written only, so a unit holding 3 valid pages of 16 scored as 3 of 4 full and lost to units that cost more to collect. (529d70960)
- FDP background cost-benefit GC takes the best-scoring unit with enough to free. A unit with one invalid page and an old invalidation could outscore every other victim; the pass refused it and collected nothing until the others aged past it or the foreground watermark was reached (fe29da90b).
- A ZNS Zone Management Send waits for the writes to its zones that the controller already accepted. A Reset in the gap between a write's acceptance and its data copy left an Empty zone with a moved write pointer and the old data.
Spec conformance and host compatibility
- With a
femu-subsys, SMART byte 6 (Endurance Group Critical Warning Summary) repeats bits 0, 2 and 3 of the endurance group's warning. It read 0. - A KV namespace runs its I/O commands only when the host enables the controller with CC.CSS 110b. Under 000b, which selects only the NVM command set, they fail with Invalid Command Opcode (Base 2.3, Figure 41). Linux selects 110b. Set Features I/O Command Set Profile (19h) now succeeds with no effect when CC.CSS is not 110b (Base 2.3, 5.2.26.1.17).
- Write Zeroes reads its directive type from CDW12 bits 22:20 (NVM Command Set 1.2, Figure 82). Bit 23 is NSZ: with it set, a Write Zeroes failed with Invalid Field once the Data Placement Directive was enabled, or lost its placement.
- FDP event 03h sets LV, with the reclaim group and handle that the controller selected for the write (Base 2.3, Figure 296).
- The placement handle of a placement identifier is bits 15 - RGIF to 0 (Base 2.3, Figure 290). FEMU read one bit less, which did not matter with one group. RGIF is now the fewest bits that hold
fdp.nrg- 1. - A Copy descriptor format 2 range that names the command's own namespace is accepted in every mode that accepts Copy. A CSD namespace refused it with Invalid Namespace, although the controller advertised format 2.
- Identify CNS 19h (Endurance Group List) lists endurance group 1 on a controller in a subsystem, from a starting identifier of 0 or 1, as
nvme list-endgrpasks. Without a subsystem it is refused. - Commands complete on the completion queue they were bound to, and submission queues that share a completion queue are served (7a3f1d9fa, dc4289f91).
- Completions are not posted into a full queue and the phase tag is written last (6f998742f, 04ce8b1a7).
- I/O interrupts are delivered without a KVM route, and pin interrupts work with shadow doorbells (8ebffbaa4, 34621540e, 4ca1be945).
- Create SQ/CQ reject out-of-range queue IDs and invalid interrupt vectors, and return the specified statuses (b3bbaedb0, 7580dd341, edefcd7c5).
- Fixed controller configuration and admin queue registers, feature reset on controller reset, and the fatal status cleared on disable (330ed2aab, f2ea41361, ab63717c5).
- Get Log Page reads its identifier and offset correctly and serves every log from the requested offset (a6b0d5897, ef8b755ee, 23fc538ea).
- Feature identifier, selector and save bit are decoded, and namespace-scoped features take a namespace (2380e4ecc, 1729244c2).
- Temperature Threshold: Get Features refuses the reserved THSEL values and "all sensors", Set Features refuses the reserved THSEL values, the over threshold starts at the warning temperature (343 K) as Identify reports, and the under threshold sets SMART critical warning bit 1 and raises the temperature event (7ff2172cc).
- Identify reports total NVM capacity and the fields a host relies on (907ad6ff1, 8530bc287).
- Fixed the error and SMART logs, the log directories, Format secure erase decoding, data pointer and transfer size statuses, and bad doorbell reporting (325e02cfd, c52d9ff9c, adfc12e93, bdb6f6b59, 225c6bdee).
- Fixed the AER count, Zone Append limit, KV MDTS and vector masking (7b5dbbc77).
- A failed data transfer is reported as an error, PRP lists starting inside a page are followed, and SGL errors use their own status codes (29175cb05, ecbef8416, c9344bd4c, e310fdb43).
- The Changed Zone List reports only unsolicited changes, ZNS follows the zone resource, compare and notice rules, and commands that rewrite a zone behind its back are refused (7a6f01f8a, 41a6c189f, 99d2194e0, ed38b0728).
- A reset zone holds no data, an offline zone returns its resources, and zone geometry is reported for the namespace's format (bce5e1c3e, 2c7062ed0, 901d0908f, b4d9585ca, f0f989c21).
- KV list entries are padded to 4 bytes, NVM-only commands are refused on KV namespaces, and KV Identify requires a KV namespace (240e21c43, f5a7d7bc8, 5ec9ee859).
- FDP reports the reclaim unit size the FTL uses and moves a handle to a new reclaim unit on update (7fe32c556, 78de60448).
- FDP reports reclaim moves with the controller events of the specification. A collection or refresh of Initially Isolated data logs 80h with the blocks moved, and 81h when the moves give that handle a new unit. Moves of Persistently Isolated data log nothing; collection used to log 81h for every unit.
- The FDP Reclaim Unit Handle Usage log uses 8 byte descriptors, so
nvme fdp usagereports every handle as host specified instead of reading some as unused, and the placement logs store their fields little endian (1bc8508a6, 31bd13259). - With
namespace_modes, the controller's model number and serial come from its ownfemu_modeinstead of the namespace brought up last (efdb98643, c3f968029). - SMART wear counters are summed across namespaces (4a4f0d9bf).
- Counters fixed to move in every mode: FDP and KV write amplification and bytes, KV relocations, FDP erases (f4b3ac376, 980fb7886, 37464e4bd, ce20d8c06, 4c7d9c22a, 749e09fef, 2a16553c9, ba0c49338).
- OC 1.2 enforces its bad block table: a write or erase that names a factory bad, grown bad or device reserved block fails with Write Fault. Set Bad Block Table marks the plane it is given instead of another block's plane, and keeps the table's counts current (933addb72).
- Abort no longer rewrites the aborted command in the host's submission queue: the controller marks it and completes it with Command Abort Requested when fetched. An Abort run with more than
aclothers queued behind it fails with Abort Command Limit Exceeded (7b7eaf133). - Logs 12h (Feature Identifiers Supported and Effects) and 13h (NVMe-MI Commands Supported and Effects) are answered and listed in log 00h. A feature that needs something absent, such as Volatile Write Cache without
vwc=1, is an invalid field for every selector (7b36b4c25). - Enabling with a CC.CSS value that CAP.CSS does not offer fails the controller, and admin commands that name SGLs are refused (992dc9911, 2ff5e3925).
- Every Unrecovered Read Error and Compare Failure sets Do Not Retry (f8efff85a).
- Identify reports one read-only firmware slot, matching the firmware log (989df3cea).
- OACS, ONCS, OCFS, LPA, SANICAP and logs 00h and 05h are built from one capability registry, and a qtest checks them against what every mode answers (a1c67d97f, 933fb3f15).
- Log 05h lists each mode's own commands (BBSSD 0xEF, the Open-Channel and CSD commands, Flush on KV namespaces) and no longer lists Read and Write for Open-Channel 1.2, which refuses them (99eabe2c1).
- Log 00h lists the Open-Channel 2.0 chunk information page (CAh) (209b499b6).
- Get Log Page answers a page log 00h lists for no command set with Invalid Log Page, so the endurance group and FDP pages without a subsystem no longer answer Invalid Field (87d5f1372).
- A zoned namespace reports no Copy limits in Identify Namespace, since it refuses Copy (92b3763a3).
- Vendor admin command 0xEE outside Open-Channel mode answers Invalid Command Opcode instead of Invalid Field, since log 05h does not list it there.
- A subsystem with FDP off has no FDP capability, as CTRATT.FDPS already said. The FDP pages 20h to 23h answer Invalid Log Page and Features 1Dh and 1Eh answer Invalid Field; some used to answer FDP Disabled. Where log 05h does not list I/O Management Send and Receive, they answer Invalid Command Opcode instead of their no-operation.
- Log 00h and the pages of one command set follow CC.CSS: with CC.CSS 000b they serve the NVM set whatever CDW14.CSI names. The Changed Zone List (BFh) answers only for the zoned set. Open-Channel 2.0 Chunk Information (CAh) answers only for NVM. Another set gets Invalid Log Page. BFh with an unknown CSI answers I/O Command Set Not Supported.
- An Open-Channel 2.0 Vector Chunk Reset handles every entry of its LBA list. An entry that fails no longer stops the entries after it. Dword 0 and 1 of the completion mark the failed entries, and the metadata buffer gets a chunk descriptor for each entry. Each chunk that is reset is charged one erase, also when another entry fails.
- The controller reports NVMe 2.1 instead of 1.4, with what that requires: CAP.CRMS and the CRTO register, BPCAP 01b, Identify CNS 1Fh, CNS 00h refused for a Key Value namespace (Invalid I/O Command Set), CSI-specific log pages refused for an unknown command set, and CNS 07h refused for a set CC.CSS does not enable. Open-Channel stays at 1.4 (409db7bb3).
- CAP.AMS no longer claims weighted round robin, which nothing arbitrated by, and enabling with another CC.AMS fails (409db7bb3).
- A controller in a subsystem reports its endurance group (CTRATT bit 4, ENDGIDMAX, each namespace's ENDGID, the Key Value Identify structure included) whether or not FDP is on, as log 09h already did (409db7bb3).
- The spare critical warning in the SMART and Endurance Group logs is set when the available spare falls below the threshold, not when it equals it (4faaff90a).
- A memory backend that the host cannot allocate now refuses the device with a message that names its size. Before, QEMU aborted in the allocator.
- An asynchronous event identical to one already queued (type, information, log page, namespace) is not queued again. Copies used to fill the 16-entry queue and push out other namespaces' events.
- Reading one zoned namespace's Changed Zone List no longer unmasks Notice events while another namespace's reported notice is unread. That read used to send the other namespace's queued notice before its log was read (Base 2.3, 5.2.2).
- A Changed Zone List read without RAE clears the list and its event only after a successful transfer, as SMART and Error Information already did. A failed transfer used to lose the changes. A zone that changes during the read keeps its entry.
- An asynchronous event about a namespace no longer counts against the 16 queued controller events. With more than 16 zoned namespaces, a Zone Descriptor Changed notice used to be dropped and never raised again.
- Identify CNS 06h reports the version of each command set (TP4135): NVM 1.1 in bytes 23:20 and ZNS 1.2 in bytes 35:32. Both read 0. KV stays 1.3, SLM and CP stay 1.2, and an Open-Channel controller is unchanged.
- The NVM Identify CNS 06h sets AOCS bit 0, as Get LBA Status serves action type 02h. It read 0.
- With
pi=on, DPC is 17h instead of 1Fh: protection information sits in the last 8 bytes of metadata only (NVM 1.1, Figure 114). Format and Namespace Management refuse PIL with a protection type, and DPS never reports PIL. - Error Information entries name the command (TP4113a): byte 30 holds its command set and byte 31 its opcode. Every returned entry has Log Page Version 1h in byte 63. Open-Channel entries are unchanged.
- Identify CNS 0Ah for key value ignores the NSID and reports only format capabilities: NSZE and the key limit read 0. Indexes other than 0 fail with Invalid Field.
- With Namespace Management, Identify CNS 09h and CNS 0Ah answer for the NVM Command Set (TP4095a). Without it they stay refused.
Documentation and tooling
femu-steady-state.pyreports when per-round fio results reach steady state, by the SNIA PTS rule, so a WAF or GC study can skip the fresh-device rounds.femu-stat.pyprints the end-of-life state of a namespace witheol_read_only: read-only or writable, and the reserve pages that admitted writes hold.- Documentation moved under
hw/femu/docs/with getting-started, concepts, mode and feature guides, an FAQ, security notes and a doc map (e00c70f99, 034670c4c, 62a565ae0, fb1cf3ce6, 28aa224b7, 0bcb5cae2). - CXL SSD, caching API and NVMe link guides, and a reference for every
femu-cxl-ssdproperty and counter (41b318ef2, 9ec16a701, 93bfbf5c9, ccaa5d190, dcea2b9a8). - A property reference generated from the binary and checked in CI, with every device property described in its help text (a6118d051, 9489cf692, 37aaccf27, c2a12a2eb).
- The mode table is generated from
modes.py, and every documented command line is tested (6a97f8755, 12361d7f7, 573da0a1b). - Refusals and behaviour changes that affect existing command lines are listed (9e93cb94f); that list is now part of this changelog.
- The
vwcdescription no longer claimsvwc=0makes Flush a no-op: Flush drains the bbssd write buffer either way (f48a6bc6f). - Documentation of the SMART vendor area, vendor log page, endurance rating, mapping schemes, GC and cache options (4e1f5bce5, 77fa23981, 9f52a098d, 658e4c9e6).
- README refreshed: build hosts for the QEMU 10.1 base, binary path, guest image steps, namespace and plane limits, debugging switches, and links to the new docs (4f327242c, a967b15fa, 4dbeea46d, b5c68a96f, f2d9dee99, b2ae45483, 65332b21a, 10f30e231).
- Added CONTRIBUTING, CODE_OF_CONDUCT, SECURITY, CITATION.cff and ROADMAP files (599a36676, da692f5d9).
ssd-config.shexpands an INI-style config file into the device arguments, checking keys against the binary (7f605016e).femu-test.shchecks a device from inside the guest for block, zoned, KV and CSD namespaces (9fee8190c, 2244a1b9c, c17a31ea9).guest-conformance.shboots a guest for each conformance suite and runs blktests (theblockandzbdgroups) or the nvme-cli end-to-end suite against FEMU. The guest scriptsblktests-guest.shandnvme-cli-e2e-guest.shalso run on their own inside a guest. CI does not run them.guest-conformance.shruns azenfs-crashsuite:zenfs-crash-guest.shbuilds RocksDB with ZenFS in the guest and runs a crash test on a ZNS namespace. The new--device,--smpand--memoptions serve control runs and larger guests.kv-bench.cdrives a KV namespace with the NVMe-KV commands and checks each answer against a model of the keys. Thekv-benchsuite ofguest-conformance.shruns it andkv-probein a guest.femu-config-check.pystarts QEMU under qtest with no guest and reports either the refusal or the configuration FEMU builds: capacity, geometry, over-provisioning, line, reclaim unit and zone sizes, mode and NAND timing per namespace, and warnings. The documentation example check runs its documented commands.femu-stat.pyshows the FTL counters of a running VM from the host, liketop: pages, WAF since start and over the interval, line, reclaim unit and zone counts, and I/O stage times, from QMPquery-femuandquery-femu-stages.make-guest-image.shbuilds an Ubuntu 24.04 guest image, and the run scripts acceptIMGDIR,OSIMGFand another SSH port (e877f2dc0, e74535012, 66bb3068e).- The build script fails on a compile error, and the config self-test fails when FEMU does not survive (a1bf37caf, da7c1fcfe).
- The config self-test requires each device to come up, not only its property names to be accepted. That caught
zns.conf, which asked for more active zones than it has and was refused at every size (b509a23a5). - Config presets for OCSSD, CSD, KV and NoSSD (NoSSD with link and firmware time from the NVMeCHA controller), and a
run-kvssd.shlauncher (04eb9b06d). - A key-value probe tool and a corrected KV wire format description (9ab75f5dc).
pin.shno longer names a CPU past the last one, and now pins the pollers, the FTL thread and the CXL SSD'sfemu-cxl-ftlandfemu-cxl-ccathreads as well as the vCPUs (e29fe6ee2, 56e0e2f27).- Every launcher, the legacy scripts and
make-guest-image.shname QEMU's threads withdebug-threads=on(e29fe6ee2, 56e0e2f27). - The documentation example check realizes the guest's disks and NICs too, with stand-in backends, so a device the machine cannot plug (a NIC without
bus=pcie.0on acxl=onmachine) fails the check (ac5a152fe). kv-probe.ccomments describe what it checks and which device nodes it can use (dfc1bd606).- GitHub Actions CI on several Ubuntu releases, with pinned actions, a read-only token, sanitizer builds, link checks and steps that can actually fail (3b4708763, daf890b7f, c613ae5ac, 4164e551b, 8d4762608, 89ff3ed38, e3700422c).
- qtests and unit tests for FEMU now live under
hw/femu/tests/, including a NAND media unit test run by meson and FTL checks turned on in CI (d72e30a34, 6549d6094, cc926e1e9, 8241ccc7f). - Seeded fuzzers for admin, I/O, zoned, FDP, KV, Open-Channel 2.0 and CSD commands, run on sanitizer builds in CI (8a57a3e27, 6d6d927d0, 9798a6574, dff3d9f72, 28eaf2afa, 2dbb18a82, 243fc0b66, 2f1208402, 692d9a106).