--- /dev/null
+# Dropping stripe_meta: four claims checked (2026-10-22)
+
+Series: `misc-next/topics/stripe-alloc` = `bcadbfc8ac020` (114 patches on
+`0c48d26d46bdd`; export numbers below are `NNNN-*.patch` in this directory).
+This is read-only analysis: no new tests were run. Sources: memory notes,
+`~/share/raid56-wh-harness/forensics/`, `TESTING.md`, git, and the list.
+
+| # | Claim | Verdict |
+|---|---|---|
+| 1 | raid56 metadata is not faster than raid1, in theory or in practice | **Holds in practice; partly holds in theory.** No measured speed win beyond about 12-18% on cold stat. fsync is 5-8% slower, with 1.4-2x the device bytes per fsync. Theory allows a narrow win for bulk full-stripe writes and for spreading reads over the devices. It does not allow one for fsync, small commits or degraded reads. |
+| 2 | The space saving is smaller than the raid5/raid1 efficiency difference, because trapped blocks fill much of the metadata space | **Partly holds, and holds where it matters.** On a fresh filesystem at moderate fill, trapping is 16-23% and raid5 still uses about half of raid1's raw space. On churned, near-full or fsync-heavy filesystems, trapping is 49-88%, or the fsync log runs inflate the allocation. In those cases the saving disappears or reverses. |
+| 3 | Complexity is high; risk of metadata stalls/deadlocks is high | **Holds.** 14 patches are exclusively stripe_meta. Of the 13 metadata fix patches, 9 fix ENOSPC/abort or stall/deadlock bugs. Another 8 shared patches were found through metadata. At least 5 more defects were folded away before the series took its shape, and one ENOSPC abort class is still open. |
+| 4 | Complex, collides with Johannes Thumshirn's recent zoned-ENOSPC work, same issues | **Partly holds.** The problems are the same: free-but-unusable metadata space, metadata reservations against it, reclaim/relocation self-deadlock, aborts on reservation failure during reclaim, and metadata writeback ordering against commit. But there is no code collision. All of his work is merged (v7.1-rc1 .. v7.3-rc4) and already in our base. Only one function, `btree_writepages()`, is touched by both. |
+
+---
+
+## Claim 1: speed
+
+### Theory
+
+Let n = number of devices. Strips are 64 KiB, nodes are 16 KiB.
+
+* **Writes, bulk.**
+ * raid1 writes 2 device bytes per metadata byte.
+ * raid5 with full stripes writes n/(n-1): 1.33 at 4 devices, 1.25 at 5.
+ * Under stripe_meta every write is a full stripe, so this is the best case. But each open run pads its last stripe at commit.
+ * A commit of B bytes therefore writes `ceil(B/S)*S*n/(n-1)` device bytes, where S = (n-1)*64 KiB.
+ * raid5 writes fewer device bytes only once a commit fills several stripes. At 4 devices a 1 MiB commit is 1.5 MiB on raid5 against 2 MiB on raid1. A 64 KiB commit is 256 KiB against 128 KiB.
+ * Aggregate full-stripe bandwidth is (n-1) devices for raid5 against n/2 for raid1. This is the only clear theoretical write advantage, and metadata commits are rarely large enough to use it.
+* **Writes, fsync.**
+ * With patch 81, each log commit gets its own whole stripes. A log commit of 1-3 blocks (16-48 KiB) writes one full stripe: 256 KiB of device writes at 4 devices. raid1 writes 32-96 KiB for the same commit, so raid5 writes 2.7-8x more.
+ * Without patch 81 there is no padding, but every later log commit in the transaction does an RMW over the earlier commits' fsync-durable blocks. That is both a cost (reads) and a write hole (`log-epoch-fsync-hole`).
+* **Latency.** A full-stripe write completes when the slowest of n members completes. A raid1 write completes when the slower of 2 completes. Tail latency therefore grows with n.
+* **Reads, healthy.** A tree block sits in one strip on one device under both profiles.
+ * raid1 has 2 candidate devices, and the read policies can pick between them.
+ * raid5 has exactly one device, but it spreads consecutive blocks over n-1 devices. That can help a cold sequential walk.
+* **Reads, degraded.** For blocks on the missing member:
+ * raid1 reads the other copy: 1 IO.
+ * raid5 reconstructs from the n-1 other members (raid6: up to n-2) and computes parity, for every such block.
+* **stripe_meta's own overhead.**
+ * Writeback is deferred to the commit (`btrfs_defer_stripe_meta_write()`), so dirty metadata accumulates and is written in bursts.
+ * The commit waits for the metadata runs to drain after the tree writes (`btrfs_retire_meta_stripes()`).
+ * The rbio cache holds pins for open runs: up to 256 (`rbio-pin-cap`), and an fsync workload hits the limit within seconds.
+
+**Conclusion.** In theory raid56 metadata can be faster only for large commits that fill stripes, and possibly for cold multi-device reads. It is slower in theory for fsync (per log commit, at every n), for small commits, and for every degraded read. The claim "not faster in theory" is too strong, but the cases where raid56 metadata could win are narrow.
+
+### Practice
+
+**`forensics/meta-profile-bench-20261003/`** (README.md, summary.md):
+
+* Setup: lean kernels on both lanes (bhive 6.18 #268, dhive misc-next #27), raid5 data with stripe_alloc, 4 x 8 GiB loop members, 4 reps per arm, alternating order.
+* The table shows raid5 metadata relative to raid1.
+
+| phase | bhive | dhive |
+|---|---|---|
+| small-file create, time / device writes | 1.05x / 0.88x | 1.00x / 0.94x |
+| create+fsync, files/s | 0.93x | 0.92x |
+| fsync p50 / p99 | 1.08x / 1.11x | 1.09x / 1.06x |
+| fio 4K randwrite+fsync, IOPS | 0.95x | 0.94x |
+| cold stat, time | 0.88x | 0.82x |
+| rm -rf + sync, time | 1.11x | 1.11x |
+
+* raid5 metadata did about 1 metadata RMW per fsync: 2856 per 3000 fsyncs, and 235 MiB of member reads in 45 s of fio. raid1 did none.
+* **This bench predates patch 81 (per-log-commit runs, authored 10-04).**
+
+**`forensics/fsync-mode-bench-20261004/`** is the only raid1-vs-raid5-metadata comparison with patch 81 present:
+
+* Setup: 5 x 8 GiB members, raid5 data. `bench-280-3arm-reclaim10.log` and `mtailfix2-284/bench.log`, shipping "seal" arm, 7 workloads, 2 reps each.
+* Device bytes per fsync, raid5 relative to raid1: geomean **1.36x**, range 0.95-1.98x. Single writer is 1.98x (one padded stripe per fsync); 64 writers are about 1.0x. These figures include data writes.
+* fsync/s, raid5 relative to raid1: geomean 0.81 (#280) and 0.95 (#284), per-row range 0.11-2.06x. The README calls the rig noisy and drifting between reps. There is no consistent win.
+* 0 metadata RMW reads in every row.
+
+**Caveats.**
+
+* Every member was a loop file on the rig's one /mnt/wh backing store. That flattens exactly the multi-device parallelism that is raid5's theoretical advantage.
+* No degraded-mode or raid6 timing was taken.
+
+**Test that would settle it:** run meta-profile-bench.sh and fsync-mode-bench.py on 4 or more physical devices with a patch-81 kernel, and add a degraded cold-read arm.
+
+---
+
+## Claim 2: space
+
+**Breakeven.**
+
+* Let u = used/allocated metadata. For live metadata L:
+ * raid1 uses `2L/u1` of raw space.
+ * raid5 uses `(n/(n-1))L/u5`.
+ * raid6 uses `(n/(n-2))L/u6`.
+* raid5 saves raw space only while `u5/u1 > n/(2(n-1))`.
+* If trapping is the only difference between the profiles, the trapped fraction t of the allocation must stay below:
+ * raid5: 25% (3 devices), 33% (4 devices), 40% (6 devices)
+ * raid6: 17% (5 devices), 25% (6 devices)
+* The patch-50 hold-back (the largest group's length, at most a quarter of the space_info) also counts as used for every user reservation, which pushes the effective t higher. Its claim margin is two transactions' worth of whole-stripe claims.
+
+**Measured trapped fraction (stripe_meta metadata):**
+
+| situation | trapped | raid5/6 vs raid1 raw | source |
+|---|---|---|---|
+| fresh fs, 80 MiB used, 4-dev raid5 | 16-23% (31.5-45 MiB of 192) | 256 vs 512 MiB (saves) | meta-profile-bench-20261003 |
+| fill-edge test, raid5 | ~51% (3.04 GiB metadata, 49% used, fs not writable) | loses (above the 33% breakeven) | 04bca28a857b6 (patch 50) message |
+| unlink churn at the edge, raid5 | 1.51 GB trapped; claimable 374 MiB -> 0 while used stayed flat | loses | 7cff178b3a5b7 (patch 51) message |
+| 6-dev raid6 fsstress, 10 min | 202 MiB trapped, 43 MiB used (82%) | loses (breakeven 25%) | memory `stripe-meta-trapping-option4`, dhive #96 |
+| raid6/raid6 octopus T5 COW churn | 754 of 848 MiB (88%); `rm` could not free space (evict could not reserve) | loses badly | `forensics/bhive-r6oct-20260926/`, memory `raid6-raid6-octopus-2026-09-24` |
+
+* **Same-transaction reuse recovers almost nothing.** It is 0.05% of allocations. Trapping comes from hot and cold blocks living in one stripe across transactions (`stripe-meta-trapping-option4`).
+* **Recovery needs relocation.** Reclaim is off by default (`bg_reclaim_threshold` is 0 on non-zoned), and relocation needs the hold-back to have room.
+* **Compaction does work when turned on.** stripe-compact-test took metadata from 89 to 24 MiB trapped (TESTING.md, 2026-10-18), at the cost of relocation writes.
+
+**fsync log runs (patch 81).**
+
+* Source: `forensics/dhive-log-epoch-plateau-20260924/` arm (d), the shipping configuration. 4-dev raid5, 6 fsync writers.
+* Results:
+ * 2.8 MiB of live metadata.
+ * Metadata total 1.59-1.71 GiB at the loaded peak, 1.03 GiB settled. Per-transaction runs alone gave 480 MiB, so settled is 2.15x.
+ * At rest the space is claimable, not trapped (1.25 MiB trapped). But the chunks stay metadata, so data cannot use them.
+* In fsync-mode-bench (seal arm, 28 row pairs), settled raw metadata for raid5 relative to raid1 was:
+ * geomean 0.81, against 0.625 in theory at 5 devices
+ * 11 of 28 rows at or above 1.0 (b2b64k up to 1.88x, par1 up to 1.5x, perinode up to 1.5x)
+ * Chunk-size granularity (256 MiB) makes single rows coarse.
+
+**Caveat.** The fresh-filesystem case does save space. The claim holds for aged, churned, near-full and fsync-heavy filesystems. Nobody has measured a raid1-metadata arm on the same aged-churn workload.
+
+**Test that would settle it:** r6oct T5 churn or the stripe-meta-trapping fsstress, with raid1c3 vs raid6 metadata, running `space-sampler.sh`. Compare raw space per live byte at the end, with reclaim off and with reclaim at 75.
+
+---
+
+## Claim 3: complexity and stall/deadlock risk
+
+### Size
+
+* **Exclusively stripe_meta: 13 patches, +1150 / -126.** Export 38, 48-53, 61, 65, 81, 93, 102, 106.
+ * 38 is `4b4d6efe8d64c`, +482.
+ * 81 (per-log-commit runs) is `944f4a24fde39`, +274.
+ * 65 (system chunks) is `5f54dd568678e`.
+* **Only needed because of stripe_meta:** patch 77, early property load before replay (`2cf425545c69f`, +61/-4). Its failure needs raid56 metadata; the raid1-metadata crash arm passed without it.
+* **Metadata RMW audit:** patches 28, 29, 55, 94 (+315/-19). They do extent-tree lookups from inside the raid56 RMW path.
+* **Shared patches with metadata hunks:** 47, 62, 63, 70, 78, 80, 86, 92, 114.
+* For scale, the whole series is +12576/-2384 and the net diff is +10321/-129.
+
+### Metadata paths touched
+
+The 14 patches above (38, 48-53, 61, 65, 77, 81, 93, 102, 106):
+
+* **Reservations and overcommit.** `reserve_bytes`, `can_overcommit`/`btrfs_can_overcommit`, `btrfs_try_granting_tickets`, `struct reserve_ticket`, and `steal_from_global_rsv`. The ticket flag travels with the ticket.
+* **Global reserve.** `btrfs_update_global_block_rsv`.
+* **Transaction commit.** `btrfs_write_and_wait_transaction`, `btrfs_commit_transaction`, `btrfs_retire_meta_stripes` (a two-phase close and drain after tree writeback), and the metadata writeback deferral in `btree_writepages`.
+* **Log commit.** `clean_log_buffer`, and META_LOG runs keyed by (root, log_transid, transid).
+* **Tree block lifecycle.** `end_bbio_meta_write` reports completion. `btrfs_free_tree_block` and `clean_log_buffer` report abandonment.
+* **Relocation.** `fs_info->reloc_owner` around `btrfs_relocate_block_group`, `set/unset_reloc_control`, and RO against the reserve.
+* **Mount.** `open_ctree`, `btrfs_start_pre_rw_mount`, `mount_cleanup_task`, and replay.
+* **Chunk tree.** `reserve_chunk_space` adds one stripe of headroom.
+
+### Bugs
+
+**Fix patches in the series for stripe_meta behaviour (13 distinct; 81 appears under two headings):**
+
+* **ENOSPC abort / ENOSPC liveness (6):**
+ * 48: trapped accounting frozen.
+ * 49: global reserve against trapped space.
+ * 50: fill-edge transaction abort, and the filesystem running out at half capacity.
+ * 51: unlink steal leads to abort; orphan cleanup refuses rw mount.
+ * 52: commit aborted with ENOSPC while 163 MiB was claimable.
+ * 53: reclaim could not take metadata groups read-only.
+* **Stall / deadlock (3):**
+ * 81: a commit waits out its timeout on a stale log_transid join, besides the write hole below.
+ * 93: making a group RO waited up to `commit_interval` while holding `reclaim_bgs_lock`. The negative control measured 291-301 s.
+ * 94: the audit's tree search under the full-stripe lock can deadlock against a rebuild.
+* **BUG / oops (2):** 61 (assert at unmount after a runtime disable) and 102 (NULL block group lookup, latent).
+* **Write hole / loss in the guarantee itself (2):**
+ * 81: fsync-durable log blocks were RMW'd, 223847 times in 5 min, in the unpatched (patch-81-off) control.
+ * 77: replay outside the policy lost 54-214 synced files under a strip fault.
+* **Audit false positives (1):** 55.
+
+**Shared patches found through, or triggered by, metadata (8), 6 of them hang or abort:**
+
+* 47: reclaim skipped every metadata group (ENOSPC).
+* 68, 69, 96: the retire drain never ended after a raid6-metadata ENOSPC abort. The hung task reported after 327 s, and unmount wedged.
+* 63: BUG on a failed mount whose replay had opened metadata runs; the next mount hung on the superblock lock.
+* 86: an allocation error was taken as success, which put a tree block at logical 0 and aborted the transaction, or gave the same space to two owners.
+* 62: BUG at runtime enable.
+* 92: a group removed while a metadata run still covered it.
+
+Of the 23 `Fixes:`-tagged commits in the series, 6 name the stripe_meta patch (`51fcf2348a33f`) or the metadata audit.
+
+**Folded before the series took its current shape** (memory notes, not visible as commits):
+
+* Mixed-bg commit deadlock: metadata had no completion report (`stripe-alloc-mixed-bg-deadlock`).
+* Retire-wait 60 s stall, three defects. The third was a write-hole invariant violation: the next transaction joined the committing transaction's runs (`stripe-alloc-retire-wait-stall`).
+* Drain leak leading to an unmount BUG (`check_ref_cleanup` and `clean_log_buffer` paths, `stripe-alloc-drain-bug`).
+* Relocation ENOSPC because `create_reloc_inode()` reserved before `reloc_task` was set. Metadata relocation errors went 857 -> 12 once fixed (r6oct runs 5-6).
+* The EMERGENCY-fallback fix v1 was a dead end and was dropped.
+
+**Still open:**
+
+* **Single metadata group.** `bytes_stripe_reserve` = 0 means no stripes are protected, and a tree-block ENOSPC with claimable 0 aborts the transaction. Reproduced 09-27, 09-28 and 09-30, and again on 10-05 in fsync-mode-bench (par64 raid5 carry, `abort-par64-raid5-carry-r1.dmesg`). No acked data was lost; the classification is ENOSPC. Patch 50 says "nothing with a single group".
+* **raid6 metadata at 88% trapped refuses `rm`** (evict cannot reserve). This is a design question left with Zygo (r6oct notes).
+* **mkfs-era / enable-transition window.** On every raid5-metadata filesystem, 3 committed blocks are RMW'd once.
+
+---
+
+## Claim 4: Johannes Thumshirn's zoned ENOSPC work
+
+### His series (linux-btrfs, 2026)
+
+lore.kernel.org served a bot-check page, so the links below are ratatoskr.run mirrors. Commits are from `btrfs/for-next`.
+
+| posted | series | merged commits | mechanism |
+|---|---|---|---|
+| 2026-02-10 | [v3 0/3 "btrfs: zoned fix two long standing ENOSPC bugs"](https://ratatoskr.run/linux-btrfs/2026/02/7625684/t) ([v1](https://ratatoskr.run/linux-btrfs/2026/02/7625640/t), [v2](https://ratatoskr.run/linux-btrfs/2026/02/7625670/t)) | 7bcb04de982f, 258e46a6385c, e2a7fd22378f (v7.1-rc1) | cap the delayed_refs_rsv refill at `total - zone_unusable` (-EAGAIN); move bgs with more than 50% zone_unusable to the reclaim list; RECLAIM_ZONES flush state for DATA |
+| 2026-03 | reclaim refactor + limit | b619185168555, bd0ffde1d31e9, ad0c23c97b4e9 (v7.1-rc1) | `btrfs_reclaim_block_groups()`; limit zones reclaimed in `flush_space()`, because generic/551 hung for more than 120 s |
+| 2026-05-13 | [0/7 "btrfs: fixes around generic/747 on zoned filesystems"](https://ratatoskr.run/linux-btrfs/2026/05/9003460/t) | (v1; patch 5 "subtract zone_unusable space in statfs" and patch 7 "RECLAIM_ZONES and RESET_ZONES in the first async reclaim loop" were not in v2) | async reclaim starvation; statfs over-reporting |
+| 2026-05-19 | [v2 0/5 "btrfs: zoned: fix deadlock and space reporting issues"](https://ratatoskr.run/linux-btrfs/2026/05/16998987/t) | 967c1716eb69d, 82fd26090ebdb, 52416a27aabc4, 814c3b4ea3572 (v7.2-rc1) | deadlock: relocation waits on a ticket only relocation can satisfy (new flush state `BTRFS_RESERVE_FLUSH_ZONED_RELOCATION`; `Fixes:` e2a7fd22378f); statfs excludes the relocation sub-group |
+| 2026-06 | [v1-v5 "btrfs: zoned: don't force read-only on transient -EAGAIN from reloc merge"](https://ratatoskr.run/linux-btrfs/2026/06/17165692/t) | e549093c11a2f (v7.3-rc1) | the February cap aborted transactions during reclaim (`Fixes:` 7bcb04de982f) |
+| 2026-07 | metadata writeback / abort | 1ebe51c29fa97 (v7.2-rc6), ecc05eda9a346, 3cbcc099b4d42, 7636e0b45c1d3 (v7.3-rc1) | deadlock between metadata writeback and commit (zone finish waits for commit under `zoned_meta_io_lock`); commit abort when writeback order meets the active-bg pivot; stranded dirty metadata on abort/unmount |
+| 2026-08-24 | [handle RAID profiles in btrfs_can_activate_zone()](https://ratatoskr.run/linux-btrfs/2026/08/17454631/t) | 3a35e787ac1ac (v7.3-rc4) | writers hung forever in `btrfs_new_extent_direct()` |
+
+The searches found nothing newer from him on the list than 2026-08-24, but they cannot rule it out.
+
+### Overlap with stripe_meta
+
+| problem | zoned (Thumshirn) | stripe_meta |
+|---|---|---|
+| free metadata space that is unusable until reclaim | `zone_unusable`; cap delayed refs against `total - zone_unusable` | `bytes_stripe_unusable` and open-run bytes counted as used in `btrfs_space_info_used()` (48); global reserve against `total - trapped` (49). The threading was copied site by site from zone_unusable (memory `stripe-unusable-threading-audit`) |
+| reclaim of partly-unusable groups | more than 50% zone_unusable goes to `reclaim_bgs` | `btrfs_stripe_bg_wants_reclaim()` (46); reclaim even with reserved/pinned bytes (47); compaction (70); `stripe_reclaim_now` (114) |
+| reclaim from the ENOSPC flush machinery | RECLAIM_ZONES flush state, limited per pass | none: reclaim runs from the cleaner and the commit rescan only |
+| relocation deadlocking on its own reservation | `FLUSH_ZONED_RELOCATION` | `reloc_owner` + hold-back (50); RO against the reserve (53); data: never wait on the gate (41) |
+| abort from a reservation failure during reclaim or commit | -EAGAIN made retryable in reclaim | NO_FLUSH/FLUSH_LIMIT/EMERGENCY draw on the reserve (52); refuse the steal below the reserve (51) |
+| metadata writeback order vs commit | `zoned_meta_io_lock` deadlock; flush the active bg at `btree_writepages()` start | defer to commit (`btrfs_defer_stripe_meta_write()`, written in "the same shape as the zoned write-pointer deferral"); two-phase retire after tree writeback; commit before waiting for RO (93) |
+| leftover state at abort/unmount | drop stranded dirty metadata | release open runs on a failed mount or aborted unmount (63); drain waits end on error (68, 69, 96) |
+
+**Collision.** There is none at the code level.
+* Every Thumshirn commit above is an ancestor of our base `0c48d26d46bdd`.
+* The functions changed by the 14 stripe_meta patches meet his changed functions only in `btree_writepages()`.
+* Across the whole series the shared functions are `btrfs_reclaim_block_group(s)`, `btrfs_reclaim_bgs_work`, `btrfs_delete_unused_bgs`, `handle_reserve_ticket`, `btrfs_reserve_data_bytes`, `btrfs_alloc_data_chunk_ondemand`, `btrfs_statfs` and `close_ctree`. Most of those are data-side stripe_alloc, not stripe_meta.
+
+**What does hold.**
+* stripe_meta solves the same problems a second time with different mechanisms: a hold-back reserve instead of a flush state, a steal refusal instead of retryable -EAGAIN, and task-identity exemptions instead of a new flush enum.
+* Reviewers will see two answers to one question. Every future change to those paths needs re-threading for both.
+* His own fixes needed fixes (814c3b4 fixes e2a7fd2; e549093 fixes 7bcb04d). That is evidence that this territory produces deadlocks and aborts even in upstream hands, which supports claim 3.
+
+**Counterpoint for the cover letter.** Zoned metadata already lives with append-only placement and unusable-until-reclaim space. So upstream has accepted this kind of cost for metadata before.
+
+---
+
+## Summary for the cover letter
+
+**What dropping removes.**
+* 14 patches: export 38, 48-53, 61, 65, 77, 81, 93, 102, 106. About +1211 / -130 lines, roughly 10% of the series' insertions.
+* Metadata hunks in about 9 shared patches.
+* Optionally the metadata RMW audit (28, 29, 55, 94; +315/-19).
+* The series becomes data-only. Metadata keeps the stock allocator.
+* The reservation and overcommit paths, the global reserve, the commit and log-commit retire, tree-block completion reporting, the replay-time property load and the metadata relocation reserve all lose their stripe_alloc changes.
+* The obsolete directed tests are stripe-meta-enospc, stripe-meta-toggle, sys-chunk-tear (EXPECT=fixed), meta-reloc-drain, meta-ro-commit, meta-crash-replay and run-meta-fsync-tear.
+
+**What users lose: the write-hole closure for raid56 metadata.**
+* Without it, a crash plus a lost or bad member can tear committed tree blocks that share a stripe with a later sub-stripe write. That includes fsync-durable log-tree blocks and the chunk tree in raid56 system chunks.
+* Stock 7.3 made the chunk tree unreadable and the degraded mount was refused after 5 transactions (`sys-chunk-tear-test`, 2026-09-20).
+* plain stripe_alloc: 174 of 249 sub-stripe metadata writes rewrote parity over committed blocks (patch 29 message).
+
+**What users should do instead.**
+* Use raid1 metadata with raid5 data, or raid1c3 metadata with raid6 data. These tolerate the same number of failed devices.
+* mkfs already defaults to raid1 metadata on multiple devices. An existing filesystem converts online (`btrfs balance start -mconvert=raid1c3`).
+* raid6 data + raid1c3 metadata is covered in testing (r6c3: six stages PASS).
+* Patch 27's mount warning returns to its original scope. It fires for raid56 metadata or system chunks:
+
+ stripe_alloc does not cover raid56 metadata: the write hole remains for metadata, consider converting it to raid1c3/raid1c4
+
+ The rate-limited per-write warning from patch 28 also stays, with the `meta_rmw` counter in `stripe_park_stats`:
+
+ read-modify-write of full stripe N: this block group is not covered by stripe_alloc, the raid56 write hole applies to it
+
+ For metadata it fires continuously, by design.
+* Mixed block groups stay refused (patch 6).