]> git.hungrycats.org Git - linux/commitdiff
stripe-alloc: REORDER-PLAN rev 3 and the reorder engine
authorZygo Blaxell <ce3g8jdj@umail.furryterror.org>
Fri, 23 Oct 2026 17:38:57 +0000 (13:38 -0400)
committerZygo Blaxell <ce3g8jdj@umail.furryterror.org>
Fri, 23 Oct 2026 17:38:57 +0000 (13:38 -0400)
o-sord's revision 3 of the subtopic reorder: data-only reclaim in S3,
extended to metadata block groups by a new S5 commit, order S1 S2 S3 S4
S6a S5 S6b.  Candidates refs/tmp/o-sord/p16 (misc-next, 164 commits) and
q16 (6.18, 180) build W=1-clean at every boundary and at every commit
from S3 on; final trees equal the lane tips plus the documented
residual.  scripts/sa-reorder/ holds the engine, inputs, logs and
checks that regenerate them.  Both are on the pre-rebase bases and get
replayed after the 2026-10-23 lane rebase.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B6wxsJn1aY7PwnhgXdz6Ec

78 files changed:
scripts/sa-reorder/README.md [new file with mode: 0644]
scripts/sa-reorder/bin/assemble.py [new file with mode: 0644]
scripts/sa-reorder/bin/assemble3.py [new file with mode: 0644]
scripts/sa-reorder/bin/blamedeps.py [new file with mode: 0755]
scripts/sa-reorder/bin/bounds.sh [new file with mode: 0755]
scripts/sa-reorder/bin/mkchain.py [new file with mode: 0644]
scripts/sa-reorder/bin/mkorder.py [new file with mode: 0644]
scripts/sa-reorder/bin/mkorder5.py [new file with mode: 0644]
scripts/sa-reorder/bin/mktable.py [new file with mode: 0644]
scripts/sa-reorder/bin/msgdiff.py [new file with mode: 0644]
scripts/sa-reorder/bin/novel.py [new file with mode: 0644]
scripts/sa-reorder/bin/oracle.py [new file with mode: 0644]
scripts/sa-reorder/bin/oracle2.py [new file with mode: 0644]
scripts/sa-reorder/bin/oracle3.py [new file with mode: 0644]
scripts/sa-reorder/bin/presplit.py [new file with mode: 0644]
scripts/sa-reorder/bin/replay.py [new file with mode: 0644]
scripts/sa-reorder/bin/replay2.py [new file with mode: 0644]
scripts/sa-reorder/bin/replay3.py [new file with mode: 0644]
scripts/sa-reorder/bin/replay4.py [new file with mode: 0644]
scripts/sa-reorder/bin/review.py [new file with mode: 0644]
scripts/sa-reorder/bin/review4.py [new file with mode: 0644]
scripts/sa-reorder/bin/tokdeps.py [new file with mode: 0644]
scripts/sa-reorder/bin/viol.py [new file with mode: 0644]
scripts/sa-reorder/bin/wblock.py [new file with mode: 0644]
scripts/sa-reorder/bin/wdump.py [new file with mode: 0644]
scripts/sa-reorder/bin/wpost.py [new file with mode: 0644]
scripts/sa-reorder/bin/wreplay.py [new file with mode: 0644]
scripts/sa-reorder/bin/zmerge.py [new file with mode: 0644]
scripts/sa-reorder/build-one2.sh [new file with mode: 0644]
scripts/sa-reorder/class.v10 [new file with mode: 0644]
scripts/sa-reorder/class.v11 [new file with mode: 0644]
scripts/sa-reorder/class.v13 [new file with mode: 0644]
scripts/sa-reorder/class618.v2 [new file with mode: 0644]
scripts/sa-reorder/class618.v3 [new file with mode: 0644]
scripts/sa-reorder/class618.v5 [new file with mode: 0644]
scripts/sa-reorder/each-commit2.sh [new file with mode: 0644]
scripts/sa-reorder/oracle-618.txt [new file with mode: 0644]
scripts/sa-reorder/oracle-mn.txt [new file with mode: 0644]
scripts/sa-reorder/order.orig116 [new file with mode: 0644]
scripts/sa-reorder/order618.orig132 [new file with mode: 0644]
scripts/sa-reorder/post/ext.py [new file with mode: 0644]
scripts/sa-reorder/post/msgdiff-618.txt [new file with mode: 0644]
scripts/sa-reorder/post/msgdiff-mn.txt [new file with mode: 0644]
scripts/sa-reorder/post/msgs.py [new file with mode: 0644]
scripts/sa-reorder/post/notes13.py [new file with mode: 0644]
scripts/sa-reorder/post/residual-618.diff [new file with mode: 0644]
scripts/sa-reorder/post/residual-mn.diff [new file with mode: 0644]
scripts/sa-reorder/post/wpost-618.py [new file with mode: 0644]
scripts/sa-reorder/post/wpost-mn.py [new file with mode: 0644]
scripts/sa-reorder/queue7.sh [new file with mode: 0755]
scripts/sa-reorder/queue8.sh [new file with mode: 0755]
scripts/sa-reorder/queue9.sh [new file with mode: 0755]
scripts/sa-reorder/rev9-S1.txt [new file with mode: 0644]
scripts/sa-reorder/rev9-S2.txt [new file with mode: 0644]
scripts/sa-reorder/rev9-S3.txt [new file with mode: 0644]
scripts/sa-reorder/rev9-S4.txt [new file with mode: 0644]
scripts/sa-reorder/rev9-S5.txt [new file with mode: 0644]
scripts/sa-reorder/review4-618.txt [new file with mode: 0644]
scripts/sa-reorder/review4-mn.txt [new file with mode: 0644]
scripts/sa-reorder/wpost-p16.json [new file with mode: 0644]
scripts/sa-reorder/wpost-p16.log [new file with mode: 0644]
scripts/sa-reorder/wpost-q16.json [new file with mode: 0644]
scripts/sa-reorder/wpost-q16.log [new file with mode: 0644]
scripts/sa-reorder/wreplay-618e.log [new file with mode: 0644]
scripts/sa-reorder/wreplay-618f.log [new file with mode: 0644]
scripts/sa-reorder/wreplay-w11.json [new file with mode: 0644]
scripts/sa-reorder/wreplay-w11.log [new file with mode: 0644]
scripts/sa-reorder/wreplay-w12.json [new file with mode: 0644]
scripts/sa-reorder/wreplay-w12.log [new file with mode: 0644]
scripts/sa-reorder/wreplay-x15.json [new file with mode: 0644]
scripts/sa-reorder/wreplay-x15.log [new file with mode: 0644]
scripts/sa-reorder/wreplay-y15.json [new file with mode: 0644]
scripts/sa-reorder/wreplay-y15.log [new file with mode: 0644]
scripts/sa-reorder/wspec13.py [new file with mode: 0644]
scripts/sa-reorder/wspec5.py [new file with mode: 0644]
scripts/sa-reorder/wspec618.py [new file with mode: 0644]
scripts/sa-reorder/wspec618b.py [new file with mode: 0644]
topics/stripe-alloc/REORDER-PLAN.md

diff --git a/scripts/sa-reorder/README.md b/scripts/sa-reorder/README.md
new file mode 100644 (file)
index 0000000..a24f896
--- /dev/null
@@ -0,0 +1,36 @@
+# sa-reorder: the stripe-alloc reorder engine
+
+o-sord's tools for rebuilding topics/stripe-alloc in subtopic order
+(REORDER-PLAN.md, rev 2, 2026-10-22).  They were copied from the job's
+temporary directory.  The working caches, intermediate specs and older
+engine logs were left behind.
+
+- `bin/wreplay.py` is the engine.  It partitions each original patch by
+  hunk and line into the subtopics, and adds no code.
+- Inputs:
+  - misc-next: `order.orig116` (source commits), `class.v11` (subtopic per
+    patch; `class.v10` is the earlier one with 113 in S6) and `wspec5.py`
+    (transfers, PERSUB, NOMATCH, FOLD, JOIN, FORCE);
+  - 6.18: `order618.orig132`, `class618.v3` (`class618.v2` had 129, 113's
+    equivalent, in S6) and `wspec618.py`.
+- Checks: `bin/oracle2.py` compares tree, authorship and messages.
+  `bin/novel.py`, `bin/review.py` and `bin/wblock.py` show each
+  boundary's new top-level blocks.  `bin/bounds.sh` lists the boundaries.
+- Outputs of the final runs: `wreplay-w12.{log,json}` (misc-next,
+  candidate 5b4847cb8f7a) and `wreplay-618f.log` (6.18, 487ff1c5a439).
+  The previous runs, with 113 in S6, are `wreplay-w11.{log,json}`
+  (da5e6a43ea6c) and `wreplay-618e.log` (dd63b3b1b6d3).
+- Block reviews of S1-S5: `rev9-S*.txt`.
+
+To regenerate, run from this directory with a scratch TMPD.  It writes
+wreplay.json, wstate.pkl and torn.json into TMPD, and takes about 4 minutes:
+
+    TMPD=$(mktemp -d) python3 -I bin/wreplay.py ~/share/linux 0c48d26d46bd \
+        order.orig116 class.v11 wspec5.py <ref> <log>
+
+For 6.18, use base 2ff600d29ee4 with the 618 inputs.  The 6.18 boundaries
+build only when merged with 6.18/topics/raid56-disguise.
+
+The specs are tied to the exact
+source tips (misc-next a23064467620, 6.18 6602cb54b8e2).  Any change to
+the source series needs the class and spec files revisited.
diff --git a/scripts/sa-reorder/bin/assemble.py b/scripts/sa-reorder/bin/assemble.py
new file mode 100644 (file)
index 0000000..7a8495f
--- /dev/null
@@ -0,0 +1,29 @@
+#!/usr/bin/python3 -I
+# assemble.py WREPLAY.json BUILDS.txt -> REORDER-PLAN.md on stdout
+import json, sys, subprocess
+o = json.load(open(sys.argv[1])); builds = open(sys.argv[2]).read()
+o618 = json.load(open('t618/wreplay.json'))
+tags = {1: 'base', 2: 'allow_rmw', 3: 'reclaim', 4: 'fsync', 5: 'stripe_meta', 6: 'debug'}
+def bounds(o, pfx):
+    st = {}
+    for line in builds.splitlines():
+        if line.startswith(pfx + ' '):
+            _, s, res = line.split(' ', 2); st[s] = res
+    runs = []
+    for i, x in enumerate(o, 1):
+        if not runs or runs[-1][0] != x['sub']: runs.append([x['sub'], i, i, x['sha']])
+        else: runs[-1][2] = i; runs[-1][3] = x['sha']
+    return '\n'.join(f"| S{s} {tags[s]} | #{a}-#{c} ({c - a + 1}) | {sha[:12]} | {st.get('S%d' % s, 'pending')} |"
+                     for s, a, c, sha in runs)
+b = bounds(o, 'BOUND')
+parts = ['| new | S | from old | lines | why |', '|---:|:-:|---:|---:|---|']
+for i, x in enumerate(o, 1):
+    if x['kind'] == 'part':
+        parts.append(f"| {i} | {x['sub']} | {x['src']} | {x['lines']} | {'; '.join(x['why'])} |")
+tip = o[-1]['sha'][:12]
+h = open('plan-head-11.md').read(); t = open('plan-tail-11.md').read()
+doc = (h + '\n' + t).replace('__TIP__', tip).replace('__BOUNDS__', b).replace('__PARTS__', '\n'.join(parts))
+doc = doc.replace('__TABLE__', open('table-new4.md').read().rstrip('\n'))
+doc = doc.replace('__BUILDS__', '\n'.join(l for l in builds.splitlines() if not l.startswith(('BOUND ', 'BOUND618 '))))
+doc = doc.replace('__TIP618__', o618[-1]['sha'][:12]).replace('__BOUNDS618__', bounds(o618, 'BOUND618'))
+sys.stdout.write(doc)
diff --git a/scripts/sa-reorder/bin/assemble3.py b/scripts/sa-reorder/bin/assemble3.py
new file mode 100644 (file)
index 0000000..95d9115
--- /dev/null
@@ -0,0 +1,61 @@
+#!/usr/bin/python3 -I
+# assemble3.py BUILDS.md -> REORDER-PLAN.md (revision 3) on stdout
+import json, sys, subprocess, re
+R = '/home/aigendu/share/linux'
+def git(*a): return subprocess.run(['git', '-C', R] + list(a), capture_output=True, text=True, check=True).stdout
+mn = json.load(open('wpost-p16.json')); s618 = json.load(open('wpost-q16.json'))
+builds = open(sys.argv[1]).read().rstrip('\n')
+ZN = {1: 'S1 base', 2: 'S2 allow_rmw', 3: 'S3 reclaim', 4: 'S4 fsync', 5: 'S6a debug', 6: 'S5 stripe_meta', 7: 'S6b debug_meta'}
+ZS = {1: 'S1', 2: 'S2', 3: 'S3', 4: 'S4', 5: 'S6a', 6: 'S5', 7: 'S6b'}
+def bounds(o):
+    runs = []
+    for i, x in enumerate(o, 1):
+        if not runs or runs[-1][0] != x['sub']: runs.append([x['sub'], i, i, x['sha']])
+        else: runs[-1][2] = i; runs[-1][3] = x['sha']
+    rows = ['| subtopic | commits | boundary | tree |', '|---|---|---|---|']
+    rows += [f"| {ZN[s]} | #{a}-#{c} ({c - a + 1}) | {sha[:12]} | {git('rev-parse', sha + '^{tree}')[:12]} |" for s, a, c, sha in runs]
+    return '\n'.join(rows)
+def parts(o, eng):
+    e = {x['sha']: x for x in json.load(open(eng))}
+    rows = ['| new | S | from old | lines | why |', '|---:|:-:|---:|---:|---|']
+    for i, x in enumerate(o, 1):
+        if x['kind'] == 'part':
+            y = e[x['eng_sha']]
+            rows.append(f"| {i} | {ZS[x['sub']]} | {x['src']} | {y['lines']} | {'; '.join(y['why'])} |")
+    return '\n'.join(rows)
+def new(o): return next((i, x) for i, x in enumerate(o, 1) if x['kind'] == 'new')
+def s4(o): return [x['sha'] for x in o if x['sub'] <= 4][-1]
+def fence(t): return t.replace('```', "'''")
+emn, e618 = new(mn), new(s618)
+ext_msg = git('log', '-1', '--format=%B', emn[1]['sha']).rstrip('\n')
+ext_diff = '\n'.join(l for l in git('show', '--format=', emn[1]['sha']).splitlines() if not l.startswith('index '))
+s4g = git('grep', '-n', '-E', 'btrfs_is_stripe_meta_bg|BTRFS_STRIPE_RUN_META|bytes_stripe_reserve|retire_meta|stripe_log_run|META_LOG|stripe_meta',
+          s4(mn), '--', 'fs/btrfs', 'include').replace(s4(mn) + ':', '').rstrip('\n')
+w = open('post/wpost-618.py').read()
+warn = re.search(r"NEW_WARN = '''(.*?)'''", w, re.S).group(1).rstrip('\n')
+md618 = open('post/msgdiff-618.txt').read()
+m76 = re.search(r"(\*\*#\d+\*\* \(old 76, main\).*?```\n\n)", md618, re.S).group(1)
+oracle = '```\n' + open('oracle-mn.txt').read().rstrip() + '\n```\n\n6.18:\n\n```\n' + open('oracle-618.txt').read().rstrip() + '\n```'
+g618 = next(i for i, x in enumerate(s618, 1) if x['src'] == 88 and x['kind'] == 'main')
+sub = {
+ '__MN__': mn[-1]['sha'][:12], '__S618__': s618[-1]['sha'][:12],
+ '__NMN__': str(len(mn)), '__N618__': str(len(s618)),
+ '__TREEMN__': git('rev-parse', mn[-1]['sha'] + '^{tree}')[:12], '__TREE618__': git('rev-parse', s618[-1]['sha'] + '^{tree}')[:12],
+ '__BOUNDS_MN__': bounds(mn), '__BOUNDS_618__': bounds(s618),
+ '__EXTMN__': str(emn[0]), '__EXT618__': str(e618[0]), '__EXTMSG__': ext_msg, '__EXTDIFF__': ext_diff,
+ '__G618__': str(g618),
+ '__RESID_MN__': open('post/residual-mn.diff').read().rstrip('\n'),
+ '__RESID_618__': open('post/residual-618.diff').read().rstrip('\n'),
+ '__MSGDIFF_MN__': open('post/msgdiff-mn.txt').read().rstrip('\n') + '\n\n6.18 only:\n\n' + m76.rstrip('\n'),
+ '__ORACLE__': oracle, '__WARN618__': warn,
+ '__TABLE__': open('table-new6.md').read().rstrip('\n'),
+ '__PARTS__': parts(mn, 'wreplay-x15.json'), '__PARTS618__': parts(s618, 'wreplay-y15.json'),
+ '__S4MN__': s4(mn)[:12], '__S4618__': s4(s618)[:12], '__S4GREP__': s4g,
+ '__BUILDS__': builds,
+}
+doc = open('plan3-head.md').read() + '\n' + open('plan3-a.md').read() + '\n' + open('plan3-tail.md').read()
+for k, v in sub.items():
+    doc = doc.replace(k, v)
+left = set(re.findall(r'__[A-Z0-9_]+__', doc))
+assert not left, left
+sys.stdout.write(doc)
diff --git a/scripts/sa-reorder/bin/blamedeps.py b/scripts/sa-reorder/bin/blamedeps.py
new file mode 100755 (executable)
index 0000000..aac0ec3
--- /dev/null
@@ -0,0 +1,40 @@
+#!/usr/bin/python3 -I
+# For each commit in BASE..TIP, blame the old-side lines of each hunk in its
+# parent and report which series commits those lines came from.
+import subprocess, sys, re, json
+repo, base, tip, out = sys.argv[1:5]
+def git(*a):
+    return subprocess.run(['git','-C',repo]+list(a),capture_output=True,text=True,check=True).stdout
+commits = git('rev-list','--reverse',f'{base}..{tip}').split()
+idx = {c:i+1 for i,c in enumerate(commits)}
+def one(arg):
+    i,c=arg
+    d = git('diff','-U3',f'{c}^',c)
+    fname=None; edges={}
+    for line in d.splitlines():
+        if line.startswith('--- '):
+            fname = line[6:] if line.startswith('--- a/') else None
+        m = re.match(r'^@@ -(\d+)(?:,(\d+))? \+', line)
+        if m and fname:
+            a=int(m.group(1)); b=int(m.group(2) or 1)
+            if b==0:
+                # pure insertion after line a: blame line a and a+1
+                rng=[(max(a,1),max(a,1)+1)]
+            else:
+                rng=[(a,a+b-1)]
+            for lo,hi in rng:
+                try:
+                    bl = git('blame','--porcelain','-L',f'{lo},{hi}',f'{base}..{c}^','--',fname)
+                except subprocess.CalledProcessError:
+                    continue
+                for bline in bl.splitlines():
+                    mm = re.match(r'^([0-9a-f]{40}) \d+ \d+', bline)
+                    if mm and mm.group(1) in idx:
+                        j = idx[mm.group(1)]
+                        edges.setdefault(j,set()).add(fname.split('/')[-1])
+    print(i, sorted(edges), file=sys.stderr, flush=True)
+    return i,{str(k):sorted(v) for k,v in edges.items()}
+from multiprocessing import Pool
+with Pool(12) as p:
+    deps=dict(p.map(one, list(enumerate(commits,1))))
+json.dump(deps, open(out,'w'), indent=0)
diff --git a/scripts/sa-reorder/bin/bounds.sh b/scripts/sa-reorder/bin/bounds.sh
new file mode 100755 (executable)
index 0000000..20f91b0
--- /dev/null
@@ -0,0 +1,17 @@
+#!/bin/bash
+# bounds.sh: boundary refs from wreplay.json -> refs/tmp/o-sord/b-S*, push to ahive, start builds
+cd /home/aigendu/.claude/jobs/f89f1ecd/tmp/osord
+python3 - <<'PY' > boundaries.txt
+import json
+o=json.load(open('wreplay.json'))
+runs=[]
+for i,x in enumerate(o,1):
+    if not runs or runs[-1][0]!=x['sub']: runs.append([x['sub'],i,i,x['sha']])
+    else: runs[-1][2]=i; runs[-1][3]=x['sha']
+for s,a,b,sha in runs: print(f'S{s} {a} {b} {sha}')
+PY
+cat boundaries.txt
+while read s a b sha; do git -C ~/share/linux update-ref refs/tmp/o-sord/b-$s $sha; done < boundaries.txt
+git -C ~/share/linux push -f root@ahive:/mnt/linux/linux 'refs/tmp/o-sord/b-*:refs/tmp/o-sord/b-*' 2>&1 | grep -c forced
+P=$1; shift
+timeout 60 ssh -o BatchMode=yes root@ahive "systemctl stop osord-build 2>/dev/null; cd /mnt/linux/wt-osord-mn; systemd-run --unit=osord-build --collect /mnt/linux/wt-osord-mn/run-all.sh $P $*"
diff --git a/scripts/sa-reorder/bin/mkchain.py b/scripts/sa-reorder/bin/mkchain.py
new file mode 100644 (file)
index 0000000..20e3a5a
--- /dev/null
@@ -0,0 +1,31 @@
+#!/usr/bin/python3 -I
+# mkchain.py REPO WPOST.json EXTRA FROM PREFIX
+# 6.18 builds need EXTRA (raid56-disguise) merged in.  For each commit of
+# the candidate from index FROM-1 (1-based; the commit before FROM is the
+# per-commit base) to the end, merge it with EXTRA (git merge-tree) and
+# commit the result on a linear chain: refs PREFIX/pre (= FROM-1 merged) and
+# PREFIX/each (the chain tip); PREFIX/S<n> for each subtopic's last commit.
+import json, subprocess, sys
+repo, wj, extra, frm, prefix = sys.argv[1:6]
+frm = int(frm)
+def git(*a, inp=None):
+    r = subprocess.run(['git', '-C', repo] + list(a), input=inp, capture_output=True, text=True)
+    if r.returncode:
+        raise RuntimeError(f'{a}: {r.stdout[:1500]} {r.stderr[:500]}')
+    return r.stdout.strip()
+out = json.load(open(wj))
+def merged(c):
+    return git('merge-tree', '--write-tree', c, extra).split()[0]
+prev = git('commit-tree', merged(out[frm - 2]['sha']), '-p', extra, inp='chain base\n')
+git('update-ref', f'{prefix}/pre', prev)
+for i in range(frm - 1, len(out)):
+    prev = git('commit-tree', merged(out[i]['sha']), '-p', prev, inp=f'#{i + 1} {out[i]["subject"]}\n')
+git('update-ref', f'{prefix}/each', prev)
+last = {}
+for i, o in enumerate(out):
+    last[o['sub']] = o['sha']
+for s, c in sorted(last.items()):
+    m = git('commit-tree', merged(c), '-p', extra, inp=f'S{s} end merged with raid56-disguise\n')
+    git('update-ref', f'{prefix}/S{s}', m)
+    print(f'S{s}', c[:12], m[:12])
+print('each', prev[:12], len(out) - frm + 1, 'commits')
diff --git a/scripts/sa-reorder/bin/mkorder.py b/scripts/sa-reorder/bin/mkorder.py
new file mode 100644 (file)
index 0000000..1f7723d
--- /dev/null
@@ -0,0 +1,6 @@
+#!/usr/bin/python3 -I
+import sys,subprocess
+cls={int(a):int(b) for a,b in (l.split()[:2] for l in open(sys.argv[1]) if l.strip() and not l.startswith('#'))}
+shas=subprocess.run(['git','-C',sys.argv[2],'rev-list','--reverse',sys.argv[3]],capture_output=True,text=True).stdout.split()
+for i in sorted(cls,key=lambda i:(cls[i],i)):
+    print(shas[i-1], f'S{cls[i]} old{i}')
diff --git a/scripts/sa-reorder/bin/mkorder5.py b/scripts/sa-reorder/bin/mkorder5.py
new file mode 100644 (file)
index 0000000..dce56f9
--- /dev/null
@@ -0,0 +1,19 @@
+#!/usr/bin/python3 -I
+# mkorder5.py CLASSFILE HPRIME.json > order
+import json, sys
+cls = {int(a): int(b) for a, b in (l.split() for l in open(sys.argv[1]) if l.strip())}
+h = json.load(open(sys.argv[2]))
+items = []
+for seq, x in enumerate(h):
+    pc = x['piece']
+    if pc.startswith('S') and pc[1:].isdigit():
+        s = int(pc[1:])
+    elif pc.startswith('after'):
+        s = cls[int(pc[5:])]
+    else:
+        s = cls[x['old']]
+    key = (s, int(pc[5:]) if pc.startswith('after') else x['old'], 1 if pc.startswith('after') else 0, seq)
+    lab = f"S{s} old{x['old']}" + (f".{pc}" if pc else '')
+    items.append((key, x['sha'], lab))
+for key, sha, lab in sorted(items):
+    print(sha, lab)
diff --git a/scripts/sa-reorder/bin/mktable.py b/scripts/sa-reorder/bin/mktable.py
new file mode 100644 (file)
index 0000000..7f7ffa3
--- /dev/null
@@ -0,0 +1,21 @@
+#!/usr/bin/python3 -I
+# mktable.py: section 1's table (table-new6.md) from wpost-p16.json, table-new5.md's subjects and post/notes13.py
+import json, re
+exec(open('post/notes13.py').read())
+o = json.load(open('wpost-p16.json'))
+ZN = {1: 'S1', 2: 'S2', 3: 'S3', 4: 'S4', 5: 'S6a', 6: 'S5', 7: 'S6b'}
+main = {}; parts = {}
+for i, x in enumerate(o, 1):
+    if x['kind'] == 'main': main[x['src']] = (i, x['sub'])
+    elif x['kind'] == 'part': parts.setdefault(x['src'], []).append((i, x['sub']))
+rows = [l for l in open('table-new5.md') if re.match(r'^\| \d+ \|', l)]
+out = ['| old | new | S | subject | parts | note |', '|---:|---:|:-:|---|---|---|']
+for l in rows:
+    c = [s.strip() for s in l.strip().strip('|').split('|')]
+    k = int(c[0]); n, s = main[k]
+    p = ', '.join(f'#{i} {ZN[t]}' for i, t in parts.get(k, []))
+    out.append(f'| {k} | {n} | {ZN[s]} | {c[3]} | {p} | {NOTES.get(k, c[5])} |')
+    if k == 38:
+        e = next(i for i, x in enumerate(o, 1) if x['kind'] == 'new')
+        out.append(f'| new | {e} | S5 | stripe_meta: extend stripe reclaim to metadata block groups |  | ruling A: the metadata parts of 42, 46, 47, 70 and 114 (author Zygo, today; Assisted-by only) |')
+open('table-new6.md', 'w').write('\n'.join(out) + '\n')
diff --git a/scripts/sa-reorder/bin/msgdiff.py b/scripts/sa-reorder/bin/msgdiff.py
new file mode 100644 (file)
index 0000000..b7f8640
--- /dev/null
@@ -0,0 +1,20 @@
+#!/usr/bin/python3 -I
+# msgdiff.py WPOST.json ORDERORIG: the message edits, as diffs against the source message
+import json, subprocess, difflib, sys
+o = json.load(open(sys.argv[1]))
+orig = [l.split()[0] for l in open(sys.argv[2]) if l.strip()]
+def body(c):
+    r = subprocess.run(['git', '-C', '/home/aigendu/share/linux', 'cat-file', 'commit', c], capture_output=True, text=True).stdout
+    return r[r.index('\n\n') + 2:]
+for i, x in enumerate(o, 1):
+    if not x['msg_changed'] or x['kind'] == 'new':
+        continue
+    a = body(orig[x['src'] - 1]) if x['kind'] == 'main' else body(x['eng_sha'])
+    b = body(x['sha'])
+    print(f'**#{i}** (old {x["src"]}, {x["kind"]}): {x["subject"]}\n')
+    print('```diff')
+    for d in difflib.unified_diff(a.rstrip('\n').splitlines(), b.rstrip('\n').splitlines(), lineterm='', n=0):
+        if d.startswith(('---', '+++')):
+            continue
+        print(d)
+    print('```\n')
diff --git a/scripts/sa-reorder/bin/novel.py b/scripts/sa-reorder/bin/novel.py
new file mode 100644 (file)
index 0000000..1df3b56
--- /dev/null
@@ -0,0 +1,56 @@
+#!/usr/bin/python3 -I
+# novel.py REPO BASE ORIGORDER REF...: top-level C blocks (functions, structs,
+# initializers; comments stripped) in each REF tree that never existed in any
+# tree of the original series.  Those are the code combinations the reorder
+# created and that need review; every other block is byte-identical (modulo
+# comments) to some original version.
+import subprocess, sys, re, hashlib, json
+repo, base, origf = sys.argv[1:4]; refs = sys.argv[4:]
+def git(*a):
+    return subprocess.run(['git', '-C', repo] + list(a), capture_output=True, text=True).stdout
+orig = [l.split()[0] for l in open(origf) if l.strip()]
+files = sorted(set(git('diff', '--name-only', base, orig[-1]).split()))
+def strip_comments(text):
+    text = re.sub(r'/\*.*?\*/', '', text, flags=re.S)
+    text = re.sub(r'//[^\n]*', '', text)
+    return '\n'.join(l.rstrip() for l in text.splitlines() if l.strip())
+def blocks(text):
+    """top-level blocks: (name, normalized text)"""
+    t = strip_comments(text)
+    out = []; cur = []; depth = 0
+    for line in t.splitlines():
+        cur.append(line)
+        s = re.sub(r'"(\\.|[^"\\])*"', '""', line)
+        s = re.sub(r"'(\\.|[^'\\])*'", "''", s)
+        depth += s.count('{') - s.count('}')
+        if depth == 0 and ('}' in s or s.endswith(';')):
+            body = '\n'.join(cur)
+            if '{' in body:
+                head = next((l for l in cur if '(' in l or 'struct' in l or 'enum' in l), cur[0])
+                out.append((head.strip()[:100], body))
+            cur = []
+    return out
+known = {}
+revs = [base] + orig
+for p in files:
+    seen = set()
+    for r in revs:
+        x = subprocess.run(['git', '-C', repo, 'show', f'{r}:{p}'], capture_output=True, text=True)
+        if x.returncode:
+            continue
+        for name, body in blocks(x.stdout):
+            seen.add(hashlib.sha1(body.encode()).hexdigest())
+    known[p] = seen
+res = {}
+for ref in refs:
+    lst = []
+    for p in files:
+        x = subprocess.run(['git', '-C', repo, 'show', f'{ref}:{p}'], capture_output=True, text=True)
+        for name, body in blocks(x.stdout):
+            if hashlib.sha1(body.encode()).hexdigest() not in known[p]:
+                lst.append((p, name))
+    res[ref] = lst
+    print(f'== {ref}: {len(lst)} novel blocks')
+    for p, n in lst:
+        print(f'   {p}: {n}')
+json.dump(res, open('novel.json', 'w'), indent=1)
diff --git a/scripts/sa-reorder/bin/oracle.py b/scripts/sa-reorder/bin/oracle.py
new file mode 100644 (file)
index 0000000..918c48c
--- /dev/null
@@ -0,0 +1,52 @@
+#!/usr/bin/python3 -I
+# oracle.py REPO BASE REF LOG HPRIME.json ORDERORIG FINAL
+# Checks the final tree, authorship per commit against its source patch,
+# coverage of all original patches, subtopic contiguity; prints boundaries.
+import subprocess, sys, json, re
+repo, base, ref, logf, hpf, origf, final = sys.argv[1:8]
+def git(*a):
+    return subprocess.run(['git', '-C', repo] + list(a), capture_output=True, text=True).stdout
+orig = [l.split()[0] for l in open(origf) if l.strip()]
+h = json.load(open(hpf))
+oklines = [l for l in open(logf) if l.startswith('OK ')]
+commits = git('rev-list', '--reverse', f'{base}..{ref}').split()
+assert len(commits) == len(oklines), (len(commits), len(oklines))
+ok = True
+ft, rt = git('rev-parse', f'{final}^{{tree}}').strip(), git('rev-parse', f'{ref}^{{tree}}').strip()
+print(f'final tree {rt} vs {ft}: {"MATCH" if rt == ft else "MISMATCH"}')
+ok &= rt == ft
+seen = set(); subs = []; nres = 0; bad = []
+for c, l in zip(commits, oklines):
+    lab = l.split(' -> ')[0].split(' ', 2)[2]
+    m = re.match(r'^S(\d) old(\d+)', lab)
+    old = int(m.group(2))
+    mr = re.search(r'RESIDUAL\(after S(\d) ', lab)
+    sub = int(mr.group(1)) if mr else int(m.group(1))
+    nres += bool(mr)
+    subs.append((sub, c, lab))
+    seen.add(old)
+    a = git('log', '-1', '--format=%an <%ae> %ad', '--date=raw', c).strip()
+    o = git('log', '-1', '--format=%an <%ae> %ad', '--date=raw', orig[old - 1]).strip()
+    if a != o:
+        bad.append((lab, a, o))
+print(f'{len(commits)} commits ({nres} moved-hunk follow-ups); originals covered {len(seen)}/{len(orig)}')
+ok &= len(seen) == len(orig)
+print('authorship mismatches:', len(bad))
+for b in bad[:10]: print('  ', b)
+ok &= not bad
+# original subjects present as-is (multiset of originals)
+subj_new = [git('log', '-1', '--format=%s', c).strip() for c in commits]
+missing = [i + 1 for i, s in enumerate(orig) if git('log', '-1', '--format=%s', s).strip() not in subj_new]
+print('original subjects missing from the new range:', missing)
+ok &= not missing
+# contiguity and boundaries
+seq = [s for s, _, _ in subs]
+runs = []
+for i, s in enumerate(seq):
+    if not runs or runs[-1][0] != s: runs.append([s, i + 1, i + 1])
+    else: runs[-1][2] = i + 1
+print('subtopic runs (subtopic, first#, last#):', runs)
+ok &= len(runs) == len(set(seq))
+for s, a, b in runs:
+    print(f'boundary S{s}: new #{b} {subs[b - 1][1][:12]} {subs[b - 1][2]}')
+print('ORACLE', 'PASS' if ok else 'FAIL')
diff --git a/scripts/sa-reorder/bin/oracle2.py b/scripts/sa-reorder/bin/oracle2.py
new file mode 100644 (file)
index 0000000..a1951d2
--- /dev/null
@@ -0,0 +1,46 @@
+#!/usr/bin/python3 -I
+# oracle2.py REPO BASE REF ORDERORIG FINAL WREPLAY.json
+import subprocess, sys, json
+repo, base, ref, origf, final, wj = sys.argv[1:7]
+def git(*a): return subprocess.run(['git', '-C', repo] + list(a), capture_output=True, text=True).stdout
+orig = [l.split()[0] for l in open(origf) if l.strip()]
+out = json.load(open(wj))
+commits = git('rev-list', '--reverse', f'{base}..{ref}').split()
+ok = True
+def chk(c, msg):
+    global ok
+    print(('PASS ' if c else 'FAIL ') + msg); ok &= bool(c)
+chk([o['sha'] for o in out] == commits, f'{len(commits)} commits match wreplay.json, linear on base')
+chk(git('rev-parse', f'{ref}^{{tree}}') == git('rev-parse', f'{final}^{{tree}}'), 'final tree equals original tip tree')
+bad = []
+for o, c in zip(out, commits):
+    a = git('log', '-1', '--format=%an <%ae> %ad', '--date=raw', c)
+    b = git('log', '-1', '--format=%an <%ae> %ad', '--date=raw', orig[o['src'] - 1])
+    if a != b: bad.append(c)
+chk(not bad, f'author name/email/date equal the source patch for every commit ({len(bad)} bad)')
+mains = [o['src'] for o in out if o['kind'] == 'main']
+chk(sorted(mains) == list(range(1, len(orig) + 1)), 'each original patch has exactly one main commit')
+bad = []
+for o in out:
+    if o['kind'] == 'main':
+        body = lambda c: (lambda r: r[r.index('\n\n') + 2:])(git('cat-file', 'commit', c))
+        if body(o['sha']) != body(orig[o['src'] - 1]):
+            bad.append(o['sha'])
+chk(not bad, f'main commits keep the original message verbatim ({len(bad)} differ)')
+bad = []
+for o in out:
+    if o['kind'] == 'part':
+        m = git('log', '-1', '--format=%B', o['sha'])
+        if 'Signed-off-by' in m or 'Co-Authored-By' in m or m.count('Assisted-by: Claude:claude-opus-5-5') != 1:
+            bad.append(o['sha'])
+chk(not bad, f'part commits: one Assisted-by, no Signed-off-by/Co-Authored-By ({len(bad)} bad)')
+empty = [o['sha'] for o in out if git('rev-parse', o['sha'] + '^{tree}') == git('rev-parse', o['sha'] + '^^{tree}')]
+chk(not empty, f'no empty commits ({len(empty)})')
+seq = [o['sub'] for o in out]
+runs = []
+for i, s in enumerate(seq, 1):
+    if not runs or runs[-1][0] != s: runs.append([s, i, i])
+    else: runs[-1][2] = i
+chk(len(runs) == len(set(seq)) and [r[0] for r in runs] == sorted(set(seq)), 'subtopics contiguous and in order: ' +
+    ' '.join(f'S{s}:#{a}-{b}' for s, a, b in runs))
+print('ORACLE', 'PASS' if ok else 'FAIL')
diff --git a/scripts/sa-reorder/bin/oracle3.py b/scripts/sa-reorder/bin/oracle3.py
new file mode 100644 (file)
index 0000000..16bc2d0
--- /dev/null
@@ -0,0 +1,79 @@
+#!/usr/bin/python3 -I
+# oracle3.py REPO BASE REF ORDERORIG FINAL WPOST.json WPOSTSPEC RESIDUAL.diff [MAP.json]
+# The final tree is FINAL plus exactly RESIDUAL; authorship and messages
+# are the source patch's, except where the wpost spec says otherwise.
+# MAP.json (6.18): misc-next old number -> this lane's, for the message edits.
+import subprocess, sys, json, os
+repo, base, ref, origf, final, wj, specf, resf = sys.argv[1:9]
+mapf = sys.argv[9] if len(sys.argv) > 9 else None
+def git(*a): return subprocess.run(['git', '-C', repo] + list(a), capture_output=True, text=True).stdout
+orig = [l.split()[0] for l in open(origf) if l.strip()]
+out = json.load(open(wj))
+spec = {'SPECF': specf}
+exec(open(specf).read(), spec)
+commits = git('rev-list', '--reverse', f'{base}..{ref}').split()
+ok = True
+def chk(c, msg):
+    global ok
+    print(('PASS ' if c else 'FAIL ') + msg); ok &= bool(c)
+def body(c):
+    r = git('cat-file', 'commit', c); return r[r.index('\n\n') + 2:]
+def who(c): return git('log', '-1', '--format=%an <%ae> %ad', '--date=raw', c).strip()
+chk([o['sha'] for o in out] == commits, f'{len(commits)} commits match the wpost json, linear on base')
+res = git('diff', final, ref)
+chk(res == open(resf).read(), f'final tree = {final[:12]} + exactly {os.path.basename(resf)} '
+    f'({res.count(chr(10))} lines)')
+ZYGO = '%s <%s> %s' % (spec['ZYGO'][0], spec['ZYGO'][1], spec['NOW'])
+bad = []
+for o, c in zip(out, commits):
+    if o['kind'] == 'new' and not isinstance(o['src'], int) and o['src'] != int(o['src']):
+        want = None   # synthetic: the engine spec's author
+    else:
+        want = who(orig[o['src'] - 1])
+    if want is not None and who(c) != want:
+        bad.append(f"{c[:12]} {o['anchor']}")
+chk(not bad, f'author name/email/date equal the source patch for every old patch\'s commit ({bad})')
+news = [(o['sha'], who(o['sha']), o['subject']) for o in out if o['kind'] == 'new']
+for s, w, t in news:
+    print(f'     new commit {s[:12]} {w} {t}')
+mains = sorted(o['src'] for o in out if o['kind'] == 'main')
+chk(mains == list(range(1, len(orig) + 1)), 'each original patch has exactly one main commit')
+edits = spec.get('MSG_EDITS', {})
+bad = []; changed = []
+for o in out:
+    a = tuple(o['anchor'])
+    if o['kind'] != 'main' and a not in edits:
+        continue
+    want = body(orig[o['src'] - 1]) if o['kind'] == 'main' else body(o['eng_sha'])
+    for (old, new) in edits.get(a, []):
+        want = want.replace(old, new, 1)
+    if body(o['sha']) != want:
+        bad.append(o['sha'][:12])
+    if a in edits:
+        changed.append(f"{a}")
+chk(not bad, f'messages: original verbatim, or with exactly the spec\'s edits ({bad}); edited: {", ".join(changed)}')
+bad = []
+for o in out:
+    m = body(o['sha'])
+    if 'Signed-off-by' in m or 'Co-Authored-By' in m or 'cherry picked' in m:
+        bad.append(o['sha'][:12])
+    elif o['kind'] in ('part', 'new') and m.count('Assisted-by: Claude:claude-opus-5-5') != 1:
+        bad.append(o['sha'][:12])
+    elif tuple(o['anchor']) in edits and m.count('Assisted-by: Claude:claude-opus-5-5') > 1:
+        bad.append(o['sha'][:12])
+chk(not bad, f'no Signed-off-by/Co-Authored-By/cherry-pick line anywhere; one opus Assisted-by on '
+    f'parts and new commits, at most one on edited ones ({bad})')
+empty = [o['sha'] for o in out if git('rev-parse', o['sha'] + '^{tree}') == git('rev-parse', o['sha'] + '^^{tree}')]
+chk(not empty, f'no empty commits ({len(empty)})')
+seq = [o['sub'] for o in out]
+runs = []
+for i, s in enumerate(seq, 1):
+    if not runs or runs[-1][0] != s: runs.append([s, i, i])
+    else: runs[-1][2] = i
+chk(len(runs) == len(set(seq)) and [r[0] for r in runs] == sorted(set(seq)), 'subtopics contiguous and in order: ' +
+    ' '.join(f'S{s}:#{a}-{b}' for s, a, b in runs))
+pre = [o for o in out if o['sub'] < 6][-1]['sha']
+n = git('grep', '-c', 'stripe_meta', pre, '--', 'fs/btrfs').strip()
+print(f'     before the stripe_meta subtopic ({pre[:12]}): lines naming stripe_meta per file:\n       ' +
+      '\n       '.join(l.split(':', 1)[1] for l in n.splitlines()))
+print('ORACLE', 'PASS' if ok else 'FAIL')
diff --git a/scripts/sa-reorder/bin/presplit.py b/scripts/sa-reorder/bin/presplit.py
new file mode 100644 (file)
index 0000000..9855bc3
--- /dev/null
@@ -0,0 +1,129 @@
+#!/usr/bin/python3 -I
+# Build H': the original series with some patches split into consecutive
+# pieces (partition of each patch's own +/- lines) and some lines transferred
+# to a later patch.  Every H' tree at an unsplit patch equals the original
+# tree, except inside a transfer span.  Writes hprime.json:
+#   [{"sha":..., "old": n, "piece": name, "subject": ...}, ...]
+# Usage: presplit.py REPO BASE ORDERORIG SPECPY OUTJSON
+import subprocess, sys, os, re, json, tempfile
+sys.path.insert(0, os.path.dirname(__file__))
+from zmerge import edits
+repo, base, orderf, specf, outf = sys.argv[1:6]
+TMPD = os.environ.get('TMPD', '/tmp')
+env0 = dict(os.environ)
+def git(*a, inp=None, env=None, check=True):
+    r = subprocess.run(['git', '-C', repo] + list(a), input=inp, capture_output=True,
+                       text=True, env=env or env0)
+    if check and r.returncode != 0:
+        raise RuntimeError(f'git {a}: {r.stderr}')
+    return r
+def blob(rev, p):
+    x = git('show', f'{rev}:{p}', check=False)
+    return None if x.returncode else x.stdout.splitlines(True)
+def put_tree(tree, files):
+    idx = os.path.join(TMPD, 'ps.index'); ienv = dict(env0, GIT_INDEX_FILE=idx)
+    git('read-tree', tree, env=ienv)
+    for p, lines in files.items():
+        bl = git('hash-object', '-w', '--stdin', '--path', p, inp=''.join(lines)).stdout.strip()
+        git('update-index', '--add', '--cacheinfo', f'100644,{bl},{p}', env=ienv)
+    return git('write-tree', env=ienv).stdout.strip()
+def tree_of(x): return git('rev-parse', f'{x}^{{tree}}').stdout.strip()
+orig = [l.split()[0] for l in open(orderf) if l.strip()]
+N = len(orig)
+spec = {}
+exec(open(specf).read(), spec)
+transfers = spec.get('TRANSFERS', [])     # (from, to, path, exact line)
+splits = spec.get('SPLITS', {})           # old -> [(piece, kind, arg, msginfo)]
+ctx = dict(git=git, blob=blob, orig=orig, base=base, repo=repo)
+
+def adj_tree(k):
+    """tree of original patch k (0 = base) adjusted for transfers"""
+    rev = base if k == 0 else orig[k - 1]
+    t = tree_of(rev); files = {}
+    for (fr, to, p, line) in transfers:
+        if fr <= k < to:
+            b = files.get(p) or blob(rev, p)
+            idx = [i for i, l in enumerate(b) if l == line]
+            assert len(idx) == 1, (k, p, line, idx)
+            files[p] = b[:idx[0]] + b[idx[0] + 1:]
+    return put_tree(t, files) if files else t
+def changed(t1, t2):
+    r = git('diff-tree', '-r', '--name-only', t1, t2)
+    return [l for l in r.stdout.splitlines() if l]
+def apply_edits(b, eds):
+    out = []; q0 = 0
+    for (a, bb, nl) in sorted(eds, key=lambda e: (e[0], e[1])):
+        out.extend(b[q0:a]); out.extend(nl); q0 = bb
+    out.extend(b[q0:]); return out
+
+def msg_of(sha): return git('log', '-1', '--format=%B', sha).stdout
+def auth_env(sha):
+    an, ae, ad = git('log', '-1', '--format=%an%x00%ae%x00%ad', '--date=raw', sha).stdout.strip().split('\0')
+    return dict(env0, GIT_AUTHOR_NAME=an, GIT_AUTHOR_EMAIL=ae, GIT_AUTHOR_DATE=ad)
+
+out = []; parent = base; prevtree = adj_tree(0)
+with tempfile.TemporaryDirectory() as td:
+    for k in range(1, N + 1):
+        sha = orig[k - 1]; t = adj_tree(k); subj = msg_of(sha).splitlines()[0]
+        if k not in splits:
+            c = git('commit-tree', t, '-p', parent, inp=msg_of(sha), env=auth_env(sha)).stdout.strip()
+            out.append({'sha': c, 'old': k, 'piece': '', 'subject': subj})
+            parent, prevtree = c, t; continue
+        pieces = splits[k]            # list of dicts: name, select(path, edit, ctx) -> piece index per line
+        npieces = len(pieces) + 1     # 0 = main
+        # per file: list of edits with per-line piece owner, and deletion owner
+        fed = {}
+        for p in changed(prevtree, t):
+            b = blob(prevtree, p) or []; tt = blob(t, p) or []
+            eds = edits(b, tt, td)
+            lst = []
+            for (a, bb, nl) in eds:
+                own = [0] * len(nl)
+                for j, pc in enumerate(pieces, 1):
+                    sel = pc['select'](p, (a, bb, nl), ctx)
+                    if sel is True:
+                        own = [j] * len(nl); dele = j
+                    elif sel:
+                        for i in sel: own[i] = j
+                if nl and min(own) > 0:
+                    dele = min(own)
+                elif not nl:
+                    dele = 0
+                    for j, pc in enumerate(pieces, 1):
+                        if pc['select'](p, (a, bb, nl), ctx) is True: dele = j
+                else:
+                    dele = 0
+                lst.append((a, bb, nl, own, dele))
+            fed[p] = (b, lst)
+        pend = False; pc0name = 'S1'
+        for j in range(npieces):
+            files = {}
+            for p, (b, lst) in fed.items():
+                eds = []
+                for (a, bb, nl, own, dele) in lst:
+                    if dele > j:
+                        if any(o <= j for o in own):
+                            eds.append((a, a, [l for l, o in zip(nl, own) if o <= j]))
+                        continue
+                    eds.append((a, bb, [l for l, o in zip(nl, own) if o <= j]))
+                files[p] = apply_edits(b, eds)
+            tj = put_tree(prevtree, files) if j < npieces - 1 else t
+            if j == npieces - 1:
+                assert put_tree(prevtree, files) == t, f'piece reassembly mismatch at {k}'
+            if j == 0 or pend:
+                msg = msg_of(sha); name = pc0name if j == 0 else pieces[j - 1]['name']
+            else:
+                pc = pieces[j - 1]; name = pc['name']
+                msg = (f"{subj} ({pc['tag']} part)\n\n"
+                       f"Split from \"{subj}\" for the subtopic reorder: {pc['why']}\n\n"
+                       f"Assisted-by: Claude:claude-opus-5-5\n")
+            if git('rev-parse', f'{parent}^{{tree}}').stdout.strip() == tj:
+                print(f'old{k} piece {name}: empty, skipped', file=sys.stderr)
+                pend = pend or j == 0; continue
+            pend = False
+            c = git('commit-tree', tj, '-p', parent, inp=msg, env=auth_env(sha)).stdout.strip()
+            out.append({'sha': c, 'old': k, 'piece': name, 'subject': msg.splitlines()[0]})
+            parent = c
+        prevtree = t
+json.dump(out, open(outf, 'w'), indent=1)
+print('H\' tip', parent, 'tree', tree_of(parent), file=sys.stderr)
diff --git a/scripts/sa-reorder/bin/replay.py b/scripts/sa-reorder/bin/replay.py
new file mode 100644 (file)
index 0000000..2ef0481
--- /dev/null
@@ -0,0 +1,66 @@
+#!/usr/bin/python3 -I
+# Checkout-free replay of series commits in a new order.
+# replay.py REPO BASE ORDERFILE OUTREF LOG [--stop-on-conflict]
+# ORDERFILE lines: "<sha> <label>"; '#' comments.  Merges by merge-tree with
+# --merge-base=<sha>^; conflicted files are retried with the zealous merge.
+import subprocess, sys, os, re, json
+sys.path.insert(0, os.path.dirname(__file__))
+from zmerge import zmerge
+repo, base, orderf, outref, logf = sys.argv[1:6]
+env0 = dict(os.environ)
+def git(*a, inp=None, env=None, check=True):
+    r = subprocess.run(['git', '-C', repo] + list(a), input=inp, capture_output=True,
+                       text=True, env=env or env0)
+    if check and r.returncode not in (0,):
+        raise RuntimeError(f'git {a}: {r.stderr}')
+    return r
+log = open(logf, 'a')
+def L(*a):
+    print(*a, file=log, flush=True); print(*a, flush=True)
+order = [l.split(None, 1) for l in open(orderf) if l.strip() and not l.startswith('#')]
+acc = git('rev-parse', base).stdout.strip()
+for n, (sha, label) in enumerate(order, 1):
+    label = label.strip()
+    sha = git('rev-parse', sha).stdout.strip()
+    r = git('merge-tree', '--write-tree', f'--merge-base={sha}^', acc, sha, check=False)
+    lines = r.stdout.splitlines()
+    tree = lines[0].strip()
+    resolved = []
+    if r.returncode == 1:
+        paths = sorted({m.group(1) for l in lines[1:]
+                        for m in [re.match(r'^[0-7]{6} [0-9a-f]{40} [123]\t(.*)$', l)] if m})
+        idx = os.path.join(os.environ.get('TMPD', '/tmp'), 'replay.index')
+        ienv = dict(env0, GIT_INDEX_FILE=idx)
+        git('read-tree', tree, env=ienv)
+        for p in paths:
+            def blob(rev):
+                x = git('show', f'{rev}:{p}', check=False)
+                return None if x.returncode else x.stdout.splitlines(True)
+            b, o, t = blob(f'{sha}^'), blob(acc), blob(sha)
+            if b is None or o is None or t is None:
+                L(f'STOP {n} {label}: add/delete conflict in {p}')
+                sys.exit(2)
+            res, conf, _ = zmerge(b, o, t, blob(os.environ["FINAL"]))
+            if res is None:
+                L(f'STOP {n} {label}: overlapping edits in {p}')
+                for (ob, tb) in conf[:20]:
+                    L(f'  base[{ob[0]+1},{ob[1]}) ours->{len(ob[2])} lines | base[{tb[0]+1},{tb[1]}) theirs->{len(tb[2])} lines')
+                json.dump({'n': n, 'sha': sha, 'acc': acc, 'path': p,
+                           'conf': [[list(c[0][:2]), c[0][2], list(c[1][:2]), c[1][2]] for c in conf]},
+                          open(os.path.join(os.environ.get('TMPD', '/tmp'), 'stop.json'), 'w'), indent=1)
+                git('update-ref', outref, acc)
+                sys.exit(1)
+            bl = git('hash-object', '-w', '--stdin', '--path', p, inp=''.join(res)).stdout.strip()
+            mode = '100644'
+            git('update-index', '--add', '--cacheinfo', f'{mode},{bl},{p}', env=ienv)
+            resolved.append(p)
+        tree = git('write-tree', env=ienv).stdout.strip()
+    elif r.returncode != 0:
+        raise RuntimeError(r.stderr)
+    msg = git('log', '-1', '--format=%B', sha).stdout
+    an, ae, ad = git('log', '-1', '--format=%an%x00%ae%x00%ad', '--date=raw', sha).stdout.strip().split('\0')
+    cenv = dict(env0, GIT_AUTHOR_NAME=an, GIT_AUTHOR_EMAIL=ae, GIT_AUTHOR_DATE=ad)
+    acc = git('commit-tree', tree, '-p', acc, inp=msg, env=cenv).stdout.strip()
+    L(f'OK {n} {label} {sha[:12]} -> {acc[:12]}' + (f' ZMERGE {",".join(resolved)}' if resolved else ''))
+git('update-ref', outref, acc)
+L(f'DONE {acc}')
diff --git a/scripts/sa-reorder/bin/replay2.py b/scripts/sa-reorder/bin/replay2.py
new file mode 100644 (file)
index 0000000..7feae83
--- /dev/null
@@ -0,0 +1,154 @@
+#!/usr/bin/python3 -I
+# Replay with hunk deferral.  replay2.py REPO BASE ORDERFILE OUTREF LOG
+# A hunk of P that edits lines which only a not-yet-replayed series commit A
+# provides is cut out of P and re-applied as a residual commit right after A.
+import subprocess, sys, os, re, json
+sys.path.insert(0, os.path.dirname(__file__))
+from zmerge import zmerge, edits
+import tempfile
+repo, base, orderf, outref, logf = sys.argv[1:6]
+TMPD = os.environ.get('TMPD', '/tmp')
+FINAL = os.environ['FINAL']
+env0 = dict(os.environ)
+def git(*a, inp=None, env=None, check=True):
+    r = subprocess.run(['git', '-C', repo] + list(a), input=inp, capture_output=True,
+                       text=True, env=env or env0)
+    if check and r.returncode != 0:
+        raise RuntimeError(f'git {a}: {r.stderr}')
+    return r
+log = open(logf, 'w')
+def L(*a):
+    print(*a, file=log, flush=True); print(*a, flush=True)
+def rp(x): return git('rev-parse', x).stdout.strip()
+base = rp(base)
+series = git('rev-list', '--reverse', f'{base}..{rp(sys.argv[3]) if False else outref}', check=False)
+order = []
+for l in open(orderf):
+    if l.strip() and not l.startswith('#'):
+        s, lab = l.split(None, 1); order.append(('c', rp(s), lab.strip()))
+pos = {it[1]: i for i, it in enumerate(order)}
+applied = set()
+pending = {}   # anchor sha -> list of residual items
+deferred_to = {}  # sha whose residual is pending -> its anchor
+def blob(rev, p):
+    x = git('show', f'{rev}:{p}', check=False)
+    return None if x.returncode else x.stdout.splitlines(True)
+def put_tree(tree, files):
+    idx = os.path.join(TMPD, 'r2.index'); ienv = dict(env0, GIT_INDEX_FILE=idx)
+    git('read-tree', tree, env=ienv)
+    for p, lines in files.items():
+        bl = git('hash-object', '-w', '--stdin', '--path', p, inp=''.join(lines)).stdout.strip()
+        git('update-index', '--add', '--cacheinfo', f'100644,{bl},{p}', env=ienv)
+    return git('write-tree', env=ienv).stdout.strip()
+def history_owners(rev, p, lo, hi):
+    r = git('log', '-s', '--format=%H', f'-L{lo},{hi}:{p}', f'{base}..{rev}', check=False)
+    return {l.strip() for l in r.stdout.splitlines() if l.strip() in pos}
+def blame_owners(rev, p, lo, hi):
+    # 1-based inclusive line range in rev; series commits owning them
+    r = git('blame', '--porcelain', '-L', f'{lo},{hi}', f'{base}..{rev}', '--', p, check=False)
+    own = set()
+    for l in r.stdout.splitlines():
+        m = re.match(r'^([0-9a-f]{40}) \d+ \d+', l)
+        if m and m.group(1) in pos:
+            own.add(m.group(1))
+    return own
+acc = base
+q = list(order)
+n = 0
+while q:
+    kind, sha, label = q.pop(0)[:3] if True else None
+    it = None
+    n += 1
+    if kind == 'c':
+        mb, theirs, srcsha = f'{sha}^', sha, sha
+    else:
+        mb, theirs = sha  # residual: (rbase, rtip)
+        srcsha = theirs
+    r = git('merge-tree', '--write-tree', f'--merge-base={mb}', acc, theirs, check=False)
+    lines = r.stdout.splitlines(); tree = lines[0].strip()
+    notes = []
+    defer_files = {}
+    if r.returncode == 1:
+        paths = sorted({m.group(1) for l in lines[1:]
+                        for m in [re.match(r'^[0-7]{6} [0-9a-f]{40} [123]\t(.*)$', l)] if m})
+        files = {}; anchors = set(); stop = None; deps_x = set()
+        for p in paths:
+            b, o, t = blob(mb, p), blob(acc, p), blob(theirs, p)
+            if b is None or o is None or t is None:
+                stop = f'add/delete conflict in {p}'; break
+            res, conf, et = zmerge(b, o, t, blob(FINAL, p))
+            if res is not None:
+                files[p] = res; notes.append(f'zmerge {p}'); continue
+            # decide deferral per conflicting theirs-edit
+            bad = set()
+            for (oe, te) in conf:
+                c, d = te[0], te[1]
+                lo, hi = (c + 1, d) if d > c else (max(c, 1), c + 1)
+                own = blame_owners(mb, p, lo, hi)
+                a0, b0 = oe[0], oe[1]
+                if b0 > a0:
+                    own |= blame_owners(mb, p, a0 + 1, b0)
+                later = {x for x in own if x not in applied and pos.get(x, -1) > pos[srcsha]}
+                later |= {deferred_to[x] for x in own if x in deferred_to}
+                deps_x |= {x for x in own if x in deferred_to}
+                done = {x for x in own if x in applied}
+                if not later:
+                    own2 = history_owners(mb, p, lo, max(hi, lo))
+                    later = {x for x in own2 if x not in applied and pos.get(x, -1) > pos[srcsha]}
+                    later |= {deferred_to[x] for x in own2 if x in deferred_to}
+                    deps_x |= {x for x in own2 if x in deferred_to}
+                    if later:
+                        notes.append(f'history-owner {p}')
+                if not later:
+                    stop = (f'overlap in {p} base[{c+1},{d}) owners '
+                            f'{[order[pos[x]][2] for x in own]} none later'); break
+                anchors |= later; bad.add((c, d, tuple(te[2])))
+            if stop: break
+            keep = [e for e in et if (e[0], e[1], tuple(e[2])) not in bad]
+            tprime = []; q0 = 0
+            for (a, bb, nl) in keep:
+                tprime.extend(b[q0:a]); tprime.extend(nl); q0 = bb
+            tprime.extend(b[q0:])
+            res, conf2, _ = zmerge(b, o, tprime, blob(FINAL, p))
+            if res is None:
+                stop = f'still overlapping after deferral in {p}'; break
+            files[p] = res; defer_files[p] = tprime
+            notes.append(f'defer {p} {len(bad)} edits')
+        if stop:
+            L(f'STOP {n} {label}: {stop}')
+            git('update-ref', outref, acc); sys.exit(1)
+        tree = put_tree(tree, files)
+        if defer_files:
+            rbase = put_tree(git('rev-parse', f'{theirs}^{{tree}}').stdout.strip(), defer_files)
+            rbase_c = git('commit-tree', rbase, '-p', mb, inp='rbase\n').stdout.strip()
+            anchor = max(anchors, key=lambda x: pos[x])
+            deferred_to[srcsha] = anchor
+            lab0 = label.split(' RESIDUAL')[0]
+            item = ('r', (rbase_c, srcsha), f'{lab0} RESIDUAL(after {order[pos[anchor]][2]})')
+            if anchor not in applied:
+                pending.setdefault(anchor, []).append(item)
+            else:
+                # anchor already replayed: go after the queued residuals that
+                # own the lines (they sit at the front of the queue)
+                ix = max([i for i, x in enumerate(q) if x[0] == 'r' and x[1][1] in deps_x] or [-1])
+                q.insert(ix + 1, item)
+    elif r.returncode != 0:
+        raise RuntimeError(r.stderr)
+    src = sha if kind == 'c' else sha[1]
+    msg = git('log', '-1', '--format=%B', src).stdout
+    if kind == 'r':
+        subj = msg.splitlines()[0]
+        msg = f'fixup! {subj}\n\nResidual of the reorder: the part of this patch that edits code\nintroduced by a later-placed patch.\n'
+    an, ae, ad = git('log', '-1', '--format=%an%x00%ae%x00%ad', '--date=raw', src).stdout.strip().split('\0')
+    cenv = dict(env0, GIT_AUTHOR_NAME=an, GIT_AUTHOR_EMAIL=ae, GIT_AUTHOR_DATE=ad)
+    acc = git('commit-tree', tree, '-p', acc, inp=msg, env=cenv).stdout.strip()
+    L(f'OK {n} {label} -> {acc[:12]}' + (' ' + '; '.join(notes) if notes else ''))
+    if kind == 'r' and not (r.returncode == 1 and defer_files):
+        deferred_to.pop(srcsha, None)
+    if kind == 'c':
+        applied.add(sha)
+        if sha in pending:
+            q[0:0] = pending.pop(sha)
+git('update-ref', outref, acc)
+L(f'DONE {acc} tree {rp(acc + "^{tree}")}')
+if pending: L(f'UNPLACED residuals: {pending}')
diff --git a/scripts/sa-reorder/bin/replay3.py b/scripts/sa-reorder/bin/replay3.py
new file mode 100644 (file)
index 0000000..f45f536
--- /dev/null
@@ -0,0 +1,160 @@
+#!/usr/bin/python3 -I
+# Replay with hunk deferral.  replay3.py REPO BASE ORDERFILE OUTREF LOG
+# env: TMPD scratch dir, FINAL oracle commit (orders same-point insertions).
+# A hunk of P that edits lines which only a not-yet-replayed series commit A
+# provides is cut out of P and re-applied as a residual commit right after A.
+import subprocess, sys, os, re, json
+sys.path.insert(0, os.path.dirname(__file__))
+from zmerge import zmerge
+repo, base, orderf, outref, logf = sys.argv[1:6]
+TMPD = os.environ.get('TMPD', '/tmp'); FINAL = os.environ['FINAL']
+STOPAT = os.environ.get('STOPAT')
+env0 = dict(os.environ)
+def git(*a, inp=None, env=None, check=True):
+    r = subprocess.run(['git', '-C', repo] + list(a), input=inp, capture_output=True,
+                       text=True, env=env or env0)
+    if check and r.returncode != 0:
+        raise RuntimeError(f'git {a}: {r.stderr}')
+    return r
+log = open(logf, 'w')
+def L(*a):
+    print(*a, file=log, flush=True); print(*a, flush=True)
+def rp(x): return git('rev-parse', x).stdout.strip()
+base = rp(base)
+order = []
+for l in open(orderf):
+    if l.strip() and not l.startswith('#'):
+        s, lab = l.split(None, 1); order.append(('c', rp(s), lab.strip()))
+pos = {it[1]: i for i, it in enumerate(order)}
+lab = {it[1]: it[2] for it in order}
+applied = set(); pending = {}; deferred_to = {}; nres = {}
+def blob(rev, p):
+    x = git('show', f'{rev}:{p}', check=False)
+    return None if x.returncode else x.stdout.splitlines(True)
+def put_tree(tree, files):
+    idx = os.path.join(TMPD, 'r3.index'); ienv = dict(env0, GIT_INDEX_FILE=idx)
+    git('read-tree', tree, env=ienv)
+    for p, lines in files.items():
+        bl = git('hash-object', '-w', '--stdin', '--path', p, inp=''.join(lines)).stdout.strip()
+        git('update-index', '--add', '--cacheinfo', f'100644,{bl},{p}', env=ienv)
+    return git('write-tree', env=ienv).stdout.strip()
+def owners(rev, p, lo, hi, hist=False):
+    if hist:
+        r = git('log', '-s', '--format=%H', f'-L{lo},{hi}:{p}', f'{base}..{rev}', check=False)
+        return {l.strip() for l in r.stdout.splitlines() if l.strip() in pos}
+    r = git('blame', '--porcelain', '-L', f'{lo},{hi}', f'{base}..{rev}', '--', p, check=False)
+    return {m.group(1) for l in r.stdout.splitlines()
+            for m in [re.match(r'^([0-9a-f]{40}) \d+ \d+', l)] if m and m.group(1) in pos}
+def apply_edits(b, eds):
+    out = []; q0 = 0
+    for (a, bb, nl) in sorted(eds, key=lambda e: (e[0], e[1])):
+        out.extend(b[q0:a]); out.extend(nl); q0 = bb
+    out.extend(b[q0:]); return out
+acc = base
+q = list(order); n = 0; reslog = []
+while q:
+    item = q.pop(0); n += 1
+    kind, label = item[0], item[2]
+    if kind == 'c':
+        mb, theirs, src = f'{item[1]}^', item[1], item[1]
+    else:
+        mb, theirs, src = item[1]
+    r = git('merge-tree', '--write-tree', f'--merge-base={mb}', acc, theirs, check=False)
+    lines = r.stdout.splitlines(); tree = lines[0].strip()
+    notes = []; groups = {}
+    if r.returncode == 1:
+        paths = sorted({m.group(1) for l in lines[1:]
+                        for m in [re.match(r'^[0-7]{6} [0-9a-f]{40} [123]\t(.*)$', l)] if m})
+        files = {}; kept = {}; stop = None; deps = set(); fb = {}
+        for p in paths:
+            b, o, t = blob(mb, p), blob(acc, p), blob(theirs, p)
+            if b is None or o is None or t is None:
+                stop = f'add/delete conflict in {p}'; break
+            fin = blob(FINAL, p); fb[p] = b
+            res, conf, et = zmerge(b, o, t, fin)
+            if res is not None:
+                files[p] = res; notes.append(f'zmerge {p}'); continue
+            bad = {}
+            for (oe, te) in conf:
+                c, d = te[0], te[1]
+                lo, hi = (c + 1, d) if d > c else (max(c, 1), c + 1)
+                own = owners(mb, p, lo, hi)
+                if oe[1] > oe[0]:
+                    own |= owners(mb, p, oe[0] + 1, oe[1])
+                def later_of(own):
+                    lt = {x for x in own if x not in applied and pos[x] > pos[src]}
+                    lt |= {deferred_to[x] for x in own if x in deferred_to}
+                    return lt
+                lt = later_of(own)
+                if not lt:
+                    own = owners(mb, p, lo, max(hi, lo), hist=True); lt = later_of(own)
+                    if lt: notes.append(f'hist {p}')
+                if not lt:
+                    stop = (f'overlap in {p} base[{c+1},{d}) owners '
+                            f'{sorted(lab[x] for x in own)} none later'); break
+                deps |= {x for x in own if x in deferred_to}
+                tgt = max(lt, key=lambda x: pos[x])
+                key = (c, d, tuple(te[2]))
+                if key not in bad or pos[tgt] > pos[bad[key]]:
+                    bad[key] = tgt
+            if stop: break
+            keepe = [e for e in et if (e[0], e[1], tuple(e[2])) not in bad]
+            tprime = apply_edits(b, keepe)
+            res, conf2, _ = zmerge(b, o, tprime, fin)
+            if res is None:
+                stop = f'still overlapping after deferral in {p}'; break
+            files[p] = res; kept[p] = keepe
+            for (c, d, tl), tgt in bad.items():
+                groups.setdefault(tgt, []).append((p, (c, d, list(tl))))
+            notes.append(f'defer {p} {len(bad)}')
+        if stop or (STOPAT and lab.get(src, '').endswith(STOPAT)):
+            L(f'STOP {n} {label}: {stop}')
+            json.dump(reslog, open(os.path.join(TMPD, 'reslog.json'), 'w'), indent=1)
+            git('update-ref', outref, acc); sys.exit(1)
+        tree = put_tree(tree, files)
+        if groups:
+            ttree = git('rev-parse', f'{theirs}^{{tree}}').stdout.strip()
+            state = {p: list(kept[p]) for p in kept}
+            prev = git('commit-tree', put_tree(ttree, {p: apply_edits(fb[p], state[p]) for p in state}),
+                       '-p', mb, inp='rbase\n').stdout.strip()
+            for tgt in sorted(groups, key=lambda x: pos[x]):
+                for (p, e) in groups[tgt]:
+                    state[p].append(tuple(e))
+                tip = git('commit-tree', put_tree(ttree, {p: apply_edits(fb[p], state[p]) for p in state}),
+                          '-p', prev, inp='rtip\n').stdout.strip()
+                lab0 = label.split(' RESIDUAL')[0]
+                ritem = ('r', (prev, tip, src), f'{lab0} RESIDUAL(after {lab[tgt]})')
+                reslog.append({'src': lab0, 'after': lab[tgt],
+                               'files': sorted({p for (p, e) in groups[tgt]}),
+                               'edits': len(groups[tgt]), 'prev': prev, 'tip': tip})
+                nres[src] = nres.get(src, 0) + 1
+                deferred_to[src] = tgt if src not in deferred_to or pos[tgt] > pos[deferred_to[src]] else deferred_to[src]
+                if tgt not in applied:
+                    pending.setdefault(tgt, []).append(ritem)
+                else:
+                    ix = max([i for i, x in enumerate(q) if x[0] == 'r' and x[1][2] in deps] or [-1])
+                    q.insert(ix + 1, ritem)
+                prev = tip
+    elif r.returncode != 0:
+        raise RuntimeError(r.stderr)
+    msg = git('log', '-1', '--format=%B', src).stdout
+    if kind == 'r':
+        subj = msg.splitlines()[0]
+        msg = (f'fixup! {subj}\n\nReorder residual: the part of "{subj}"\n'
+               f'that edits code a later-placed patch introduces.\n')
+    an, ae, ad = git('log', '-1', '--format=%an%x00%ae%x00%ad', '--date=raw', src).stdout.strip().split('\0')
+    cenv = dict(env0, GIT_AUTHOR_NAME=an, GIT_AUTHOR_EMAIL=ae, GIT_AUTHOR_DATE=ad)
+    acc = git('commit-tree', tree, '-p', acc, inp=msg, env=cenv).stdout.strip()
+    L(f'OK {n} {label} -> {acc[:12]}' + (' ' + '; '.join(notes) if notes else ''))
+    if kind == 'r':
+        nres[src] -= 1
+        if nres[src] == 0:
+            deferred_to.pop(src, None)
+    else:
+        applied.add(item[1])
+        if item[1] in pending:
+            q[0:0] = pending.pop(item[1])
+json.dump(reslog, open(os.path.join(TMPD, 'reslog.json'), 'w'), indent=1)
+git('update-ref', outref, acc)
+L(f'DONE {acc} tree {rp(acc + "^{tree}")} final {rp(FINAL + "^{tree}")}')
+if pending: L(f'UNPLACED residuals: {pending}')
diff --git a/scripts/sa-reorder/bin/replay4.py b/scripts/sa-reorder/bin/replay4.py
new file mode 100644 (file)
index 0000000..d951cbd
--- /dev/null
@@ -0,0 +1,217 @@
+#!/usr/bin/python3 -I
+# Replay with hunk deferral.  replay3.py REPO BASE ORDERFILE OUTREF LOG
+# env: TMPD scratch dir, FINAL oracle commit (orders same-point insertions).
+# A hunk of P that edits lines which only a not-yet-replayed series commit A
+# provides is cut out of P and re-applied as a residual commit right after A.
+import subprocess, sys, os, re, json
+sys.path.insert(0, os.path.dirname(__file__))
+from zmerge import zmerge
+repo, base, orderf, outref, logf = sys.argv[1:6]
+TMPD = os.environ.get('TMPD', '/tmp'); FINAL = os.environ['FINAL']
+STOPAT = os.environ.get('STOPAT')
+env0 = dict(os.environ)
+def git(*a, inp=None, env=None, check=True):
+    r = subprocess.run(['git', '-C', repo] + list(a), input=inp, capture_output=True,
+                       text=True, env=env or env0)
+    if check and r.returncode != 0:
+        raise RuntimeError(f'git {a}: {r.stderr}')
+    return r
+log = open(logf, 'w')
+def L(*a):
+    print(*a, file=log, flush=True); print(*a, flush=True)
+def rp(x): return git('rev-parse', x).stdout.strip()
+base = rp(base)
+order = []
+for l in open(orderf):
+    if l.strip() and not l.startswith('#'):
+        s, lab = l.split(None, 1); order.append(('c', rp(s), lab.strip()))
+pos = {it[1]: i for i, it in enumerate(order)}
+lab = {it[1]: it[2] for it in order}
+applied = set(); pending = {}; deferred_to = {}; nres = {}
+def blob(rev, p):
+    x = git('show', f'{rev}:{p}', check=False)
+    return None if x.returncode else x.stdout.splitlines(True)
+def put_tree(tree, files):
+    idx = os.path.join(TMPD, 'r3.index'); ienv = dict(env0, GIT_INDEX_FILE=idx)
+    git('read-tree', tree, env=ienv)
+    for p, lines in files.items():
+        bl = git('hash-object', '-w', '--stdin', '--path', p, inp=''.join(lines)).stdout.strip()
+        git('update-index', '--add', '--cacheinfo', f'100644,{bl},{p}', env=ienv)
+    return git('write-tree', env=ienv).stdout.strip()
+def owners(rev, p, lo, hi, hist=False):
+    if hist:
+        r = git('log', '-s', '--format=%H', f'-L{lo},{hi}:{p}', f'{base}..{rev}', check=False)
+        return {l.strip() for l in r.stdout.splitlines() if l.strip() in pos}
+    r = git('blame', '--porcelain', '-L', f'{lo},{hi}', f'{base}..{rev}', '--', p, check=False)
+    return {m.group(1) for l in r.stdout.splitlines()
+            for m in [re.match(r'^([0-9a-f]{40}) \d+ \d+', l)] if m and m.group(1) in pos}
+def patchctx(b, o, t):
+    """apply base->theirs hunk by hunk as context diffs (fuzz <= 2, any
+    offset, hunks independently placed) to ours"""
+    import tempfile
+    with tempfile.TemporaryDirectory(dir=TMPD) as td:
+        pb, pt, po, out = (os.path.join(td, x) for x in ('b', 't', 'o', 'out'))
+        open(pb, 'w').write(''.join(b)); open(pt, 'w').write(''.join(t))
+        d = subprocess.run(['diff', '-U3', pb, pt], capture_output=True, text=True).stdout
+        dl = d.splitlines(True)
+        hdr = dl[:2]; hunks = []
+        for l in dl[2:]:
+            if l.startswith('@@'): hunks.append([l])
+            else: hunks[-1].append(l)
+        cur = ''.join(o); fzmax = 0; msgs = []
+        for h in hunks:
+            open(po, 'w').write(cur)
+            for fz in (0, 1, 2):
+                r = subprocess.run(['patch', '--no-backup-if-mismatch', '-N', f'-F{fz}', '-o', out, po],
+                                   input=''.join(hdr + h), capture_output=True, text=True)
+                if r.returncode == 0:
+                    break
+            else:
+                return None
+            fzmax = max(fzmax, fz)
+            msgs += [l.strip() for l in r.stdout.splitlines() if 'Hunk' in l]
+            cur = open(out).read()
+        PCLOG.append((fzmax, ' / '.join(msgs) or 'exact'))
+        return cur.splitlines(True)
+def apply_edits(b, eds):
+    out = []; q0 = 0
+    for (a, bb, nl) in sorted(eds, key=lambda e: (e[0], e[1])):
+        out.extend(b[q0:a]); out.extend(nl); q0 = bb
+    out.extend(b[q0:]); return out
+acc = base
+TAG = {1: 'base', 2: 'allow_rmw', 3: 'reclaim', 4: 'fsync', 5: 'stripe_meta', 6: 'debug'}
+rcount = {}
+PCLOG = []
+q = list(order); n = 0; reslog = []
+while q:
+    item = q.pop(0); n += 1
+    kind, label = item[0], item[2]
+    if kind == 'c':
+        mb, theirs, src = f'{item[1]}^', item[1], item[1]
+    else:
+        mb, theirs, src = item[1]
+    r = git('merge-tree', '--write-tree', f'--merge-base={mb}', acc, theirs, check=False)
+    lines = r.stdout.splitlines(); tree = lines[0].strip()
+    notes = []; groups = {}
+    if r.returncode == 1:
+        paths = sorted({m.group(1) for l in lines[1:]
+                        for m in [re.match(r'^[0-7]{6} [0-9a-f]{40} [123]\t(.*)$', l)] if m})
+        files = {}; kept = {}; stop = None; deps = set(); fb = {}
+        for p in paths:
+            b, o, t = blob(mb, p), blob(acc, p), blob(theirs, p)
+            if b is None or o is None or t is None:
+                stop = f'add/delete conflict in {p}'; break
+            fin = blob(FINAL, p); fb[p] = b
+            res, conf, et = zmerge(b, o, t, fin)
+            if res is not None:
+                files[p] = res; notes.append(f'zmerge {p}'); continue
+            pc = patchctx(b, o, t)
+            if pc is not None:
+                files[p] = pc; notes.append(f'patchctx F{PCLOG[-1][0]} {p} [{PCLOG[-1][1]}]'); continue
+            bad = {}
+            for (oe, te) in conf:
+                c, d = te[0], te[1]
+                lo, hi = (c + 1, d) if d > c else (max(c, 1), c + 1)
+                own = owners(mb, p, lo, hi)
+                if oe[1] > oe[0]:
+                    own |= owners(mb, p, oe[0] + 1, oe[1])
+                def later_of(own):
+                    lt = {x for x in own if x not in applied and pos[x] > pos[src]}
+                    lt |= {deferred_to[x] for x in own if x in deferred_to}
+                    return lt
+                lt = later_of(own)
+                if not lt:
+                    own = owners(mb, p, lo, max(hi, lo), hist=True); lt = later_of(own)
+                    if lt: notes.append(f'hist {p}')
+                if not lt:
+                    stop = (f'overlap in {p} base[{c+1},{d}) owners '
+                            f'{sorted(lab[x] for x in own)} none later'); break
+                deps |= {x for x in own if x in deferred_to}
+                tgt = max(lt, key=lambda x: pos[x])
+                key = (c, d, tuple(te[2]))
+                if key not in bad or pos[tgt] > pos[bad[key]]:
+                    bad[key] = tgt
+            if stop: break
+            # defer whole hunks: an edit within 3 lines of a deferred edit
+            # goes with it, so a hunk is never torn between subtopics
+            ets = sorted(et, key=lambda e: (e[0], e[1]))
+            clusters = []
+            for e in ets:
+                if clusters and e[0] - clusters[-1][-1][1] <= 3:
+                    clusters[-1].append(e)
+                else:
+                    clusters.append([e])
+            for cl in clusters:
+                ks = [(e[0], e[1], tuple(e[2])) for e in cl]
+                tg = [bad[k] for k in ks if k in bad]
+                if tg:
+                    t0 = max(tg, key=lambda x: pos[x])
+                    for k in ks:
+                        bad[k] = t0
+            keepe = [e for e in et if (e[0], e[1], tuple(e[2])) not in bad]
+            tprime = apply_edits(b, keepe)
+            res, conf2, _ = zmerge(b, o, tprime, fin)
+            if res is None:
+                stop = f'still overlapping after deferral in {p}'; break
+            files[p] = res; kept[p] = keepe
+            for (c, d, tl), tgt in bad.items():
+                groups.setdefault(tgt, []).append((p, (c, d, list(tl))))
+            notes.append(f'defer {p} {len(bad)}')
+        if stop or (STOPAT and lab.get(src, '').endswith(STOPAT)):
+            L(f'STOP {n} {label}: {stop}')
+            json.dump(reslog, open(os.path.join(TMPD, 'reslog.json'), 'w'), indent=1)
+            git('update-ref', outref, acc); sys.exit(1)
+        tree = put_tree(tree, files)
+        if groups:
+            ttree = git('rev-parse', f'{theirs}^{{tree}}').stdout.strip()
+            state = {p: list(kept[p]) for p in kept}
+            prev = git('commit-tree', put_tree(ttree, {p: apply_edits(fb[p], state[p]) for p in state}),
+                       '-p', mb, inp='rbase\n').stdout.strip()
+            for tgt in sorted(groups, key=lambda x: pos[x]):
+                for (p, e) in groups[tgt]:
+                    state[p].append(tuple(e))
+                tip = git('commit-tree', put_tree(ttree, {p: apply_edits(fb[p], state[p]) for p in state}),
+                          '-p', prev, inp='rtip\n').stdout.strip()
+                lab0 = label.split(' RESIDUAL')[0]
+                ritem = ('r', (prev, tip, src), f'{lab0} RESIDUAL(after {lab[tgt]})')
+                reslog.append({'src': lab0, 'after': lab[tgt],
+                               'files': sorted({p for (p, e) in groups[tgt]}),
+                               'edits': len(groups[tgt]), 'prev': prev, 'tip': tip})
+                nres[src] = nres.get(src, 0) + 1
+                deferred_to[src] = tgt if src not in deferred_to or pos[tgt] > pos[deferred_to[src]] else deferred_to[src]
+                if tgt not in applied:
+                    pending.setdefault(tgt, []).append(ritem)
+                else:
+                    ix = max([i for i, x in enumerate(q) if x[0] == 'r' and x[1][2] in deps] or [-1])
+                    q.insert(ix + 1, ritem)
+                prev = tip
+    elif r.returncode != 0:
+        raise RuntimeError(r.stderr)
+    msg = git('log', '-1', '--format=%B', src).stdout
+    if kind == 'r':
+        subj = msg.splitlines()[0]
+        tl = label.split('RESIDUAL(after ')[1].rstrip(')')
+        tsub = int(tl.split()[0][1:]); tag = TAG[tsub]
+        tsubj = git('log', '-1', '--format=%s', [x[1] for x in order if x[2] == tl][0]).stdout.strip()
+        k = (src, tag); rcount[k] = rcount.get(k, 0) + 1
+        sfx = f' {rcount[k]}' if rcount[k] > 1 else ''
+        msg = (f'{subj} ({tag} part{sfx})\n\n'
+               f'Split from "{subj}" for the subtopic reorder: its hunks that edit\n'
+               f'code from "{tsubj}", which comes later in the new order.\n\n'
+               f'Assisted-by: Claude:claude-opus-5-5\n')
+    an, ae, ad = git('log', '-1', '--format=%an%x00%ae%x00%ad', '--date=raw', src).stdout.strip().split('\0')
+    cenv = dict(env0, GIT_AUTHOR_NAME=an, GIT_AUTHOR_EMAIL=ae, GIT_AUTHOR_DATE=ad)
+    acc = git('commit-tree', tree, '-p', acc, inp=msg, env=cenv).stdout.strip()
+    L(f'OK {n} {label} -> {acc[:12]}' + (' ' + '; '.join(notes) if notes else ''))
+    if kind == 'r':
+        nres[src] -= 1
+        if nres[src] == 0:
+            deferred_to.pop(src, None)
+    else:
+        applied.add(item[1])
+        if item[1] in pending:
+            q[0:0] = pending.pop(item[1])
+json.dump(reslog, open(os.path.join(TMPD, 'reslog.json'), 'w'), indent=1)
+git('update-ref', outref, acc)
+L(f'DONE {acc} tree {rp(acc + "^{tree}")} final {rp(FINAL + "^{tree}")}')
+if pending: L(f'UNPLACED residuals: {pending}')
diff --git a/scripts/sa-reorder/bin/review.py b/scripts/sa-reorder/bin/review.py
new file mode 100644 (file)
index 0000000..9470c3c
--- /dev/null
@@ -0,0 +1,27 @@
+#!/usr/bin/python3 -I
+# review.py SUB: for each novel block at the end of SUB, the block with
+# markers: '   ' in both, '>Sn' added later, '<Sn' present now, deleted later.
+# Prints only regions near '<' lines (code that exists only in the
+# reordered series' intermediate state) unless -a.
+import json, subprocess, re, sys
+sub = int(sys.argv[1]); full = '-a' in sys.argv
+nov = json.load(open('novel.json'))[f'refs/tmp/o-sord/b-S{sub}']
+for p, name in nov:
+    rx = '^' + re.escape(name.split('(')[0].split('{')[0].strip())
+    r = subprocess.run(['python3', '-I', 'bin/wblock.py', str(sub), p, rx, '2000'], capture_output=True, text=True)
+    blk = []
+    for l in r.stdout.splitlines():
+        blk.append(l)
+        if l.split('| ', 1)[-1].startswith('}'): break
+    lt = [j for j, l in enumerate(blk) if l.startswith('<')]
+    if not lt and not full:
+        continue
+    print(f'##### {p}: {name}')
+    show = set()
+    for j in lt:
+        show |= set(range(max(0, j - 6), min(len(blk), j + 7)))
+    if full: show = set(range(len(blk)))
+    prev = -2
+    for j in sorted(show):
+        if j != prev + 1: print('   ...')
+        print('  ', blk[j][:160]); prev = j
diff --git a/scripts/sa-reorder/bin/review4.py b/scripts/sa-reorder/bin/review4.py
new file mode 100644 (file)
index 0000000..c8670ed
--- /dev/null
@@ -0,0 +1,56 @@
+#!/usr/bin/python3 -I
+# review4.py WSTATE.pkl CLASS
+# Reclaim review by the weave: the functions (top-level blocks) that CLASS
+# patches wrote code in; for each, every hunk placed after the subtopic
+# (later subtopics' changes to it, and the synthetic extension), and any
+# hunk of a CLASS patch placed outside the subtopic.
+import pickle, sys
+st = pickle.load(open(sys.argv[1], 'rb')); cls = int(sys.argv[2])
+W, H, key, order, CLS = st['W'], st['H'], st['key'], st['order'], st['CLS']
+def sub(kk):
+    return 7 if len(kk) > 2 and kk[2] == 2 else CLS[order[kk[0]]]
+mine = [hi for hi, h in enumerate(H) if CLS.get(h['k']) == cls]
+K3 = max(key[hi] for hi in mine if sub(key[hi]) == cls)
+out = [hi for hi in mine if sub(key[hi]) != cls]
+print(f'{cls}-class hunks placed outside the subtopic: {len(out)}')
+for hi in out:
+    print('   ', H[hi]['k'], H[hi]['path'], key[hi])
+tops = {}
+for hi in mine:
+    h = H[hi]; w = W[h['path']]
+    if not h['path'].endswith('.c') or not h['encl']:
+        continue
+    t = h['encl'][0]
+    if w['t'][t].strip() != '{':
+        continue
+    j = w['order'].index(t) - 1
+    while j > 0 and not (w['t'][w['order'][j]][:1].isalpha() and w['dele'][w['order'][j]] == 0):
+        j -= 1
+    tops[(h['path'], t)] = w['t'][w['order'][j]].strip()
+for p, w in W.items():
+    if not p.endswith('.c'):
+        continue
+    for i in w['order']:
+        if w['t'][i] == '{\n' and CLS.get(w['ins'][i]) == cls:
+            j = w['order'].index(i) - 1
+            while j > 0 and not w['t'][w['order'][j]][:1].isalpha():
+                j -= 1
+            tops[(p, i)] = w['t'][w['order'][j]].strip()
+print(f'functions the subtopic wrote code in: {len(tops)}')
+later = {}
+for hi, h in enumerate(H):
+    if not h['encl'] or key[hi] <= K3:
+        continue
+    t = (h['path'], h['encl'][0])
+    if t in tops:
+        later.setdefault(t, []).append(hi)
+for t in sorted(tops, key=lambda x: (x[0], tops[x])):
+    hs = later.get(t, [])
+    if not hs:
+        print(f'  S{cls} final  {t[0]}: {tops[t][:70]}')
+        continue
+    print(f'  later  {t[0]}: {tops[t][:70]}')
+    for hi in sorted(hs, key=lambda x: key[x]):
+        h = H[hi]; w = W[h['path']]
+        ch = [('+' if w['ins'][i] == h['k'] else '-') + w['t'][i].rstrip() for i in h['ids']]
+        print(f'        S{sub(key[hi])} old{h["k"]}: {len(ch)} lines: ' + ' | '.join(c.strip()[:60] for c in ch[:3]))
diff --git a/scripts/sa-reorder/bin/tokdeps.py b/scripts/sa-reorder/bin/tokdeps.py
new file mode 100644 (file)
index 0000000..bc2b073
--- /dev/null
@@ -0,0 +1,30 @@
+#!/usr/bin/python3 -I
+# Semantic deps: identifiers new in the series (absent from base), the patch
+# that first adds them, and the later patches whose + lines use them.
+import subprocess, sys, re, json
+repo, base, tip, out = sys.argv[1:5]
+def git(*a):
+    return subprocess.run(['git','-C',repo]+list(a),capture_output=True,text=True,check=True).stdout
+commits = git('rev-list','--reverse',f'{base}..{tip}').split()
+paths=['fs/btrfs','include/trace/events/btrfs.h']
+tok=re.compile(r'\b[A-Za-z_][A-Za-z0-9_]{3,}\b')
+basetoks=set(tok.findall(git('grep','-h','-I','-e','.',base,'--',*paths)))
+first={}; uses={}
+for i,c in enumerate(commits,1):
+    d=git('show','--format=','-U0',c)
+    add=set()
+    for l in d.splitlines():
+        if l.startswith('+') and not l.startswith('+++'):
+            s=re.sub(r'/\*.*?\*/','',l[1:])
+            s=re.sub(r'"[^"]*"','',s)
+            if s.strip().startswith(('*','/*','//')): continue
+            add|=set(tok.findall(s))
+    add-=basetoks
+    for t in add:
+        if t not in first: first[t]=i
+        else: uses.setdefault(i,set()).add(t)
+res={}
+for i,ts in uses.items():
+    for t in ts:
+        res.setdefault(str(i),{}).setdefault(str(first[t]),[]).append(t)
+json.dump({'first':first,'uses':res},open(out,'w'),indent=0)
diff --git a/scripts/sa-reorder/bin/viol.py b/scripts/sa-reorder/bin/viol.py
new file mode 100644 (file)
index 0000000..3b007f9
--- /dev/null
@@ -0,0 +1,21 @@
+#!/usr/bin/python3 -I
+import json,sys
+cls={int(a):int(b) for a,b in (l.split() for l in open(sys.argv[1]) if l.strip())}
+def key(i): return (cls[i],i)
+mode=sys.argv[2]
+if mode=='tok':
+    d=json.load(open('tokdeps.json'))['uses']
+    for u,defs in sorted(d.items(),key=lambda x:int(x[0])):
+        u=int(u)
+        for dd,toks in sorted(defs.items(),key=lambda x:int(x[0])):
+            dd=int(dd)
+            if key(dd)>key(u):
+                print(f'{u}(S{cls[u]}) uses {dd}(S{cls[dd]}): {" ".join(sorted(toks)[:8])}')
+else:
+    d=json.load(open('blamedeps.json'))
+    for u,defs in sorted(d.items(),key=lambda x:int(x[0])):
+        u=int(u)
+        for dd,files in sorted(defs.items(),key=lambda x:int(x[0])):
+            dd=int(dd)
+            if key(dd)>key(u):
+                print(f'{u}(S{cls[u]}) ctx {dd}(S{cls[dd]}): {" ".join(files)}')
diff --git a/scripts/sa-reorder/bin/wblock.py b/scripts/sa-reorder/bin/wblock.py
new file mode 100644 (file)
index 0000000..bc1b7d3
--- /dev/null
@@ -0,0 +1,29 @@
+#!/usr/bin/python3 -I
+# wblock.py SUB PATH REGEX [N]: weave view of a block at the end of subtopic SUB:
+#  ' ' present there and in the final tree, '>' only later (inserter's subtopic),
+#  '<' present there but deleted later (deleter's subtopic)
+import pickle, sys, re, json
+st = pickle.load(open('wstate.pkl', 'rb'))
+W, H, key, order, insh, delh, CLS = (st[k] for k in ('W', 'H', 'key', 'order', 'insh', 'delh', 'CLS'))
+sub, p, rx = int(sys.argv[1]), sys.argv[2], sys.argv[3]
+n = int(sys.argv[4]) if len(sys.argv) > 4 else 80
+out = json.load(open('wreplay.json'))
+bk = max(tuple(x['key']) for x in out if x['sub'] == sub)
+w = W[p]; wo = w['order']
+def at(i, kk):
+    a = w['ins'][i] == 0 or key[insh[(p, i)]] <= kk
+    d = w['dele'][i] != 0 and key[delh[(p, i)]] <= kk
+    return a and not d
+fin = (999999,)
+start = next(j for j, i in enumerate(wo) if re.search(rx, w['t'][i]) and at(i, fin))
+shown = 0
+for i in wo[start:]:
+    b, f = at(i, bk), at(i, fin)
+    if not b and not f:
+        continue
+    if b and f: m = '   '
+    elif f: m = '>S%d' % CLS[order[key[insh[(p, i)]][0]]]
+    else: m = '<S%d' % CLS[order[key[delh[(p, i)]][0]]]
+    print(f'{m} old{w["ins"][i]:<3}| {w["t"][i].rstrip()}')
+    shown += 1
+    if shown >= n: break
diff --git a/scripts/sa-reorder/bin/wdump.py b/scripts/sa-reorder/bin/wdump.py
new file mode 100644 (file)
index 0000000..c6beaab
--- /dev/null
@@ -0,0 +1,14 @@
+#!/usr/bin/python3 -I
+# wdump.py PATH REGEX [N]: weave lines around the first line matching REGEX
+import pickle, sys, re
+st = pickle.load(open('wstate.pkl', 'rb'))
+W, H, key, order, insh, delh, CLS = (st[k] for k in ('W', 'H', 'key', 'order', 'insh', 'delh', 'CLS'))
+p, rx = sys.argv[1], sys.argv[2]; n = int(sys.argv[3]) if len(sys.argv) > 3 else 40
+w = W[p]; wo = w['order']
+start = next(j for j, i in enumerate(wo) if re.search(rx, w['t'][i]))
+def sub(hi): return 'S%d' % CLS[order[key[hi][0]]] if hi is not None else '  '
+for i in wo[max(0, start - 3):start + n]:
+    a = w['ins'][i]; d = w['dele'][i]
+    ka = sub(insh.get((p, i))) if a else 'base'
+    kd = sub(delh.get((p, i))) if d else ''
+    print(f"ins old{a:<3} {ka:4} del {('old%d' % d) if d else '':6} {kd:3} | {w['t'][i].rstrip()[:90]}")
diff --git a/scripts/sa-reorder/bin/wpost.py b/scripts/sa-reorder/bin/wpost.py
new file mode 100644 (file)
index 0000000..6883f41
--- /dev/null
@@ -0,0 +1,169 @@
+#!/usr/bin/python3 -I
+# wpost.py REPO ENGINE.json SPEC OUTREF OUT.json LOG
+#
+# Rewrites a weave replay (wreplay.py's output) where a ruling allows new
+# code.  The engine's commits stay the skeleton; the spec adds:
+#
+#   OVERLAYS: dict(name, at=ANCHOR, until=ANCHOR|None, edits=[(path, old, new)])
+#     (old may be a tuple of (old, new) alternatives, new then ignored)
+#     From commit `at` (inclusive) up to commit `until` (exclusive; None =
+#     to the end), each tree carries the edits.  The edits are made as text
+#     replacements in the tree at `at` (after the overlays before this one);
+#     later trees get them by a three-way merge, so commits in between that
+#     touch other lines keep their own changes.  At `until` the engine's own
+#     tree comes back, so that commit's diff absorbs the overlay's removal.
+#   INSERTS: dict(name, after=ANCHOR, src=K, msg=TEXT)
+#     A new commit after ANCHOR with old patch K's author and date.
+#   DROPS: [ANCHOR]: commits that the overlays made empty (checked).
+#   RETITLES: {ANCHOR: (msg, kind)}: new message, author ZYGO, date NOW.
+#   MSGS: {ANCHOR: msg}: replace an original message.
+#   MSG_EDITS: {ANCHOR: [(old, new)]}: text replacements in the message
+#     (each old text found exactly once).
+#
+# ANCHOR: ('main', K) | ('part', K, N) (N-th part of K, 1-based) |
+#         ('new', K) (the engine's synthetic patch K) | ('new', NAME).
+import json, subprocess, sys, os
+repo, enginef, specf, outref, outf, logf = sys.argv[1:7]
+log = open(logf, 'w')
+def L(*a): print(*a, file=log, flush=True)
+env0 = dict(os.environ)
+def git(*a, inp=None, env=None, check=True):
+    r = subprocess.run(['git', '-C', repo] + list(a), input=inp, capture_output=True, text=True,
+                       env=env or env0)
+    if check and r.returncode not in (0,):
+        raise RuntimeError(f'git {a}: rc={r.returncode} {r.stdout[:2000]} {r.stderr[:2000]}')
+    return r
+spec = {"SPECF": specf}
+exec(open(specf).read(), spec)
+ZYGO = spec['ZYGO']; NOW = spec['NOW']
+OVERLAYS = spec.get('OVERLAYS', []); INSERTS = spec.get('INSERTS', [])
+DROPS = spec.get('DROPS', []); RETITLES = spec.get('RETITLES', {}); MSGS = spec.get('MSGS', {})
+MSG_EDITS = spec.get('MSG_EDITS', {})
+eng = json.load(open(enginef))
+
+# ---- the sequence ------------------------------------------------------------------
+def anchor_of(i):
+    x = eng[i]
+    if x['kind'] in ('main', 'new'):
+        return (x['kind'], x['src'])
+    n = sum(1 for y in eng[:i + 1] if y['src'] == x['src'] and y['kind'] == 'part')
+    return ('part', x['src'], n)
+seq = []
+for i, x in enumerate(eng):
+    seq.append(dict(anchor=anchor_of(i), eng=i, tree=git('rev-parse', x['sha'] + '^{tree}').stdout.strip(),
+                    sha=x['sha'], src=x['src'], kind=x['kind'], sub=x['sub']))
+for ins in INSERTS:
+    j = next(j for j, e in enumerate(seq) if e['anchor'] == tuple(ins['after']))
+    prev = seq[j]
+    seq.insert(j + 1, dict(anchor=('new', ins['name']), eng=None, tree=prev['tree'], sha=None,
+                           src=ins['src'], kind='main', sub=ins.get('sub', prev['sub']), msg=ins['msg']))
+pos = {e['anchor']: j for j, e in enumerate(seq)}
+for a in list(DROPS) + list(RETITLES) + list(MSGS) + list(MSG_EDITS):
+    assert tuple(a) in pos, f'unknown anchor {a}'
+
+# ---- trees -----------------------------------------------------------------------------
+_cm = {}
+def commit_of(tree):
+    if tree not in _cm:
+        _cm[tree] = git('commit-tree', tree, inp='wpost scratch\n').stdout.strip()
+    return _cm[tree]
+def merge3(base, ours, theirs):
+    if ours == base:
+        return theirs
+    if theirs == base or ours == theirs:
+        return ours
+    r = git('merge-tree', '--write-tree', '--merge-base=' + commit_of(base), commit_of(ours),
+            commit_of(theirs), check=False)
+    if r.returncode != 0:
+        raise RuntimeError(f'merge conflict: {r.stdout[:3000]}')
+    return r.stdout.split()[0]
+def apply_edits(tree, edits, name, soft=False):
+    idx = dict(env0, GIT_INDEX_FILE=os.path.join(os.environ['TMPD'], 'wpost.index'))
+    git('read-tree', tree, env=idx)
+    files = {}
+    for (p, old, new) in edits:
+        if p not in files:
+            r = git('show', f'{tree}:{p}', check=False)
+            files[p] = r.stdout if r.returncode == 0 else ''
+        if isinstance(old, tuple):
+            # alternatives (old, new) pairs: the first whose old text is there once
+            old, new = next(((o_, n_) for (o_, n_) in old if files[p].count(o_) == 1), old[0])
+        n = files[p].count(old)
+        if n != 1 and soft:
+            return None
+        if n != 1:
+            raise RuntimeError(f'overlay {name}: {p}: old text found {n} times:\n{old[:400]}')
+        files[p] = files[p].replace(old, new)
+    for p, c in files.items():
+        bl = git('hash-object', '-w', '--stdin', '--path', p, inp=c).stdout.strip()
+        git('update-index', '--add', '--cacheinfo', f'100644,{bl},{p}', env=idx)
+    return git('write-tree', env=idx).stdout.strip()
+
+ov = []
+for o in OVERLAYS:
+    a = pos[tuple(o['at'])]
+    u = pos[tuple(o['until'])] if o.get('until') else len(seq)
+    assert a < u, o['name']
+    ov.append(dict(o, a=a, u=u, B=None, T=None))
+desired = []
+for j, e in enumerate(seq):
+    t = e['tree']
+    for o in ov:
+        if not (o['a'] <= j < o['u']):
+            continue
+        if j == o['a']:
+            o['B'] = t
+            o['T'] = apply_edits(t, o['edits'], o['name'])
+            t = o['T']
+        else:
+            # the same edits again where they still apply, else a merge
+            t2 = apply_edits(t, o['edits'], o['name'], soft=True)
+            if t2 is None:
+                L(f'    overlay {o["name"]}: merge at {e["anchor"]}')
+                t2 = merge3(o['B'], t, o['T'])
+            t = t2
+    desired.append(t)
+    L(f'{j + 1:3d} {e["anchor"]} {t[:12]}{" (eng)" if t == e["tree"] else ""}')
+
+# ---- commits ---------------------------------------------------------------------------
+def author_of(sha):
+    return git('log', '-1', '--format=%an%x00%ae%x00%ad', '--date=raw', sha).stdout.strip().split('\0')
+acc = spec['BASE']; out = []; prev_tree = git('rev-parse', acc + '^{tree}').stdout.strip()
+drops = {tuple(a) for a in DROPS}
+for j, e in enumerate(seq):
+    a = e['anchor']
+    if a in drops:
+        if desired[j] != prev_tree:
+            raise RuntimeError(f'drop {a}: not empty')
+        L(f'drop {a}')
+        continue
+    if desired[j] == prev_tree:
+        raise RuntimeError(f'{a}: empty commit')
+    kind = e['kind']
+    if a in RETITLES:
+        msg, kind = RETITLES[a]
+        an, ae = ZYGO; ad = NOW
+    elif e['eng'] is None:
+        an, ae, ad = author_of(spec['ORIG'][e['src'] - 1])
+        msg = e['msg']
+    else:
+        an, ae, ad = author_of(e['sha'])
+        raw = git('cat-file', 'commit', e['sha']).stdout
+        msg = raw[raw.index('\n\n') + 2:]
+    if a in MSGS:
+        msg = MSGS[a]
+    for (old, new) in MSG_EDITS.get(a, []):
+        if msg.count(old) != 1:
+            raise RuntimeError(f'{a}: message text found {msg.count(old)} times: {old[:200]}')
+        msg = msg.replace(old, new)
+    cenv = dict(env0, GIT_AUTHOR_NAME=an, GIT_AUTHOR_EMAIL=ae, GIT_AUTHOR_DATE=ad)
+    acc = git('commit-tree', desired[j], '-p', acc, inp=msg, env=cenv).stdout.strip()
+    prev_tree = desired[j]
+    out.append(dict(sha=acc, anchor=list(a), src=e['src'], kind=kind, sub=e['sub'],
+                    eng_sha=e['sha'], overlaid=desired[j] != e['tree'], subject=msg.splitlines()[0],
+                    msg_changed=(a in MSGS or a in MSG_EDITS or a in RETITLES or e['eng'] is None)))
+    L(f'{len(out):3d} S{e["sub"]} {kind:4s} {a} {acc[:12]} {msg.splitlines()[0][:70]}')
+git('update-ref', outref, acc)
+json.dump(out, open(outf, 'w'), indent=1)
+L(f'DONE {acc} tree {prev_tree}')
+print(acc)
diff --git a/scripts/sa-reorder/bin/wreplay.py b/scripts/sa-reorder/bin/wreplay.py
new file mode 100644 (file)
index 0000000..9f968e7
--- /dev/null
@@ -0,0 +1,749 @@
+#!/usr/bin/python3 -I
+# Weave-based reorder.  wreplay.py REPO BASE ORIGORDER CLASSFILE SPEC OUTREF LOG
+#
+# Every file is woven from the original series: each line ever present
+# carries the patch that inserted it and the patch that deleted it.  A
+# patch is cut into hunks (its touched weave lines, clustered as diff -U3
+# would).  The new series applies hunks in a new order; a file's content at
+# any point is the weave projected on the hunks applied so far, so every
+# commit is a subset of the original patches' +/- lines and the last tree
+# equals the original last tree by construction.
+#
+# A hunk is placed at its patch's slot in the new order, unless it deletes a
+# line that a later-placed hunk inserts, or both lines around its insertion
+# come from later-placed hunks: then it moves to just after the latest such
+# hunk, as a follow-up commit of its own patch.
+import subprocess, sys, os, re, json, tempfile
+repo, base, origf, clsf, specf, outref, logf = sys.argv[1:8]
+TMPD = os.environ.get('TMPD', '/tmp')
+env0 = dict(os.environ)
+def git(*a, inp=None, env=None, check=True):
+    r = subprocess.run(['git', '-C', repo] + list(a), input=inp, capture_output=True,
+                       text=True, env=env or env0)
+    if check and r.returncode != 0:
+        raise RuntimeError(f'git {a}: {r.stderr}')
+    return r
+def blob(rev, p):
+    x = git('show', f'{rev}:{p}', check=False)
+    return [] if x.returncode else x.stdout.splitlines(True)
+log = open(logf, 'w')
+def L(*a): print(*a, file=log, flush=True)
+orig = [l.split()[0] for l in open(origf) if l.strip()]
+N = len(orig)
+CLS = {int(a): int(b) for a, b in (l.split() for l in open(clsf) if l.strip())}
+TAG = {1: 'base', 2: 'allow_rmw', 3: 'reclaim', 4: 'fsync', 5: 'stripe_meta', 6: 'debug'}
+spec = {}
+exec(open(specf).read(), spec)
+TRANSFER_INS = spec.get('TRANSFER_INS', [])   # (old, path, line text, to-old)
+PERSUB = spec.get('PERSUB', [])               # olds split by owner subtopic
+FORCE = spec.get('FORCE', [])                 # (old, path, regex, after-old)
+FOLD = spec.get('FOLD', [])                   # (old, into-old): fold old's edits of into-old's code into its commit
+JOIN = spec.get('JOIN', [])                   # (old, path, [regex...]): those hunks of old share one commit
+NOMATCH = spec.get('NOMATCH', [])             # (old, path, regex): never a context line in old's diff
+TAG = spec.get('TAGS', TAG)                   # subtopic number -> tag
+SPLIT_STMT = spec.get('SPLIT_STMT', [])       # (old, path, regex): a plain statement that may wait for its names
+DEFER = spec.get('DEFER')                     # (from-class, into-class, label): from-class hunks that land in
+                                              # into-class code wait until after all of into-class, labelled label
+# SYNTH: new patches the rulings allow, numbered between the old ones (a
+# float id): dict(id, cls, place (sort key within its class), subject, msg,
+# author (name, email), date, group).  Commits of one group that land next
+# to each other become one commit.
+SYNTH = spec.get('SYNTH', [])
+SYN = {s_['id']: s_ for s_ in SYNTH}
+for s_ in SYNTH:
+    CLS[s_['id']] = s_['cls']
+ALLK = sorted(list(range(1, N + 1)) + list(SYN))
+order = sorted(ALLK, key=lambda k: (CLS[k], SYN[k]['place'] if k in SYN else k))
+slot = {k: i for i, k in enumerate(order)}
+subj = {k: git('log', '-1', '--format=%s', orig[k - 1]).stdout.strip() for k in range(1, N + 1)}
+for s_ in SYNTH:
+    subj[s_['id']] = s_['msg'].splitlines()[0]
+
+# ---- weave ------------------------------------------------------------------
+def diff_hunks(a, b):
+    with tempfile.TemporaryDirectory(dir=TMPD) as td:
+        pa, pb = os.path.join(td, 'a'), os.path.join(td, 'b')
+        open(pa, 'w').write(''.join(a)); open(pb, 'w').write(''.join(b))
+        r = subprocess.run(['git', 'diff', '--no-index', '--no-color', '-U0',
+                            '--diff-algorithm=histogram', pa, pb], capture_output=True, text=True)
+    out = []
+    for l in r.stdout.splitlines():
+        m = re.match(r'^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@', l)
+        if m:
+            s1 = int(m.group(1)); n1 = int(m.group(2) if m.group(2) is not None else 1)
+            s2 = int(m.group(3)); n2 = int(m.group(4) if m.group(4) is not None else 1)
+            out.append((s1 if n1 == 0 else s1 - 1, n1, s2 if n2 == 0 else s2 - 1, n2))
+    return out
+files = sorted({p for p in git('log', '--format=', '--name-only', f'{base}..{orig[-1]}').stdout.split()})
+W = {}          # path -> dict(t=[text], ins=[k], dele=[k or 0], order=[ids])
+changed = {k: set(git('diff-tree', '--no-commit-id', '-r', '--name-only', orig[k - 1]).stdout.split())
+           for k in range(1, N + 1)}
+for p in files:
+    b0 = blob(base, p)
+    t = list(b0); ins = [0] * len(b0); dele = [0] * len(b0); wo = list(range(len(b0)))
+    vis = list(wo)
+    for k in range(1, N + 1):
+        if p not in changed[k]:
+            continue
+        new = blob(orig[k - 1], p)
+        old = [t[i] for i in vis]; visset = set(vis)
+        nom = set()
+        for (k1, p1, rx) in NOMATCH:
+            if k1 == k and p1 == p:
+                for j, line in enumerate(old):
+                    if re.search(rx, line):
+                        old[j] = line.rstrip('\n') + '\x01NOMATCH\n'; nom.add(vis[j])
+                        L(f'nomatch: old{k} {p} {line.strip()}')
+        newvis = []; q = 0
+        for (a, n1, c, n2) in diff_hunks(old, new):
+            newvis.extend(vis[q:a])
+            for i in vis[a:a + n1]:
+                dele[i] = k
+            ids = []
+            for line in new[c:c + n2]:
+                t.append(line); ins.append(k); dele.append(0); ids.append(len(t) - 1)
+            if n1 and any(i in nom for i in vis[a:a + n1]):
+                # a line the patch rewrote into new code ending in a copy of
+                # it: the old line stays with what follows it
+                at = wo.index(vis[a])
+            elif n1:
+                # a replacement stays next to the lines it replaces
+                at = wo.index(vis[a + n1 - 1]) + 1
+            else:
+                # before the next line, and before the dead lines its own
+                # patch replaced: new code written just above V goes just
+                # above V's older versions too
+                at = wo.index(vis[a]) if a < len(vis) else len(wo)
+                if a < len(vis) and ins[vis[a]]:
+                    vk = ins[vis[a]]
+                    while at > 0 and dele[wo[at - 1]] == vk and wo[at - 1] not in visset:
+                        at -= 1
+            wo[at:at] = ids
+            newvis.extend(ids); q = a + n1
+        newvis.extend(vis[q:])
+        vis = newvis
+        assert [t[i] for i in vis] == new, (p, k)
+        assert not any('\x01NOMATCH' in t[i] for i in vis)
+    W[p] = dict(t=t, ins=ins, dele=dele, order=wo)
+L(f'weave: {len(files)} files')
+
+# ---- rewrites: an old patch's line written in its form without a later
+# subtopic's code; a synthetic patch turns it into the final form.
+# REWRITE: (path, olds, regex, replacement or None (no such line), synth id,
+# opts).  A line still in the final tree, or deleted by a patch of the
+# synthetic's class (opts 'split_dead'), becomes the data form inserted by
+# its old patch and deleted by the synthetic, plus the final form inserted
+# by the synthetic.  A line deleted earlier is rewritten in place.
+for k_ in SYN:
+    changed[k_] = set()
+REWRITTEN = {}  # (path, id) of a synthetic's final-form line -> the old patch it rewrites
+for (p, olds, rx, repl, xs, *opts) in spec.get('REWRITE', []):
+    w = W[p]; t, ins, dele, wo = w['t'], w['ins'], w['dele'], w['order']; n = 0
+    for i in list(wo):
+        a = ins[i]
+        if a not in olds or not re.search(rx, t[i]):
+            continue
+        # opt 'prev:REGEX': only where one of the 3 weave lines before matches
+        pv = [o_[5:] for o_ in opts if o_.startswith('prev:')]
+        if pv:
+            j_ = wo.index(i)
+            if not any(re.search(pv[0], t[q_]) for q_ in wo[max(0, j_ - 3):j_]):
+                continue
+        new = None if repl is None else re.sub(rx, repl, t[i])
+        b = dele[i]
+        if b and 'split_dead' not in opts:
+            L(f'rewrite in place: old{a} del old{b} {p}: {t[i].rstrip()} -> {new.rstrip() if new else None}')
+            if new is None:
+                wo.remove(i)
+            else:
+                t[i] = new
+            n += 1; continue
+        assert a < xs and (not b or xs < b), (p, i, a, b, xs)
+        if new is not None:
+            t.append(new); ins.append(a); dele.append(xs)
+            wo.insert(wo.index(i), len(t) - 1)
+        REWRITTEN[(p, i)] = a; ins[i] = xs; changed[xs].add(p); n += 1
+        L(f'rewrite: old{a} {p}: {new.rstrip() if new else None} | synth {xs}: {t[i].rstrip()}'
+          f'{f" (del old{b})" if b else ""}')
+    assert n, ('rewrite matched nothing', p, rx)
+
+# ---- hunks --------------------------------------------------------------------
+def scan_braces(line, i, stack, st):
+    """push/pop weave id i on '{' / '}' outside comments, strings, chars;
+    st tracks an open block comment and the line that opened it"""
+    j = 0; n = len(line)
+    if not st['incom'] and line.lstrip().startswith('#'):
+        return
+    while j < n:
+        if st['incom']:
+            e = line.find('*/', j)
+            if e < 0: return
+            st['incom'] = False; j = e + 2; continue
+        ch = line[j]
+        if line.startswith('/*', j): st['incom'] = True; st['comopen'] = i; j += 2; continue
+        if line.startswith('//', j): break
+        if ch in '"\'':
+            q = ch; j += 1
+            while j < n and line[j] != q:
+                j += 2 if line[j] == '\\' else 1
+            j += 1; continue
+        if ch == '{': stack.append(i)
+        elif ch == '}' and stack: stack.pop()
+        elif ch == '(': st['paren'] = st.get('paren', 0) + 1
+        elif ch == ')': st['paren'] = max(0, st.get('paren', 0) - 1)
+        j += 1
+# hunk: dict(k, path, ids (touched weave ids, weave order), key)
+H = []
+for p in files:
+    w = W[p]; t, ins, dele, wo = w['t'], w['ins'], w['dele'], w['order']
+    for k in ALLK:
+        if p not in changed[k]:
+            continue
+        # state after k: visible ids plus the ids k deleted, in weave order
+        seq = [i for i in wo if (ins[i] <= k and (dele[i] == 0 or dele[i] >= k))]
+        touched = [j for j, i in enumerate(seq) if ins[i] == k or dele[i] == k]
+        cl = []
+        for j in touched:
+            if cl and j - cl[-1][-1] - 1 <= 3:
+                cl[-1].append(j)
+            else:
+                cl.append([j])
+        # enclosing block openers at each position of the post-k state
+        openers = {}; stack = []; st = {'incom': False, 'comopen': None, 'paren': 0}; inparen = {}
+        for i in seq:
+            openers[i] = list(stack) + ([st['comopen']] if st['incom'] else [])
+            inparen[i] = st['paren'] > 0
+            if dele[i] == k:
+                continue
+            scan_braces(t[i], i, stack, st)
+        for c in cl:
+            ids = [seq[j] for j in c]
+            before = next((seq[j] for j in range(c[0] - 1, -1, -1) if dele[seq[j]] != k), None)
+            after = next((seq[j] for j in range(c[-1] + 1, len(seq)) if dele[seq[j]] != k), None)
+            firstins = next((i for i in ids if ins[i] == k), None)
+            H.append(dict(k=k, path=p, ids=ids, pos=list(c), before=before, after=after,
+                          encl=openers[firstins] if firstins is not None else [],
+                          inparen=inparen[firstins] if firstins is not None else False))
+L(f'hunks: {len(H)}')
+insh = {}; delh = {}
+for hi, h in enumerate(H):
+    w = W[h['path']]
+    for i in h['ids']:
+        if w['ins'][i] == h['k']: insh[(h['path'], i)] = hi
+        if w['dele'][i] == h['k']: delh[(h['path'], i)] = hi
+def lines_of(h):
+    w = W[h['path']]
+    return [(('+' if w['ins'][i] == h['k'] else '-') + w['t'][i]) for i in h['ids']]
+
+# ---- initial keys -------------------------------------------------------------
+key = {}; why = {}
+def owner_sub(h):
+    """subtopic of the latest-placed patch owning the lines h deletes or sits between"""
+    w = W[h['path']]; olds = set()
+    for i in h['ids']:
+        if w['dele'][i] == h['k'] and w['ins'][i]: olds.add(REWRITTEN.get((h['path'], i), w['ins'][i]))
+    for i in (h['before'], h['after']):
+        if i is not None and w['ins'][i]: olds.add(REWRITTEN.get((h['path'], i), w['ins'][i]))
+    return max(((CLS[o], o) for o in olds), default=(1, 0))[0]
+for hi, h in enumerate(H):
+    k = h['k']; key[hi] = (slot[k], 0)
+    if k in SYN and 'into' in SYN[k]:
+        # a build fix: in the commit of the patch it adapts to
+        key[hi] = (slot[SYN[k]['into']], 0); why[hi] = f'folded into old {SYN[k]["into"]}'
+    if k in PERSUB:
+        s = owner_sub(h)
+        last = max([o for o in order if CLS[o] == s and o < k] or [None], key=lambda o: slot[o] if o else -1)
+        if s == CLS[k] or last is None:
+            key[hi] = (slot[k], 0)
+        else:
+            key[hi] = (slot[last], 0, 1, slot[k]); why[hi] = f'subtopic {TAG[s]}'
+for (k0, p, line, to) in TRANSFER_INS:
+    for hi, h in enumerate(list(H)):
+        if h['k'] == k0 and h['path'] == p and '+' + line in lines_of(h) and len(h['ids']) > 1:
+            w = W[p]
+            i = next(i for i in h['ids'] if w['ins'][i] == k0 and w['t'][i] == line)
+            h['pos'] = [q for x, q in zip(h['ids'], h['pos']) if x != i]
+            h['ids'] = [x for x in h['ids'] if x != i]
+            H.append(dict(k=k0, path=p, ids=[i], pos=[0], before=h['before'], after=h['after'], encl=[]))
+            insh[(p, i)] = len(H) - 1; key[len(H) - 1] = (slot[k0], 0)
+    for hi, h in enumerate(H):
+        if h['k'] == k0 and h['path'] == p and lines_of(h) == ['+' + line]:
+            key[hi] = (slot[to], 0); why[hi] = f'transfer into old {to}'
+            L(f'transfer: old{k0} {p} {line.strip()} -> old{to}')
+for (k0, p, rx) in SPLIT_STMT:
+    # a one-line statement split out of its hunk, so that it alone can wait
+    for hi, h in enumerate(list(H)):
+        if h['k'] != k0 or h['path'] != p or len(h['ids']) < 2:
+            continue
+        w = W[p]
+        for i in [i for i in h['ids'] if w['ins'][i] == k0 and re.search(rx, w['t'][i])]:
+            h['pos'] = [q for x, q in zip(h['ids'], h['pos']) if x != i]
+            h['ids'] = [x for x in h['ids'] if x != i]
+            H.append(dict(k=k0, path=p, ids=[i], pos=[0], before=h['before'], after=h['after'],
+                          encl=h['encl']))
+            insh[(p, i)] = len(H) - 1; key[len(H) - 1] = key[hi]
+            L(f'split stmt: old{k0} {p} {w["t"][i].strip()}')
+for (k0, p, rx, to) in FORCE:
+    for hi, h in enumerate(H):
+        if h['k'] == k0 and h['path'] == p and any(re.search(rx, l[1:]) for l in lines_of(h) if l[0] in '+-'):
+            key[hi] = max(key[hi], (slot[to], 0, 1, slot[k0])); why[hi] = f'forced after old {to}'
+            L(f'force: old{k0} {p} hunk with /{rx}/ -> after old{to}')
+
+# ---- names: a hunk that uses a name (identifier or member) new to the tree
+# (absent from the base's fs/btrfs and headers) follows the hunks of the
+# patch that first brought the name in
+TOKRX = re.compile(r'(->|\.)?\s*\b([A-Za-z_][A-Za-z0-9_]*)\b')
+CKW = set('if else for while do switch case default return break continue goto sizeof '
+          'struct union enum const static inline unsigned signed int long short char void '
+          'bool u8 u16 u32 u64 s8 s16 s32 s64 true false NULL typedef extern volatile '
+          'define include ifdef ifndef endif undef elif'.split())
+def code_tokens(text, st):
+    out = set(); j = 0; code = []
+    while j < len(text):
+        if st['c']:
+            e = text.find('*/', j)
+            if e < 0: break
+            st['c'] = False; j = e + 2; continue
+        if text.startswith('/*', j): st['c'] = True; j += 2; continue
+        if text.startswith('//', j): break
+        ch = text[j]
+        if ch in '"\'':
+            q = ch; j += 1
+            while j < len(text) and text[j] != q:
+                j += 2 if text[j] == '\\' else 1
+            j += 1; code.append(' '); continue
+        code.append(ch); j += 1
+    for m in TOKRX.finditer(''.join(code)):
+        if m.group(2) in CKW or m.group(2)[0].isdigit(): continue
+        out.add(('m' if m.group(1) else 'b', m.group(2)))
+    return out
+basetok = {}
+for p in files:
+    st = {'c': False}; bt = set()
+    for line in blob(base, p):
+        bt |= code_tokens(line, st)
+    basetok[p] = bt
+idtok = {}
+def hunk_idtokens(h):
+    """tokens per inserted line, carrying block-comment state across the
+    hunk's lines (a comment's continuation lines need not start with *)"""
+    w = W[h['path']]; st = {'c': False}
+    for i in h['ids']:
+        if w['ins'][i] != h['k']:
+            continue
+        text = w['t'][i]; s_ = text.lstrip()
+        if not st['c'] and s_.startswith('*') and not s_.startswith('*/'):
+            idtok[(h['path'], i)] = set(); continue
+        idtok[(h['path'], i)] = code_tokens(text, st)
+for h in H:
+    hunk_idtokens(h)
+def line_tokens_id(p, i): return idtok.get((p, i), set())
+def tokens_of(hi):
+    h = H[hi]; w = W[h['path']]; tk = set()
+    for i in h['ids']:
+        if w['ins'][i] == h['k']:
+            tk |= idtok.get((h['path'], i), set())
+    return tk
+htok = {hi: tokens_of(hi) for hi in range(len(H))}
+allbase = set().union(*basetok.values()); allbasenames = {t for (_, t) in allbase}
+cand = sorted({t for tk in htok.values() for (_, t) in tk} - allbasenames)
+with tempfile.NamedTemporaryFile('w', dir=TMPD, delete=False) as f:
+    f.write('\n'.join(cand) + '\n'); patf = f.name
+cachef = os.path.join(TMPD, 'intree.cache')
+cache = json.load(open(cachef)) if os.path.exists(cachef) else {}
+if cache.get('cand') != cand:
+    ls = git('ls-tree', '-r', base, '--', 'include', 'fs/btrfs', 'arch/x86/include').stdout
+    objs = [l.split()[2] for l in ls.splitlines() if l.endswith(('.h', '.c'))]
+    r = subprocess.run(['git', '-C', repo, 'cat-file', '--batch'], input=('\n'.join(objs) + '\n').encode(),
+                       capture_output=True)
+    names = set(re.findall(rb'[A-Za-z_][A-Za-z0-9_]*', r.stdout))
+    cache = dict(cand=cand, intree=sorted(t for t in cand if t.encode() in names))
+    json.dump(cache, open(cachef, 'w'))
+intree = set(cache['intree']); os.unlink(patf)
+def newname(t): return t not in intree and t not in allbasenames
+NOTDECL = set('return case goto sizeof else'.split())
+declrx = {}
+def decl_hunks(t):
+    """hunks that insert a declaration or definition of t: a local, a
+    parameter, a function, a field, an enum constant, a macro"""
+    if t not in declrx:
+        rx1 = re.compile(r'\b([A-Za-z_][A-Za-z0-9_]*)[\s*]+' + re.escape(t) + r'\s*([=;,\[)(:]|$)')
+        rx2 = re.compile(r'^\s*(' + re.escape(t) + r'\s*[,=]|#\s*define\s+' + re.escape(t) + r'\b)')
+        out = []
+        for hi in globintro.get(t, []):
+            h = H[hi]; w = W[h['path']]
+            for i in h['ids']:
+                if w['ins'][i] != h['k']: continue
+                text = re.sub(r'"(\\.|[^"\\])*"', '""', re.sub(r'/\*.*?\*/|//.*', '', w['t'][i]))
+                m = rx1.search(text)
+                if (m and m.group(1) not in NOTDECL) or rx2.search(text):
+                    out.append(hi); break
+        declrx[t] = out
+    return declrx[t]
+def build_globintro():
+    g = {}
+    for hi in range(len(H)):
+        for tk in htok[hi]:
+            if newname(tk[1]):
+                g.setdefault(tk[1], []).append(hi)
+    return g
+globintro = build_globintro()
+firstk = {t: min(H[g]['k'] for g in lst) for t, lst in globintro.items()}
+def suppliers(t):
+    """the hunks a use of t needs one of: its declarations, or, when none
+    is recognised, the hunks of the patch that first used it"""
+    d = decl_hunks(t)
+    return d if d else [g for g in globintro[t] if H[g]['k'] == firstk[t]]
+def late_names(hi, ids_tokens, keyed=False):
+    """names this hunk's lines use whose every supplier from an earlier (or
+    its own) patch comes later: by slot in the new order, or by key"""
+    h = H[hi]; out = set()
+    for (_, t) in ids_tokens:
+        if not newname(t): continue
+        sup = [g for g in suppliers(t) if H[g]['k'] <= h['k']]
+        if not sup or any(H[g]['k'] == h['k'] for g in sup) and not keyed: continue
+        if keyed:
+            if all(key[g] > key[hi] for g in sup):
+                out.add((t, min(key[g] for g in sup), min(H[g]['k'] for g in sup)))
+        elif all(slot[H[g]['k']] > slot[h['k']] for g in sup):
+            out.add(t)
+    return out
+# split a hunk's statements that use such names into hunks of their own, so
+# only those statements wait for the name, not the whole hunk
+def dead_without(expr, late, ident):
+    """expr is constant @ident (False for "is it", True for "is it not")
+    while the names in @late do not exist yet: a test that a value equals a
+    later constant, or a call of a later predicate"""
+    e = expr.strip()
+    while e.startswith('(') and e.endswith(')') and e.count('(') == e.count(')'):
+        e = e[1:-1].strip()
+    neg = e.startswith('!')
+    if neg:
+        e = e[1:].strip()
+    lp = '|'.join(re.escape(x) for x in sorted(late))
+    m_cmp = re.fullmatch(r'[\w>.\-]+\s*(==|!=)\s*(' + lp + r')|(' + lp + r')\s*(==|!=)\s*[\w>.\-]+', e)
+    m_call = re.fullmatch(r'(' + lp + r')\([^()]*\)', e)
+    if m_cmp:
+        isnot = '!=' in e
+        val = isnot          # x == LATE is false, x != LATE is true
+    elif m_call:
+        val = False
+    else:
+        return False
+    if neg:
+        val = not val
+    return val == ident
+def stmt_span(h, m, inl, late):
+    """the lines to hold back with a use of a later name, when dropping
+    them leaves code that behaves the same while the name does not exist:
+    an operand of a && / || chain that is then the chain's identity, or an
+    if whose condition is then false"""
+    w = W[h['path']]; t = w['t']
+    adj = lambda a, b: h['pos'][h['ids'].index(inl[b])] - h['pos'][h['ids'].index(inl[a])] == 1
+    endsep = lambda x: t[x].rstrip().endswith((';', '{', '}', '*/')) or not t[x].strip()
+    # one operand line of a multi-line && / || condition
+    op = re.search(r'(&&|\|\|)\s*$', t[inl[m]])
+    if op and m > 0 and adj(m - 1, m) and t[inl[m - 1]].rstrip().endswith(op.group(1)):
+        c_ = re.sub(r'"(\\.|[^"\\])*"', '""', t[inl[m]])
+        if c_.count('(') == c_.count(')') and '{' not in c_ and '}' not in c_:
+            operand = re.sub(r'(&&|\|\|)\s*$', '', c_)
+            if dead_without(operand, late, op.group(1) == '&&'):
+                return m, m
+        return None
+    first = re.sub(r'/\*.*?\*/|//.*', '', t[inl[m]]).strip()
+    mm = re.fullmatch(r'if \((.*)\)\s*\{?', first)
+    if not mm or not dead_without(mm.group(1), late, False):
+        return None
+    m0 = m
+    while m0 > 0 and adj(m0 - 1, m0) and not endsep(inl[m0 - 1]):
+        m0 -= 1
+    # leading comment block directly above the statement
+    while m0 > 0 and adj(m0 - 1, m0) and t[inl[m0 - 1]].lstrip().startswith(('/*', '*', '//')):
+        m0 -= 1
+    depth = 0; par = 0; m1 = m0
+    while True:
+        line = t[inl[m1]]
+        code = re.sub(r'"(\\.|[^"\\])*"', '""', re.sub(r'/\*.*?\*/|//.*', '', line))
+        depth += code.count('{') - code.count('}'); par += code.count('(') - code.count(')')
+        r = line.rstrip()
+        if m1 >= m and depth == 0 and par == 0 and (r.endswith(';') or r.endswith('}')):
+            nxt = t[inl[m1 + 1]].lstrip() if m1 + 1 < len(inl) and adj(m1, m1 + 1) else ''
+            if not nxt.startswith('else'):
+                return m0, m1
+        if m1 + 1 >= len(inl) or not adj(m1, m1 + 1) or depth < 0:
+            return None
+        m1 += 1
+nsplit = 0
+for hi in range(len(H)):
+    h = H[hi]; w = W[h['path']]
+    if not late_names(hi, htok[hi]):
+        continue
+    inl = [i for i in h['ids'] if w['ins'][i] == h['k']]
+    spans = []; m = 0
+    while m < len(inl):
+        ln = late_names(hi, line_tokens_id(h['path'], inl[m]))
+        if ln:
+            sp = stmt_span(h, m, inl, ln)
+            if sp is None:
+                spans = None; break
+            if spans and sp[0] <= spans[-1][1]:
+                spans[-1] = (spans[-1][0], max(spans[-1][1], sp[1]))
+            else:
+                spans.append(sp)
+            m = spans[-1][1] + 1
+        else:
+            m += 1
+    if not spans:
+        continue
+    for (m0, m1) in spans:
+        ids = inl[m0:m1 + 1]
+        if len(ids) == len(h['ids']):
+            continue
+        npos = [q for i, q in zip(h['ids'], h['pos']) if i in ids]
+        h['pos'] = [q for i, q in zip(h['ids'], h['pos']) if i not in ids]
+        h['ids'] = [i for i in h['ids'] if i not in ids]
+        H.append(dict(k=h['k'], path=h['path'], ids=ids, pos=npos, before=None, after=None,
+                      encl=h['encl'], inparen=False))
+        n = len(H) - 1; key[n] = key[hi]
+        if hi in why: why[n] = why[hi]
+        for i in ids: insh[(h['path'], i)] = n
+        htok[n] = tokens_of(n); nsplit += 1
+        L(f'name split: old{h["k"]} {h["path"]} {len(ids)}l: {w["t"][ids[0]].strip()[:70]}')
+    htok[hi] = tokens_of(hi)
+globintro = build_globintro(); declrx.clear()
+L(f'names: {len(globintro)} new to the tree, {nsplit} statements split out')
+
+# a static function's definition waits for its first user: split each new
+# static function out of its hunk; the fixpoint holds it until a use lands
+FNRX = re.compile(r'^static\s+(?!inline\b)[^;=]*?\b([A-Za-z_][A-Za-z0-9_]*)\(')
+defs = {}
+for hi in range(len(H)):
+    h = H[hi]; w = W[h['path']]; t = w['t']
+    if not h['path'].endswith('.c'):
+        continue
+    m = -1
+    while True:
+      inl = [i for i in h['ids'] if w['ins'][i] == h['k']]
+      m += 1
+      if m >= len(inl):
+          break
+      if True:
+        i = inl[m]
+        mm = FNRX.match(t[i])
+        if not mm or not newname(mm.group(1)):
+            continue
+        adj = lambda a, b: h['pos'][h['ids'].index(inl[b])] - h['pos'][h['ids'].index(inl[a])] == 1
+        m0 = m
+        while m0 > 0 and adj(m0 - 1, m0) and t[inl[m0 - 1]].lstrip().startswith(('/*', '*', '//')):
+            m0 -= 1
+        m1 = m
+        while m1 + 1 < len(inl) and adj(m1, m1 + 1) and t[inl[m1]] != '}\n':
+            m1 += 1
+        if t[inl[m1]] != '}\n':
+            continue
+        if m1 + 1 < len(inl) and adj(m1, m1 + 1) and t[inl[m1 + 1]] == '\n':
+            m1 += 1
+        ids = inl[m0:m1 + 1]
+        if len(ids) == len(h['ids']):
+            defs[hi] = mm.group(1); continue
+        npos = [q for x, q in zip(h['ids'], h['pos']) if x in ids]
+        h['pos'] = [q for x, q in zip(h['ids'], h['pos']) if x not in ids]
+        h['ids'] = [x for x in h['ids'] if x not in ids]
+        m = m0 - 1
+        H.append(dict(k=h['k'], path=h['path'], ids=ids, pos=npos, before=None,
+                      after=None, encl=[], inparen=False))
+        n = len(H) - 1; key[n] = key[hi]
+        if hi in why: why[n] = why[hi]
+        for x in ids: insh[(h['path'], x)] = n
+        htok[n] = tokens_of(n); htok[hi] = tokens_of(hi); defs[n] = mm.group(1)
+globintro = build_globintro(); declrx.clear()
+firstk = {t: min(H[g]['k'] for g in lst) for t, lst in globintro.items()}
+users = {}
+for g in range(len(H)):
+    for (_, tname) in htok[g]:
+        users.setdefault(tname, []).append(g)
+def def_need(hi):
+    f = defs.get(hi)
+    if f is None:
+        return None
+    us = [g for g in users.get(f, []) if g != hi and H[g]['path'] == H[hi]['path']]
+    if not us or any(key[g] <= key[hi] for g in us):
+        return None
+    m = min(key[g] for g in us)
+    return (m, f, H[min(us, key=lambda g: key[g])]['k'])
+L(f'static function definitions tracked: {len(defs)}')
+def name_need(hi):
+    best = None
+    for (t, kk, j) in late_names(hi, htok[hi], keyed=True):
+        if best is None or kk > best[0]:
+            best = (kk, t, j)
+    return best
+
+def reopens(j, i):
+    """hunk j inserted opener line i in place of a line that opened too"""
+    w = W[H[j]['path']]; tk = '/*' if '/*' in w['t'][i] else '{'
+    return any(w['dele'][d] == H[j]['k'] and tk in w['t'][d] for d in H[j]['ids'])
+
+# ---- fixpoint -------------------------------------------------------------------
+changed_any = True; rounds = 0
+while changed_any:
+    changed_any = False; rounds += 1
+    for hi, h in enumerate(H):
+        w = W[h['path']]; need = None; reason = None
+        for i in h['ids']:
+            if w['dele'][i] == h['k'] and w['ins'][i]:
+                j = insh[(h['path'], i)]
+                if key[j] > key[hi] and (need is None or key[j] > need):
+                    need, reason = key[j], f'deletes a line of old {H[j]["k"]}'
+        if h.get('inparen'):
+            # inside a multi-line argument list (a format string and its
+            # arguments): between two later-placed lines, the list's
+            # punctuation is theirs
+            nb = [insh.get((h['path'], i)) for i in (h['before'], h['after']) if i is not None]
+            if len(nb) == 2 and None not in nb and all(key[j] > key[hi] for j in nb):
+                m = max(key[j] for j in nb)
+                if need is None or m > need:
+                    jj = next(j for j in nb if key[j] == m)
+                    need, reason = m, f'sits inside an argument list of old {H[jj]["k"]}'
+        for i in h['encl']:
+            j = insh.get((h['path'], i))
+            if j is not None and reopens(j, i):
+                continue    # j rewrote an opener that was already there
+            if j is not None and key[j] > key[hi] and (need is None or key[j] > need):
+                need, reason = key[j], f'sits inside a block of old {H[j]["k"]}'
+        nn = name_need(hi)
+        if nn and (need is None or nn[0] > need):
+            need, reason = nn[0], f'uses {nn[1]} from old {nn[2]}'
+        if need is not None:
+            src = order[need[0]] if len(need) == 2 else None
+            if src is not None and (h['k'], src) in FOLD:
+                # the edit adapts src's code to an interface that, in the
+                # new order, exists before src: src is written against it
+                key[hi] = need; why[hi] = f'folded into old {src}: {reason}'
+            else:
+                key[hi] = need + (1, slot[h['k']]); why[hi] = reason
+            changed_any = True
+        if DEFER and CLS[h['k']] == DEFER[0] and len(key[hi]) > 2 and key[hi][2] != 2 and \
+                CLS[order[key[hi][0]]] == DEFER[1]:
+            last = max(slot[o] for o in order if CLS[o] == DEFER[1])
+            key[hi] = (last, 0, 2, slot[h['k']]); why[hi] = (why.get(hi, '') + '; after the ' +
+                                                              TAG[DEFER[1]] + ' subtopic').lstrip('; ')
+            changed_any = True
+        dn = def_need(hi)
+        if dn:
+            # into its first user's commit: defined where it is first used
+            L(f'def move: old{h["k"]} {dn[1]} {key[hi]} -> {dn[0]} (user old{dn[2]})')
+            key[hi] = dn[0]; why[hi] = f'defines {dn[1]} for its first user, old {dn[2]}'
+            changed_any = True
+    for (k0, p, rxs) in JOIN:
+        hs = [hi for hi, h in enumerate(H) if h['k'] == k0 and (p is None or h['path'] == p) and
+              any(re.search(rx, l[1:]) for l in lines_of(h) for rx in rxs)]
+        m = max(key[hi] for hi in hs)
+        for hi in hs:
+            if key[hi] != m:
+                key[hi] = m; why[hi] = f'joined with its other hunks in {p or "the patch"}'; changed_any = True
+L(f'fixpoint rounds: {rounds}')
+
+# ---- commits --------------------------------------------------------------------
+groups = {}
+for hi, kk in key.items():
+    groups.setdefault(kk, []).append(hi)
+keys = sorted(groups)
+def src_of(kk):
+    return order[kk[-1]] if len(kk) > 2 else order[kk[0]]
+def sub_of(kk):
+    if DEFER and len(kk) > 2 and kk[2] == 2:
+        return DEFER[2]
+    return CLS[order[kk[0]]]
+mainseen = set()
+withmain = {src_of(k2) for k2 in keys if len(k2) == 2}
+idx = dict(GIT_INDEX_FILE=os.path.join(TMPD, 'w.index')); ienv = dict(env0, **idx)
+git('read-tree', base, env=ienv)
+applied = set(); acc = base; out = []
+for kk in keys:
+    src = src_of(kk)
+    for hi in groups[kk]:
+        applied.add(hi)
+    paths = sorted({H[hi]['path'] for hi in groups[kk]})
+    for p in paths:
+        w = W[p]
+        def on(i):
+            if w['ins'][i] and insh[(p, i)] not in applied: return False
+            if w['dele'][i] and delh[(p, i)] in applied: return False
+            return True
+        content = ''.join(w['t'][i] for i in w['order'] if on(i))
+        bl = git('hash-object', '-w', '--stdin', '--path', p, inp=content).stdout.strip()
+        git('update-index', '--add', '--cacheinfo', f'100644,{bl},{p}', env=ienv)
+    tree = git('write-tree', env=ienv).stdout.strip()
+    if src in SYN:
+        (an, ae), ad = SYN[src]['author'], SYN[src]['date']
+    else:
+        sha = orig[src - 1]
+        an, ae, ad = git('log', '-1', '--format=%an%x00%ae%x00%ad', '--date=raw', sha).stdout.strip().split('\0')
+    cenv = dict(env0, GIT_AUTHOR_NAME=an, GIT_AUTHOR_EMAIL=ae, GIT_AUTHOR_DATE=ad)
+    ismain = len(kk) == 2 or (src not in withmain and src not in mainseen)
+    if src in SYN and out and out[-1]['src'] in SYN and \
+            SYN[out[-1]['src']]['group'] == SYN[src]['group'] and out[-1]['sub'] == sub_of(kk):
+        # the group's previous commit: one commit
+        prevc = out.pop()
+        acc = git('rev-parse', prevc['sha'] + '^').stdout.strip()
+        acc = git('commit-tree', tree, '-p', acc, inp=SYN[src]['msg'], env=cenv).stdout.strip()
+        nl = prevc['lines'] + sum(len(H[hi]['ids']) for hi in groups[kk])
+        rs = sorted(set(prevc['why']) | {why[hi] for hi in groups[kk] if hi in why})
+        out.append(dict(prevc, sha=acc, srcs=prevc.get('srcs', [prevc['src']]) + [src],
+                        hunks=prevc['hunks'] + len(groups[kk]), lines=nl,
+                        files=sorted(set(prevc['files']) | set(paths)), why=rs))
+        L(f'{len(out):3d} S{sub_of(kk)} synth{src} merged into the previous commit {acc[:12]} l={nl}')
+        continue
+    if src in SYN:
+        msg = SYN[src]['msg']; kind = 'new'; mainseen.add(src)
+    elif ismain:
+        raw = git('cat-file', 'commit', sha).stdout
+        msg = raw[raw.index('\n\n') + 2:]; mainseen.add(src); kind = 'main'
+    else:
+        tag = TAG[sub_of(kk)]
+        n = sum(1 for o in out if o['src'] == src and o['tag'] == tag) + 1
+        sfx = f' {n}' if n > 1 else ''
+        reasons = sorted({why.get(hi, '') for hi in groups[kk]})
+        tgt = order[kk[0]] if len(kk) == 4 else None
+        if any(r.startswith('subtopic') for r in reasons):
+            body = f'its hunks in the {tag} subtopic\'s code.'
+        else:
+            body = (f'its hunks that need code from\n"{subj[order[kk[0]]]}",\n'
+                    f'which comes later in the new order.')
+        msg = (f'{subj[src]} ({tag} part{sfx})\n\nSplit from "{subj[src]}"\n'
+               f'for the subtopic reorder: {body}\n\nAssisted-by: Claude:claude-opus-5-5\n')
+        kind = 'part'
+    acc = git('commit-tree', tree, '-p', acc, inp=msg, env=cenv).stdout.strip()
+    nl = sum(len(H[hi]['ids']) for hi in groups[kk])
+    rs = sorted({why[hi] for hi in groups[kk] if hi in why})
+    out.append(dict(sha=acc, key=list(kk), src=src, sub=sub_of(kk), tag=TAG[sub_of(kk)], kind=kind,
+                    hunks=len(groups[kk]), lines=nl, files=paths, why=rs, subject=msg.splitlines()[0]))
+    L(f'{len(out):3d} S{sub_of(kk)} old{src!s:<3s} {kind:4s} {acc[:12]} h={len(groups[kk])} l={nl} {";".join(rs)}')
+git('update-ref', outref, acc)
+json.dump(out, open(os.path.join(TMPD, 'wreplay.json'), 'w'), indent=1)
+import pickle
+pickle.dump(dict(W=W, H=H, key=key, order=order, insh=insh, delh=delh, CLS=CLS), open(os.path.join(TMPD, 'wstate.pkl'), 'wb'))
+L(f'DONE {acc} tree {git("rev-parse", acc + "^{tree}").stdout.strip()}')
+
+# ---- torn-function report: a patch's hunks inside one top-level block
+# (function, struct, initializer) that landed in different commits
+torn = []
+byfn = {}
+for hi, h in enumerate(H):
+    if not h['encl']:
+        continue
+    top = h['encl'][0]
+    byfn.setdefault((h['k'], h['path'], top), []).append(hi)
+for (k, p, top), his in byfn.items():
+    ks = sorted({key[hi] for hi in his})
+    if len(ks) > 1:
+        w = W[p]
+        torn.append(dict(old=k, path=p, block=w['t'][top].strip()[:90],
+                         parts=[dict(key=list(kk), sub=CLS[order[kk[0]]], hunks=[hi for hi in his if key[hi] == kk],
+                                     lines=sum(len(H[hi]['ids']) for hi in his if key[hi] == kk)) for kk in ks]))
+json.dump(torn, open(os.path.join(TMPD, 'torn.json'), 'w'), indent=1)
+L(f'torn blocks: {len(torn)}')
+for t_ in torn:
+    L(f"TORN old{t_['old']} {t_['path']} [{t_['block']}] " +
+      ' | '.join(f"S{x['sub']}:{x['lines']}l" for x in t_['parts']))
diff --git a/scripts/sa-reorder/bin/zmerge.py b/scripts/sa-reorder/bin/zmerge.py
new file mode 100644 (file)
index 0000000..38615d0
--- /dev/null
@@ -0,0 +1,131 @@
+#!/usr/bin/python3 -I
+# Zealous line-level 3-way merge: accepts adjacent but non-overlapping edits.
+# Usage as module: zmerge(base, ours, theirs) -> (lines or None, conflicts)
+import subprocess, re, tempfile, os
+
+def edits(a, b, tmpdir, algo='histogram'):
+    pa = os.path.join(tmpdir, 'a'); pb = os.path.join(tmpdir, 'b')
+    open(pa, 'w').write(''.join(a)); open(pb, 'w').write(''.join(b))
+    r = subprocess.run(['git', 'diff', '--no-index', '--no-color', '-U0',
+                        f'--diff-algorithm={algo}', pa, pb],
+                       capture_output=True, text=True)
+    out = []
+    for l in r.stdout.splitlines():
+        m = re.match(r'^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@', l)
+        if not m:
+            continue
+        s1 = int(m.group(1)); n1 = int(m.group(2) if m.group(2) is not None else 1)
+        s2 = int(m.group(3)); n2 = int(m.group(4) if m.group(4) is not None else 1)
+        bs = s1 if n1 == 0 else s1 - 1      # 0-based start in a
+        cs = s2 if n2 == 0 else s2 - 1
+        out.append((bs, bs + n1, b[cs:cs + n2]))
+    return out
+
+def findblock(final, blk):
+    if not final or not blk: return None
+    n = len(blk)
+    for i in range(len(final) - n + 1):
+        if final[i] == blk[0] and final[i:i + n] == blk:
+            return i
+    # fall back to a line of the block that occurs exactly once in final
+    for l in blk:
+        if len(l.strip()) > 8 and final.count(l) == 1:
+            return final.index(l)
+    # fall back to a distinctive identifier of the block
+    import re
+    text = ''.join(final)
+    for l in blk:
+        for tok in re.findall(r'\b[A-Za-z_][A-Za-z0-9_]{9,}\b', l):
+            hits = [i for i, fl in enumerate(final) if re.search(r'\b' + tok + r'\b', fl)]
+            if len(hits) == 1:
+                return hits[0]
+    return None
+
+def interleave(final, A, B):
+    # merge two inserted blocks by their lines' positions in final; None if
+    # a block has no line locatable in final
+    import re
+    def keys(blk):
+        ks = []; last = None
+        for l in blk:
+            k = None
+            if l.strip() and final.count(l) == 1:
+                k = final.index(l)
+            ks.append(k)
+        if all(k is None for k in ks):
+            return None
+        # fill gaps: lines before the first anchor take it, others inherit
+        first = next(k for k in ks if k is not None)
+        out = []; cur = first
+        for k in ks:
+            if k is not None: cur = k
+            out.append(cur)
+        return out
+    ka, kb = keys(A), keys(B)
+    if ka is None or kb is None:
+        return None
+    # monotone check
+    if ka != sorted(ka) or kb != sorted(kb):
+        return None
+    res = []; i = j = 0
+    while i < len(A) or j < len(B):
+        if j >= len(B) or (i < len(A) and ka[i] <= kb[j]):
+            res.append(A[i]); i += 1
+        else:
+            res.append(B[j]); j += 1
+    return res
+
+def zmerge(base, ours, theirs, final=None):
+    best = None
+    with tempfile.TemporaryDirectory() as td:
+        for ao in ('histogram', 'patience', 'minimal', 'myers'):
+            for at in ('histogram', 'patience', 'minimal', 'myers'):
+                eo = edits(base, ours, td, ao)
+                et = edits(base, theirs, td, at)
+                r = _zmerge(base, eo, et, final) + (et,)
+                if r[0] is not None:
+                    return r
+                if best is None:
+                    best = r
+    return best
+
+def _zmerge(base, eo, et, final=None):
+    order = {}; merged = {}
+    conflicts = []
+    for (a, b, nl) in eo:
+        for (c, d, tl) in et:
+            if max(a, c) < min(b, d):
+                conflicts.append(((a, b, nl), (c, d, tl)))
+            elif a == b == c == d:
+                if nl != tl:
+                    fo, ft = findblock(final, nl), findblock(final, tl)
+                    if fo is None or ft is None or fo == ft:
+                        conflicts.append(((a, b, nl), (c, d, tl)))
+                    else:
+                        il = interleave(final, nl, tl)
+                        if il is None:
+                            order[(c, tuple(tl))] = 1 if ft > fo else -1
+                        else:
+                            merged[(c, tuple(tl))] = il
+            elif a == b and c < a < d:
+                conflicts.append(((a, b, nl), (c, d, tl)))
+            elif c == d and a < c < b:
+                conflicts.append(((a, b, nl), (c, d, tl)))
+    if conflicts:
+        return None, conflicts
+    # identical same-point insertions: keep one
+    mpt = {k[0]: v for k, v in merged.items()}
+    allx = [(a, b, (mpt[a] if a == b and a in mpt else nl), 0) for (a, b, nl) in eo]
+    for (c, d, tl) in et:
+        if any(a == b == c == d and nl == tl for (a, b, nl) in eo):
+            continue
+        if (c, tuple(tl)) in merged:
+            continue
+        allx.append((c, d, tl, order.get((c, tuple(tl)), 1)))
+    # order: by start; at the same point, pure insertions before replacements
+    allx.sort(key=lambda e: (e[0], e[1] - e[0], e[3]))
+    res = []; pos = 0
+    for (a, b, nl, _) in allx:
+        res.extend(base[pos:a]); res.extend(nl); pos = max(pos, b)
+    res.extend(base[pos:])
+    return res, []
diff --git a/scripts/sa-reorder/build-one2.sh b/scripts/sa-reorder/build-one2.sh
new file mode 100644 (file)
index 0000000..eb8de3f
--- /dev/null
@@ -0,0 +1,12 @@
+#!/bin/bash
+# build-one2.sh REF LABEL CONFIG: W=1 fs/btrfs + bzImage of REF with CONFIG, logs in logs-LABEL/
+cd /mnt/linux/wt-osord-mn || exit 1
+L=logs-$2; mkdir -p $L; rm -f $L/status
+git checkout -q --detach "$1" || { echo "checkout rc=1" > $L/status; exit 1; }
+git log -1 --format="%H %s" > $L/head
+cp "$3" .config
+make olddefconfig > $L/olddefconfig.log 2>&1; echo "olddefconfig rc=$?" >> $L/status
+make -j8 W=1 fs/btrfs/ > $L/w1.log 2>&1; echo "w1 rc=$?" >> $L/status
+make -j8 bzImage > $L/bzimage.log 2>&1; echo "bzImage rc=$?" >> $L/status
+ls -l --time-style=+%T arch/x86/boot/bzImage >> $L/status 2>&1
+echo done >> $L/status
diff --git a/scripts/sa-reorder/class.v10 b/scripts/sa-reorder/class.v10
new file mode 100644 (file)
index 0000000..170dcda
--- /dev/null
@@ -0,0 +1,116 @@
+1 1
+2 1
+3 1
+4 1
+5 1
+6 1
+7 6
+8 1
+9 1
+10 1
+11 1
+12 1
+13 4
+14 1
+15 4
+16 4
+17 1
+18 2
+19 2
+20 2
+21 2
+22 1
+23 1
+24 1
+25 1
+26 1
+27 1
+28 6
+29 6
+30 1
+31 1
+32 1
+33 1
+34 1
+35 1
+36 1
+37 1
+38 5
+39 6
+40 1
+41 1
+42 5
+43 1
+44 1
+45 1
+46 3
+47 5
+48 5
+49 5
+50 5
+51 5
+52 5
+53 5
+54 1
+55 6
+56 2
+57 1
+58 2
+59 1
+60 1
+61 5
+62 1
+63 1
+64 1
+65 5
+66 2
+67 1
+68 1
+69 1
+70 3
+71 6
+72 6
+73 1
+74 1
+75 1
+76 1
+77 1
+78 1
+79 1
+80 6
+81 5
+82 1
+83 4
+84 1
+85 2
+86 1
+87 1
+88 4
+89 1
+90 2
+91 1
+92 1
+93 5
+94 6
+95 1
+96 1
+97 1
+98 1
+99 1
+100 2
+101 1
+102 5
+103 2
+104 5
+105 5
+106 5
+107 6
+108 6
+109 1
+110 1
+111 5
+112 5
+113 6
+114 5
+115 5
+116 3
diff --git a/scripts/sa-reorder/class.v11 b/scripts/sa-reorder/class.v11
new file mode 100644 (file)
index 0000000..f2959b1
--- /dev/null
@@ -0,0 +1,116 @@
+1 1
+2 1
+3 1
+4 1
+5 1
+6 1
+7 6
+8 1
+9 1
+10 1
+11 1
+12 1
+13 4
+14 1
+15 4
+16 4
+17 1
+18 2
+19 2
+20 2
+21 2
+22 1
+23 1
+24 1
+25 1
+26 1
+27 1
+28 6
+29 6
+30 1
+31 1
+32 1
+33 1
+34 1
+35 1
+36 1
+37 1
+38 5
+39 6
+40 1
+41 1
+42 5
+43 1
+44 1
+45 1
+46 3
+47 5
+48 5
+49 5
+50 5
+51 5
+52 5
+53 5
+54 1
+55 6
+56 2
+57 1
+58 2
+59 1
+60 1
+61 5
+62 1
+63 1
+64 1
+65 5
+66 2
+67 1
+68 1
+69 1
+70 3
+71 6
+72 6
+73 1
+74 1
+75 1
+76 1
+77 1
+78 1
+79 1
+80 6
+81 5
+82 1
+83 4
+84 1
+85 2
+86 1
+87 1
+88 4
+89 1
+90 2
+91 1
+92 1
+93 5
+94 6
+95 1
+96 1
+97 1
+98 1
+99 1
+100 2
+101 1
+102 5
+103 2
+104 5
+105 5
+106 5
+107 6
+108 6
+109 1
+110 1
+111 5
+112 5
+113 3
+114 5
+115 5
+116 3
diff --git a/scripts/sa-reorder/class.v13 b/scripts/sa-reorder/class.v13
new file mode 100644 (file)
index 0000000..4048871
--- /dev/null
@@ -0,0 +1,116 @@
+1 1
+2 1
+3 1
+4 1
+5 1
+6 1
+7 5
+8 1
+9 1
+10 1
+11 1
+12 1
+13 4
+14 1
+15 4
+16 4
+17 1
+18 2
+19 2
+20 2
+21 2
+22 1
+23 1
+24 1
+25 1
+26 1
+27 1
+28 1
+29 7
+30 1
+31 1
+32 1
+33 1
+34 1
+35 1
+36 1
+37 1
+38 6
+39 5
+40 1
+41 1
+42 3
+43 1
+44 1
+45 1
+46 3
+47 3
+48 6
+49 6
+50 6
+51 6
+52 6
+53 6
+54 1
+55 7
+56 2
+57 1
+58 2
+59 1
+60 1
+61 6
+62 1
+63 1
+64 1
+65 6
+66 2
+67 1
+68 1
+69 1
+70 3
+71 5
+72 5
+73 1
+74 1
+75 1
+76 1
+77 1
+78 1
+79 1
+80 5
+81 6
+82 1
+83 4
+84 1
+85 2
+86 1
+87 1
+88 4
+89 1
+90 2
+91 1
+92 1
+93 6
+94 7
+95 1
+96 1
+97 1
+98 1
+99 1
+100 2
+101 1
+102 6
+103 2
+104 6
+105 6
+106 6
+107 7
+108 5
+109 1
+110 1
+111 6
+112 6
+113 3
+114 3
+115 3
+116 3
diff --git a/scripts/sa-reorder/class618.v2 b/scripts/sa-reorder/class618.v2
new file mode 100644 (file)
index 0000000..27f21fc
--- /dev/null
@@ -0,0 +1,132 @@
+1 1
+2 1
+3 1
+4 1
+5 1
+6 6
+7 1
+8 1
+9 1
+10 1
+11 1
+12 1
+13 1
+14 4
+15 1
+16 4
+17 4
+18 1
+19 2
+20 2
+21 2
+22 2
+23 1
+24 1
+25 1
+26 1
+27 1
+28 1
+29 6
+30 6
+31 1
+32 1
+33 1
+34 1
+35 1
+36 1
+37 1
+38 1
+39 5
+40 6
+41 1
+42 1
+43 1
+44 5
+45 1
+46 1
+47 1
+48 3
+49 5
+50 5
+51 5
+52 5
+53 5
+54 5
+55 5
+56 1
+57 6
+58 2
+59 1
+60 2
+61 1
+62 1
+63 1
+64 1
+65 1
+66 1
+67 5
+68 1
+69 1
+70 5
+71 6
+72 1
+73 1
+74 1
+75 1
+76 1
+77 5
+78 2
+79 1
+80 1
+81 1
+82 5
+83 5
+84 3
+85 3
+86 6
+87 6
+88 1
+89 1
+90 1
+91 1
+92 1
+93 1
+94 1
+95 6
+96 5
+97 1
+98 4
+99 1
+100 2
+101 1
+102 1
+103 4
+104 1
+105 2
+106 1
+107 1
+108 5
+109 6
+110 1
+111 1
+112 1
+113 1
+114 1
+115 2
+116 1
+117 5
+118 2
+119 5
+120 5
+121 5
+122 6
+123 6
+124 1
+125 1
+126 5
+127 1
+128 5
+129 6
+130 5
+131 5
+132 3
diff --git a/scripts/sa-reorder/class618.v3 b/scripts/sa-reorder/class618.v3
new file mode 100644 (file)
index 0000000..2fe1480
--- /dev/null
@@ -0,0 +1,132 @@
+1 1
+2 1
+3 1
+4 1
+5 1
+6 6
+7 1
+8 1
+9 1
+10 1
+11 1
+12 1
+13 1
+14 4
+15 1
+16 4
+17 4
+18 1
+19 2
+20 2
+21 2
+22 2
+23 1
+24 1
+25 1
+26 1
+27 1
+28 1
+29 6
+30 6
+31 1
+32 1
+33 1
+34 1
+35 1
+36 1
+37 1
+38 1
+39 5
+40 6
+41 1
+42 1
+43 1
+44 5
+45 1
+46 1
+47 1
+48 3
+49 5
+50 5
+51 5
+52 5
+53 5
+54 5
+55 5
+56 1
+57 6
+58 2
+59 1
+60 2
+61 1
+62 1
+63 1
+64 1
+65 1
+66 1
+67 5
+68 1
+69 1
+70 5
+71 6
+72 1
+73 1
+74 1
+75 1
+76 1
+77 5
+78 2
+79 1
+80 1
+81 1
+82 5
+83 5
+84 3
+85 3
+86 6
+87 6
+88 1
+89 1
+90 1
+91 1
+92 1
+93 1
+94 1
+95 6
+96 5
+97 1
+98 4
+99 1
+100 2
+101 1
+102 1
+103 4
+104 1
+105 2
+106 1
+107 1
+108 5
+109 6
+110 1
+111 1
+112 1
+113 1
+114 1
+115 2
+116 1
+117 5
+118 2
+119 5
+120 5
+121 5
+122 6
+123 6
+124 1
+125 1
+126 5
+127 1
+128 5
+129 3
+130 5
+131 5
+132 3
diff --git a/scripts/sa-reorder/class618.v5 b/scripts/sa-reorder/class618.v5
new file mode 100644 (file)
index 0000000..8520462
--- /dev/null
@@ -0,0 +1,132 @@
+1 1
+2 1
+3 1
+4 1
+5 1
+6 5
+7 1
+8 1
+9 1
+10 1
+11 1
+12 1
+13 1
+14 4
+15 1
+16 4
+17 4
+18 1
+19 2
+20 2
+21 2
+22 2
+23 1
+24 1
+25 1
+26 1
+27 1
+28 1
+29 1
+30 7
+31 1
+32 1
+33 1
+34 1
+35 1
+36 1
+37 1
+38 1
+39 6
+40 5
+41 1
+42 1
+43 1
+44 3
+45 1
+46 1
+47 1
+48 3
+49 3
+50 6
+51 6
+52 6
+53 6
+54 6
+55 6
+56 1
+57 7
+58 2
+59 1
+60 2
+61 1
+62 1
+63 1
+64 1
+65 1
+66 1
+67 6
+68 1
+69 1
+70 6
+71 6
+72 1
+73 1
+74 1
+75 1
+76 1
+77 6
+78 2
+79 1
+80 1
+81 1
+82 6
+83 6
+84 3
+85 3
+86 5
+87 5
+88 1
+89 1
+90 1
+91 1
+92 1
+93 1
+94 1
+95 5
+96 6
+97 1
+98 4
+99 1
+100 2
+101 1
+102 1
+103 4
+104 1
+105 2
+106 1
+107 1
+108 6
+109 7
+110 1
+111 1
+112 1
+113 1
+114 1
+115 2
+116 1
+117 6
+118 2
+119 6
+120 6
+121 6
+122 7
+123 5
+124 1
+125 1
+126 6
+127 1
+128 6
+129 3
+130 3
+131 3
+132 3
diff --git a/scripts/sa-reorder/each-commit2.sh b/scripts/sa-reorder/each-commit2.sh
new file mode 100644 (file)
index 0000000..659903e
--- /dev/null
@@ -0,0 +1,16 @@
+#!/bin/bash
+# each-commit2.sh BASE TIP LABEL CONFIG: W=1 fs/btrfs build of every commit in BASE..TIP
+cd /mnt/linux/wt-osord-mn || exit 1
+L=logs-$3; mkdir -p $L; : > $L/each
+cp "$4" .config
+git checkout -q --detach "$1" && make olddefconfig > /dev/null 2>&1 && make -j8 W=1 fs/btrfs/ > /dev/null 2>&1
+n=0
+for c in $(git rev-list --reverse "$1..$2"); do
+       n=$((n+1))
+       git checkout -q --detach $c || { echo "$n $c checkout-fail" >> $L/each; continue; }
+       make -j8 W=1 fs/btrfs/ > $L/c-$n.log 2>&1; rc=$?
+       w=$(grep -c "warning:" $L/c-$n.log)
+       echo "$n ${c:0:12} rc=$rc warnings=$w" >> $L/each
+       [ $rc = 0 ] && [ $w = 0 ] && rm -f $L/c-$n.log
+done
+echo done >> $L/each
diff --git a/scripts/sa-reorder/oracle-618.txt b/scripts/sa-reorder/oracle-618.txt
new file mode 100644 (file)
index 0000000..61518c3
--- /dev/null
@@ -0,0 +1,16 @@
+PASS 180 commits match the wpost json, linear on base
+PASS final tree = 6602cb54b8e2 + exactly residual-618.diff (56 lines)
+PASS author name/email/date equal the source patch for every old patch's commit ([])
+     new commit dd54cf6f46ae Zygo Blaxell <ce3g8jdj@umail.furryterror.org> 1792702025 -0400 btrfs: stripe_meta: extend stripe reclaim to metadata block groups
+PASS each original patch has exactly one main commit
+PASS messages: original verbatim, or with exactly the spec's edits ([]); edited: ('main', 5), ('main', 13), ('main', 29), ('main', 76), ('main', 44), ('main', 48), ('main', 49), ('main', 84), ('main', 130), ('main', 14), ('part', 29, 1)
+PASS no Signed-off-by/Co-Authored-By/cherry-pick line anywhere; one opus Assisted-by on parts and new commits, at most one on edited ones ([])
+PASS no empty commits (0)
+PASS subtopics contiguous and in order: S1:#1-77 S2:#78-101 S3:#102-113 S4:#114-126 S5:#127-138 S6:#139-167 S7:#168-180
+     before the stripe_meta subtopic (7be4b9cd9743): lines naming stripe_meta per file:
+       fs/btrfs/block-group.c:1
+       fs/btrfs/block-group.h:2
+       fs/btrfs/extent-tree.c:1
+       fs/btrfs/raid56.c:1
+       fs/btrfs/space-info.h:1
+ORACLE PASS
diff --git a/scripts/sa-reorder/oracle-mn.txt b/scripts/sa-reorder/oracle-mn.txt
new file mode 100644 (file)
index 0000000..356f1ae
--- /dev/null
@@ -0,0 +1,16 @@
+PASS 164 commits match the wpost json, linear on base
+PASS final tree = a23064467620 + exactly residual-mn.diff (56 lines)
+PASS author name/email/date equal the source patch for every old patch's commit ([])
+     new commit 9a8bbe5a53a5 Zygo Blaxell <ce3g8jdj@umail.furryterror.org> 1792702025 -0400 btrfs: stripe_meta: extend stripe reclaim to metadata block groups
+PASS each original patch has exactly one main commit
+PASS messages: original verbatim, or with exactly the spec's edits ([]); edited: ('main', 4), ('main', 6), ('main', 28), ('main', 42), ('main', 46), ('main', 47), ('main', 70), ('main', 114), ('main', 13), ('part', 28, 1)
+PASS no Signed-off-by/Co-Authored-By/cherry-pick line anywhere; one opus Assisted-by on parts and new commits, at most one on edited ones ([])
+PASS no empty commits (0)
+PASS subtopics contiguous and in order: S1:#1-66 S2:#67-89 S3:#90-101 S4:#102-114 S5:#115-126 S6:#127-151 S7:#152-164
+     before the stripe_meta subtopic (629f454670c4): lines naming stripe_meta per file:
+       fs/btrfs/block-group.c:1
+       fs/btrfs/block-group.h:2
+       fs/btrfs/extent-tree.c:1
+       fs/btrfs/raid56.c:1
+       fs/btrfs/space-info.h:1
+ORACLE PASS
diff --git a/scripts/sa-reorder/order.orig116 b/scripts/sa-reorder/order.orig116
new file mode 100644 (file)
index 0000000..1942f75
--- /dev/null
@@ -0,0 +1,116 @@
+f8aefd3a65eef1fc6ca498e3f7d34fd24bd2d1aa orig1
+e4a454e34f91c3246fb8a922f3e472b546622e33 orig2
+a240872477979ccf01ce59b6481be002eac1d59d orig3
+34e5adb74d1c65145b60d1a79aac6ba32cf9f5a2 orig4
+f4900f9d5af6f1fcf7328e5c15eafef33ac4e37d orig5
+dc05aa382bdb79b8f81db968b8d96236d5350ebb orig6
+c332d36b889a12ff768cdd448c5b31f72374837e orig7
+ee439d57937755a384015dabef3bd5fea72283c7 orig8
+a3f76d9a2a78b3892650a7be8380d418b53e761a orig9
+05efb9e0701c1438661bf6ac88349252b9a2c8ee orig10
+19fdab82489824f188e6656c429f9f44d633c593 orig11
+d012dbc97bfc5dc275a789a7e3c464efa09851f6 orig12
+14839547353dd2ff06d13c3a321b286878abf7c1 orig13
+36f2da531ea7492f5eadadcbcc1865d5e7bfec58 orig14
+720d3e3ab3b0c4ed892edddf9a210034a30dd06b orig15
+bdc754626ebf4622fdb443bf7618eb55d626bf1c orig16
+a737dc4313e4b2f0d01d818cb220ae1b79682676 orig17
+56d65bde49a8f81bcbcbea7083ff885ceb6edeb7 orig18
+7a2128a6af7b447537f4ce836354b9071f914cc4 orig19
+ff24d23dc643075ff828e20456e26b7fafb21566 orig20
+aee560fcabf96893e8ec946cfcb4693942e697c3 orig21
+45a865e1a62c17737f0839e3178dd45790b9999a orig22
+a7895fde7eb406a254050d73cca1962ec84111e9 orig23
+807bda7889b06996e4506808acb3a7536a460d8d orig24
+697d334f1241e81347df4ce5a5eab5a7fa90352d orig25
+b639bc5d11cf7bddb4d4237ab937eadad2f0a677 orig26
+7a956b197fb633fae63d44cea3d3aba1ab518989 orig27
+cde49689a8ca53fa1964cc93e1afc3ac5329368a orig28
+3758928da147179fac4d9ecdbd3e6c703eda36d1 orig29
+9bd6e8e81e4445fb261378e2f6386fc195cfe535 orig30
+addef1dec9727eecb057bc479be793829bd049f7 orig31
+ba78c5bdb23c33d2159470c5a0b11b182ab90aa8 orig32
+470e5e7b910d21431589778c95abc362bc6c1712 orig33
+5eecaf54aa231b7e7a6bc68f5f16b905aee89bbb orig34
+db091c0b27f9c41bde8be5b39e01f1dc63cf2a25 orig35
+aff2aee44cbf33530bdb4578906ef260a084049d orig36
+46fa2be98daec9cc359d0f216cd6725837f142b5 orig37
+4b4d6efe8d64cc91a3d94c7de469b449fa6cf16e orig38
+4d8e0574bf5043d83a69e17e41ec1e48fbaea885 orig39
+3962fc1138c917d8bef1818bc692eb54b7e6e501 orig40
+8fd5354672fd14d804216a575c2ec72e5ad6c950 orig41
+6cbe3c02a360975097941fd3a390fd607a3c9c1f orig42
+62886760223cf86cadcd40bfca85e7db871ef4f0 orig43
+acf9c88ceacb8d92f6a5fbc83674f1d3196864c3 orig44
+8907d8718d7362ec87fc3f669bb819a07b1a9f57 orig45
+1646d2e379cbc9675bd69a08ea24ba28af54c64d orig46
+15b5f3d5a5f85702371cb95182b011bfcf3754e6 orig47
+6c71f48b7ba8a42c9cf25656b8c5e199be0e22e8 orig48
+dcb5f0fbf44351d3d5ef2175b66c35649609deb8 orig49
+04bca28a857b67ce23c2b2a8805cb17eca9bbd4b orig50
+7cff178b3a5b7d534853720b13afc9fb1021acbd orig51
+dafd9cfe4b2fdba8bea8b5293b466176a027531b orig52
+4186b21d2136070c7e62e6ac601cb081752329c1 orig53
+a672e3917d47044aece23d6b98ff97c10ef29f16 orig54
+7310972a63b8be7d9d744724270bf91f6e6f099b orig55
+3ba7acf2e3c5e7ab07529aff1b016b49f0a8de40 orig56
+72db9e2da64153d2e8f18458e596483dab5902e5 orig57
+8d46931722459e4cace54fe7215127319d21744a orig58
+3e051c111fc267a5cc6ba4d9697008d527787ebe orig59
+e6d0215595c784679b9190d820a1ece1741b7bc0 orig60
+9c3f5e2a5a7c2e6b251c0014c132b7341065a71f orig61
+6269c79f5f2d9e468f4bb02952cb0cef6dae89d4 orig62
+ec648ceaf7412f288964cd2f969132a3c886478a orig63
+d7611f8eab54eddec75365914a085acbfe30808f orig64
+5f54dd568678edd647946e21d412f18c0aa344a4 orig65
+b57d7b9fd543eb50dcd6f234944b65cc5cc12eed orig66
+be6877e4568053ef1d4b08e76f14ff5d7514345d orig67
+24b8a9adadc5b04e224ff065efde5cde14e3e2a3 orig68
+22e42d6d532311a8e03edbb8b36a73668ad6e173 orig69
+9997aec01d002fa95fc96f0372fdab6f30f74882 orig70
+a4e8a846911c3922128fb10291ebf3a8113e0b09 orig71
+e463b8e99b116061c0753e4af1e2aa570dec4222 orig72
+44a1ac24083c094fe75d4a6f4eb9ed05b13af283 orig73
+c0886d0274af757dfa3f0be8a04667ea3e62c481 orig74
+ec70174eab1dd00bf3a251c225b0398b4bd8e490 orig75
+42d7b94bd97d9a38d48feb9f02a358654e5c4450 orig76
+2cf425545c69f0ec8986ea2d89e4aea793b853f4 orig77
+0e3f67ce778d663cc44348ec94ac9ef7962b170c orig78
+d0d2b845edfcf2bcfc16d4a2562f087f8ee560ce orig79
+d3436b335250591f54e6bd2c2413d7ca419d5071 orig80
+944f4a24fde392601ff2682d2eb6bc17281439f0 orig81
+6b52ac73acdfa4e81dc4e827b1b54ce8bc26ce25 orig82
+b0b570899c985d633a47d9dcb1144ccd2fda84e7 orig83
+edc9be873c6a389b67257aa21cf32bde2ae54133 orig84
+526336dd1cb564cd03541dc94f64468e79f1b779 orig85
+0249bfbd944033b29a18765023fefb579cba70df orig86
+f1dcc0c8b7309bba72e1afcf78102c4c3ac2c5cf orig87
+1453b4c48e63017f615c10544b4235189786cf97 orig88
+6ca617a49aa15b8ec9b8c7081d1eb2d7507f3f17 orig89
+4601d72544d8953d695c8f433281690b56ef8c80 orig90
+bbaa5b42965f3c3a970b39e326f3b6c1dfe9d04c orig91
+3b6b54b00a4ed9c96d123c335c93e3114923d4b4 orig92
+ca3101c29dcae3ba3d91ba482cf52ec293a12252 orig93
+e3dbeeb1a01086b92143ecb56f6c1725a08dbd44 orig94
+35ac1b2bd14ce5778f590dbff49320ac7750f1fc orig95
+3bdfa7627870621a7dff695e25079fb4d77f86ca orig96
+7ff9ffb31eedb49f8c241d91098520668eccd568 orig97
+135c4cb527ac0bc0111b37dba64144b2cb73338a orig98
+298f642fc8d19cf79aa54bc8be36dfd0b9eafa43 orig99
+778a1ddcdd8631bd4727f83e0cb42c05db605b62 orig100
+5b09cd9ba9aeeafe54ca703dbc86bf8d7631ac1c orig101
+c85af373e485e1318e807ed24e2637e2eeaff7a9 orig102
+5571f78278ce68eb576cb4699b3163c73ee669aa orig103
+b10ebcd041372e1dcc2caf3f83d25d6507b9af56 orig104
+90f0201fde06e9443c9a760e358581ed631740a5 orig105
+bbc77261bfccfb82874222569e9b7f647e08ce5f orig106
+1fcae9e2ff2dfbc8b6f2514e9eb6b2fd4f8ef18f orig107
+ddcc84d0004077983aec60e5e6cd948b25f58caf orig108
+2c86e702355125e0779d667a08699cf34da557e9 orig109
+3a14de399288d7d5aea4e241184b0be04e773a58 orig110
+a1ba776d84f34898257042e6cc7e8426938c3453 orig111
+52074eb4d12ef3850757554d6533f24cd258c362 orig112
+0900c2bcd6b290ba88d4bdea5d4f68477ad74aee orig113
+bcadbfc8ac020ccc7fddf79e5530322e3fb98747 orig114
+43d8f35586e64dd7087aaa1c5979dcc993d05cf2 orig115
+a23064467620f3d39e4cc8c71b5ae12a9bab7572 orig116
diff --git a/scripts/sa-reorder/order618.orig132 b/scripts/sa-reorder/order618.orig132
new file mode 100644 (file)
index 0000000..11372f6
--- /dev/null
@@ -0,0 +1,132 @@
+6ae381cd9e0998385ab027c1fdfdedfd0434b6b3 o618_1
+f3bd4803fbdf4b68e808f436e44753883db9953d o618_2
+afb5aff1b684577e5e5b1d05bf999624c17037c3 o618_3
+5603c7c06de56c7a9fea0bc39b63acdae52f1806 o618_4
+5e6b2edd5e06a512a0c90f6833629cf0b86fb30c o618_5
+c80b4c2c388f587ac458264b6381e36b082d8b4d o618_6
+95dfa57de912f3e5a96ad44e3d02597d58143cdd o618_7
+47ca7a971058efe8a94200e654cf06240c9c45e1 o618_8
+5ef2464912b2c133295a0c345b3c6763d0486e5c o618_9
+c5f78831cfedec7d8722b2843cd717daae180e40 o618_10
+3c40140c1795a6298b1a19269424ff35af5c3b95 o618_11
+6a2588d64aec25dc64866a090269b2b82d6bdd84 o618_12
+de9f45731cfe6bac579ddd74c57b66799117ca09 o618_13
+a757e742dbcdf942258873465423d97a07cdc2e2 o618_14
+a08032973d43d3711919bb8f24bef614f6ced6e8 o618_15
+0ae1150b54cd627018ff74cb84c4437009d87439 o618_16
+ccb2967923695917349db1e19d01d531bd1eb2ae o618_17
+0d2b0295b3815aa0fc3caadd4be29566c2af06c3 o618_18
+395b0f1c92ed90354f99a0fe32c8fc43ca99e5f8 o618_19
+72e40738ddc8b41ca926a9ebbe76614bfc8b3e59 o618_20
+eacbef2c319841f119ebc2818927da6753a9ce2b o618_21
+86ff077bf59960a0dd40abdf243096358a982f8a o618_22
+909d4ae447ff080bb2911fd29b13b82b0879d2bf o618_23
+180f9ad1e4a961934e4a8aaea04c9b21801d3ba2 o618_24
+98de5a78a6eec0212538299077e828765e6e00b4 o618_25
+2bf1a947f3c950503779e80999d69583205433ff o618_26
+c5f5440e550233d992f6c79b23eb117cf56085c6 o618_27
+f67eb73e75acb54b674c28ca386d4d613375c194 o618_28
+ec0c3752a9deab9d11b29a7f8e7acee715cfb50c o618_29
+1c4182623f8b7ae46c13d0c492aa41c60142ed6f o618_30
+a61721e671dc9373e0b1df03a8058c1ebda93fcb o618_31
+15e8321de6a641e057ece9e8c3e4bf9f40c5e2a9 o618_32
+0b1bcff8b6457bd7721ea1898194b9a30fdbb59f o618_33
+2ab1bc346c27f23c4d9fcccc08898730d16c6b27 o618_34
+0341c607b6a6484bb812a1f376bcd8532897d108 o618_35
+69d5f2ad9b26af9c14ae1efd8b2d69c449d6ebfb o618_36
+2ac8b4683fb910a868d6a5773cd228e68d217400 o618_37
+4c74cbad8ab526fed37cbcd9d496c75443aa1edb o618_38
+5adb6250c945b7cad393b70dc8a2278c8979fd2b o618_39
+d9ef6c5cdba377a5477856b4fa5d24707847f2b9 o618_40
+4dc5130eae7b89af11c3dbf4f47ad8b58e4f9041 o618_41
+acab5e7b9b6126b36b7c0b9053948b96ecf10816 o618_42
+fac5a8561bf1e6fdae8c251782ea2cb5653c973e o618_43
+2951cbf32730a8dfe180f858f87a11cd5edeeb15 o618_44
+d3dc73fff510b00ad350a980bff6f75bddeefe4b o618_45
+285d910a4b4d86ddc0fbd2fd83c0f625468b2d88 o618_46
+2ca7aec16798ed4376b21b969ee3444070c90a4d o618_47
+5a6c8573b72da86938db0b5ac72e27d68a3774fe o618_48
+730d5b3335351461f9c09f86c78f50e28ef6c551 o618_49
+a6356ea69131074cc2a9f08142a5b4069abf8dc1 o618_50
+4db6739fba0780497084e3c22ea8f85287b1b003 o618_51
+b9957a51d9e1001a9c5c6cd7ac95cc6f421b2a3b o618_52
+f7b598c07e70b94caee9d2211a6c01fe844c646c o618_53
+c6301fa03fed8fedc0a49c2f878e032a10f29d05 o618_54
+98d373b8b9773897a972b9da2357009fa9c68965 o618_55
+0e08349b63ce27b0590f371daed5d49f3ecd5819 o618_56
+6a3397549652fdf3c75fc5af365501afb63a0b6f o618_57
+4a36596841a960a5c64da788309b9431e56bdc70 o618_58
+04e5c52e308741f709afb2677e831fd2e8ab9681 o618_59
+370d67fe97a9ace5162b1aba58c5daf865b16f64 o618_60
+9254bc3122d83c55a52cada031a4fbebc1773b92 o618_61
+3622a26bd56fd4ffc6a67f4fe856bbefbeb0a0fe o618_62
+0baba5be5738e2b48a65083bda275db869c19329 o618_63
+d0c44571683204efec1373c9418eee9497097041 o618_64
+a5f332136e7d93340eb968a2e5e0badb5372052b o618_65
+44ac8d1320378e933c5a31cf2a4a1b50fc900cbe o618_66
+b29fddbc60ab61dbddd6a5cb1e04da6706c0c0c4 o618_67
+96bfe37f368516f4f0f31e8ce2a8d2867071dda5 o618_68
+45644fcbb728d1d43238c9389da5218f723e944c o618_69
+fa56054b28171ad8d10d344042be6089810c101c o618_70
+257aa02a742e5123ad5a1da9c428dae9e2da99b7 o618_71
+801c0b7475bf210320a6fcf2b483dee10a19fb1b o618_72
+3d2eafe8c20e00694c299415916eb531a2df84ce o618_73
+642d91d3de12aa7314eccf5b80210b3363b03157 o618_74
+fe0103a66d5a0e68f852d63d8d7cea1dd3726148 o618_75
+0790b2f69e7ba1f401a4e1eada22124200d2ba2a o618_76
+8016ed93c44687e65181d16c69127668194acc84 o618_77
+ac5eeeb8747c2124203dd522c449ce28deeaf95d o618_78
+e6997b2e68c6dc35dc4a6a28626e488a0eb012ac o618_79
+915efd5958bf20fd47809a275ecc9a813b328a79 o618_80
+8c5410a37f40952e9249d896a8da9e37701a1709 o618_81
+dc88c896db78fdd3d4c6d700a4fd9abb7598fc14 o618_82
+7737ee12be81ee1f97e0ce99e9c161e4232966f7 o618_83
+5b13520e9df319d636a62ca2b2314346c9d4267e o618_84
+466d0ac15bbc0d71db5e7858005fc732a40c12f2 o618_85
+fcce961dc9ee5b0c2dbd03d144de636d8eba8f90 o618_86
+12c1670913a65fd412f81c68461af197f5a64538 o618_87
+a942f870b907e9134ff4462f06620049cb64601f o618_88
+3c9104483c51bf77149ee6025a3d19a671fbd6a3 o618_89
+6591200d92db11c107f4bc339ce35b9d667ddd0f o618_90
+7f70ce03003e4f46e8149985e24f16e2a9299425 o618_91
+edcfa5e9d7fd4f7e42db5280075773e21eaf9c37 o618_92
+6d37418c08b4f5a375e227294fc23480268d8ae4 o618_93
+53b3d4e238a5267feca1896c0b1d0f3c84048822 o618_94
+d75e38525ccedfcf4dc934911d426751fe98beed o618_95
+184681add3dfbe8b294138a19b8b389118676bbf o618_96
+391b6e54f9c02b36ad3b138a486066bebf4d2f3e o618_97
+49812acabebbcda4525bb31e6089270bda0f94e5 o618_98
+6d3bf1f6badd0ab8bbbaec99d544f3c6db5388fd o618_99
+cc98086a2845c690e7ce79194b12656c52fbd7e8 o618_100
+bf52f5ec800010d3497cbaa10a600f673eafc98f o618_101
+178336bd8b9b92f0dfe1a0d6d379e56c6d57d6da o618_102
+f63181e52067c733a4212dfcf4ca3eb59752b2ab o618_103
+4505a5e1663086570282542f482b4705e04d3fa4 o618_104
+709749b95babd6f48f68a5f6df3b1548a1eff053 o618_105
+d7cb1bbe33759801f41ef888cbad7906404a9dcc o618_106
+8b3827e90b69b08feed9b2b19c17c5a670b6d98b o618_107
+a037d91ad701c8fa38c9f12a5a8628f3e7cf97d3 o618_108
+5b12fe26bcb1bcdb85b5f7efc11d760f6df557f9 o618_109
+fd7511da7d1fa2316dc06e2b5ace47583b254850 o618_110
+97728c0a883df77cbf9489b654db149016fef7fc o618_111
+d7cb91b549420e9cbc5ff76fe56f7dbdec1ac9c3 o618_112
+c789c2535441203b988fdb927124a83596d56dce o618_113
+fa4c4eb9085e1010eb1f79dcc132a97feacf1f1d o618_114
+8703a7559f53a2fe21428c764d7e216866f5c469 o618_115
+f579b8a579c58f4eb53f0f954f1523c9d12d046b o618_116
+ea2eb22ae3a5829ff3da7285532fcc317cb4c970 o618_117
+a42b30591b20a8914186a84050e726ea6e185515 o618_118
+b38ad1942b7282021cc581955b24e6d5430b1080 o618_119
+08c943793c647d7e402efeff10af10eaa8b6bae1 o618_120
+4aa43c8e44756c4bb7971e893ccf428796b6adfa o618_121
+cd41d3d09ff557b0d84a2e65e5140f08397cd2f9 o618_122
+597fa0470f5b58b345ed1c6b16d25ad854364e2a o618_123
+e3d2b2e75736f18b4f5f4b4870c8fe7f5fc64972 o618_124
+14aa136362bf5bf548e1582b9939e29d9a21ab58 o618_125
+ec1300241c4d3000fc0f0ba5ebd37cb09a7fe7f9 o618_126
+f3d8051fed6820723b3755a106adcfd08a5670ad o618_127
+c5bdb832df96e3915d835b5a4f601a81947db235 o618_128
+7874913237ec57be2d7a25e1e4702d27f3397c9e o618_129
+1977bbfdee3cc30e820fe04b2cba2d750a03b85c o618_130
+0b72b70f934a2b2c42cfe2997c498bc8f2076d7c o618_131
+6602cb54b8e2e398adbd65545d0aea614155066f o618_132
diff --git a/scripts/sa-reorder/post/ext.py b/scripts/sa-reorder/post/ext.py
new file mode 100644 (file)
index 0000000..303ae74
--- /dev/null
@@ -0,0 +1,33 @@
+EXT_MSG = """btrfs: stripe_meta: extend stripe reclaim to metadata block groups
+
+The stripe reclaim of the reclaim subtopic handles stripe_alloc data block
+groups only.  stripe_meta allocates tree blocks in whole stripes too, so
+its block groups trap free space in partially used stripes the same way,
+and that space comes back only by moving the live tree blocks out of those
+stripes.  Metadata needs it more than data: a metadata reservation that
+finds no claimable stripe aborts the transaction instead of failing one
+write, so trapped metadata space that is never reclaimed ends in a forced
+read-only filesystem.
+
+Extend each reclaim mechanism to stripe_meta block groups:
+
+ - btrfs_reclaim_block_group(): allocate a chunk to relocate into when the
+   other groups' claimable stripes cannot take the group's live bytes, and
+   relocate the group even while it has reserved or pinned bytes.  Under
+   COW, a metadata group always has tree blocks reserved or pinned, so the
+   generic bail-out would defer it forever.
+
+ - The cleaner's periodic re-evaluation scans the metadata space_info as
+   well as the data one.
+
+ - Compaction counts metadata extent items: a tree block is nodesize long
+   and never spans a stripe, so for a metadata group the closure is the
+   partial stripes themselves.
+
+ - stripe_reclaim_now accepts stripe_meta block groups, for one group or
+   for all of them.
+
+The comments that name the groups reclaim handles now name both.
+
+Assisted-by: Claude:claude-opus-5-5
+"""
diff --git a/scripts/sa-reorder/post/msgdiff-618.txt b/scripts/sa-reorder/post/msgdiff-618.txt
new file mode 100644 (file)
index 0000000..6b8e3d2
--- /dev/null
@@ -0,0 +1,207 @@
+**#5** (old 5, main): btrfs: retire stripe runs at commit and gate stripe_alloc
+
+```diff
+@@ -3,11 +3,13 @@
+-Hook stripe run retirement into the transaction commit, right after
+-TRANS_STATE_COMMIT_DOING stops accepting joins with a single writer
+-left.  At that point every data extent the transaction references was
+-inserted by an ordered extent completion that joined earlier, implying
+-its own data IO is done; the retirement drain waits out in-flight
+-neighbour writes in the same stripes (a pure data-IO wait, never an
+-ordered extent wait, which would deadlock on the blocked join).  After
+-the drain, no stripe this transaction references can ever be written
+-again, so a crash after the superblock write cannot tear it -- closing
+-the raid56 write hole for stripe-allocated block groups without
+-requiring flushoncommit.  A defensive retirement in
++Hook stripe run retirement into the transaction commit, after the wait
++for pending ordered extents and before TRANS_STATE_COMMIT_DOING stops
++accepting joins.  The retirement drain waits out in-flight data writes
++into the stripes of the transaction's runs: a pure data-IO wait, never
++an ordered extent wait.  It must run while the transaction still
++accepts joins: a task holding unreported stripe run bytes (a reserved
++extent whose bio has not completed) can block on a transaction join,
++for example for a chunk allocation while walking a delalloc range, and
++the drain waits for those bytes, so retiring after joins are blocked
++would deadlock.  After the drain, no stripe this transaction references
++can ever be written again, so a crash after the superblock write cannot
++tear it -- closing the raid56 write hole for stripe-allocated block
++groups without requiring flushoncommit.  A defensive retirement in
+@@ -16,4 +18,6 @@
+-An ordered extent whose stripe run was opened after the committing
+-transaction's retire point cannot insert its file extent into that
+-transaction, so btrfs_finish_one_ordered() ends its handle and waits
+-for the commit's critical section to end.  That wait must not be taken
++Joins are still accepted between the retirement and
++TRANS_STATE_COMMIT_DOING.  An ordered extent whose stripe run was opened
++after the committing transaction's retire point cannot insert its file
++extent into that transaction, so btrfs_finish_one_ordered() ends its
++handle and waits for the commit's critical section to end.  That wait
++must not be taken
+@@ -99,0 +104 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#12** (old 13, main): btrfs: stripe_alloc: control the policy with a filesystem property
+
+```diff
+@@ -53 +52,0 @@
+-(cherry picked from commit ecd4d3de8a0493f7c406d919d533f88e8b45390c)
+```
+
+**#21** (old 29, main): btrfs: stripe_alloc: report read-modify-write of uncovered stripes
+
+```diff
+@@ -13,3 +13,3 @@
+-is to make the exposure visible rather than to fill the log, and paired
+-with a meta_rmw counter in the existing stripe_park_stats sysfs file so
+-the rate can be read off without grepping dmesg.
++is to make the exposure visible rather than to fill the log.  (A
++meta_rmw counter in stripe_park_stats, to read the rate off without
++grepping dmesg, is debug code and is added in the debug subtopic.)
+@@ -20,0 +21 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#50** (old 76, main): btrfs: stripe_alloc: drop the mount options, the property is the interface
+
+```diff
+@@ -37 +37 @@
+-The "does not cover raid56 system chunks" warning moves from
++The warning about the raid56 groups stripe_alloc does not cover moves from
+@@ -44,0 +45 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#102** (old 44, main): btrfs: stripe_alloc: give a queued stripe group a chunk to relocate into when the supply is short
+
+```diff
+@@ -21,0 +22,3 @@
++The stripe_meta block group part of this change moved to
++"btrfs: stripe_meta: extend stripe reclaim to metadata block groups".
++
+@@ -22,0 +26 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#103** (old 48, main): btrfs: stripe_alloc: hand groups full of trapped free space to the reclaim worker
+
+```diff
+@@ -42,0 +43,3 @@
++The stripe_meta block group part of this change moved to
++"btrfs: stripe_meta: extend stripe reclaim to metadata block groups".
++
+@@ -44,0 +48 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#105** (old 49, main): btrfs: stripe_alloc: relocate a queued stripe group even while it has reserved or pinned bytes
+
+```diff
+@@ -5,6 +5,7 @@
+-and may be about to go empty on its own.  A stripe_alloc or stripe_meta
+-group is queued for the opposite reason -- free space trapped in
+-partially used stripes, which no amount of waiting frees -- and under
+-COW churn a metadata group has blocks reserved or pinned at every
+-moment, so the worker skipped every one of seven queued metadata
+-groups for the whole of a fill-to-the-edge test and relocated none.
++and may be about to go empty on its own.  A stripe_alloc group is
++queued for the opposite reason -- free space trapped in partially used
++stripes, which no amount of waiting frees -- and under COW churn it can
++have blocks reserved or pinned at any moment, so the worker can defer it
++indefinitely.  Metadata showed it: under stripe_meta, the worker skipped
++every one of seven queued metadata groups for the whole of a
++fill-to-the-edge test and relocated none.
+@@ -13,0 +15,3 @@
++The stripe_meta block group part of this change moved to
++"btrfs: stripe_meta: extend stripe reclaim to metadata block groups".
++
+@@ -14,0 +19 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#106** (old 84, main): btrfs: stripe_alloc: compact mostly live groups instead of skipping them
+
+```diff
+@@ -3,9 +3,9 @@
+-Reclaim only takes a stripe_alloc / stripe_meta group whose live data is
+-below bg_reclaim_threshold: moving everything out of a fuller group costs
+-nearly a group's worth of writes and needs that much claimable space
+-elsewhere.  But trapped free space is not confined to emptyish groups.
+-Under steady COW churn the metadata groups stay mostly live while every
+-commit leaves partially used stripes behind, and on a raid6 metadata fill
+-the trapped share of the metadata free space reached 88% with no group
+-ever falling below the threshold: reclaim never ran, and the space never
+-came back.
++Reclaim only takes a stripe_alloc group whose live data is below
++bg_reclaim_threshold: moving everything out of a fuller group costs nearly
++a group's worth of writes and needs that much claimable space elsewhere.
++But trapped free space is not confined to emptyish groups.  Under steady
++COW churn a group can stay mostly live while every commit leaves
++partially used stripes behind.  Metadata under stripe_meta showed it
++first: on a raid6 metadata fill the trapped share of the metadata free
++space reached 88% with no group ever falling below the threshold:
++reclaim never ran, and the space never came back.
+@@ -18,2 +18 @@
+-partial stripes under "shares an extent with".  A tree block never spans a
+-stripe, so for a metadata group it is just the partial stripes.
++partial stripes under "shares an extent with".
+@@ -53,0 +53,3 @@
++The stripe_meta block group part of this change moved to
++"btrfs: stripe_meta: extend stripe reclaim to metadata block groups".
++
+```
+
+**#111** (old 130, main): btrfs: stripe_alloc: add stripe_reclaim_now to reclaim stripes on demand
+
+```diff
+@@ -3 +3 @@
+-Background reclaim of stripe_alloc / stripe_meta raid56 groups runs when a
++Background reclaim of stripe_alloc raid56 groups runs when a
+@@ -13 +13 @@
+-      Queue every stripe_alloc / stripe_meta raid56 group that the
++      Queue every stripe_alloc raid56 group that the
+@@ -37 +37 @@
+-stripe_alloc / stripe_meta raid56 group (balance's vrange filter relocates
++stripe_alloc raid56 group (balance's vrange filter relocates
+@@ -63,0 +64,3 @@
++The stripe_meta block group part of this change moved to
++"btrfs: stripe_meta: extend stripe reclaim to metadata block groups".
++
+```
+
+**#114** (old 14, main): btrfs: stripe_alloc: settle a logged extent's stripes at log commit
+
+```diff
+@@ -26,6 +26,10 @@
+-The drain is bounded and join-free: run inflight is counted from
+-allocation, which happens during writeback with submission following in
+-the same pass, so the wait is bio flight time plus the parked-write
+-deadline that the flush short-circuits; write_done reporting needs no
+-transaction join, so waiting under the inode log mutex and a running
+-transaction handle is safe.
++The drain is join-free: write_done reporting needs no transaction join,
++so waiting under the inode log mutex and a running transaction handle is
++safe.  It is not bounded: it has no timeout and waits for data IO to
++complete.  Run inflight is counted from allocation, which happens during
++writeback with submission following in the same pass, so in practice the
++wait is bio flight time plus the parked-write deadline that the flush
++short-circuits.  (A later patch shares LOG runs per log transaction and
++makes that the default; its settle waits until every allocated sector in
++the logged extent's stripes is written, other writers' sectors included,
++and is not bounded either.)
+@@ -42 +46 @@
+-(cherry picked from commit 53c44fdbca58bd1fa267a5648e236ed4238d99ed)
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#128** (old 29, part): btrfs: stripe_alloc: report read-modify-write of uncovered stripes (debug part)
+
+```diff
+@@ -4,3 +4,2 @@
+-for the subtopic reorder: its hunks that need code from
+-"btrfs: add a write-hole invariant checker to the raid56 write path",
+-which comes later in the new order.
++for the subtopic reorder: the meta_rmw counter in stripe_park_stats, which
++is debug code.  The warning stays in the base subtopic.
+```
+
diff --git a/scripts/sa-reorder/post/msgdiff-mn.txt b/scripts/sa-reorder/post/msgdiff-mn.txt
new file mode 100644 (file)
index 0000000..15c1bf5
--- /dev/null
@@ -0,0 +1,197 @@
+**#4** (old 4, main): btrfs: stripe_alloc: control the policy with a filesystem property
+
+```diff
+@@ -51 +50,0 @@
+-(cherry picked from commit ecd4d3de8a0493f7c406d919d533f88e8b45390c)
+```
+
+**#6** (old 6, main): btrfs: retire stripe runs at commit and gate stripe_alloc
+
+```diff
+@@ -3,11 +3,13 @@
+-Hook stripe run retirement into the transaction commit, right after
+-TRANS_STATE_COMMIT_DOING stops accepting joins with a single writer
+-left.  At that point every data extent the transaction references was
+-inserted by an ordered extent completion that joined earlier, implying
+-its own data IO is done; the retirement drain waits out in-flight
+-neighbour writes in the same stripes (a pure data-IO wait, never an
+-ordered extent wait, which would deadlock on the blocked join).  After
+-the drain, no stripe this transaction references can ever be written
+-again, so a crash after the superblock write cannot tear it -- closing
+-the raid56 write hole for stripe-allocated block groups without
+-requiring flushoncommit.  A defensive retirement in
++Hook stripe run retirement into the transaction commit, after the wait
++for pending ordered extents and before TRANS_STATE_COMMIT_DOING stops
++accepting joins.  The retirement drain waits out in-flight data writes
++into the stripes of the transaction's runs: a pure data-IO wait, never
++an ordered extent wait.  It must run while the transaction still
++accepts joins: a task holding unreported stripe run bytes (a reserved
++extent whose bio has not completed) can block on a transaction join,
++for example for a chunk allocation while walking a delalloc range, and
++the drain waits for those bytes, so retiring after joins are blocked
++would deadlock.  After the drain, no stripe this transaction references
++can ever be written again, so a crash after the superblock write cannot
++tear it -- closing the raid56 write hole for stripe-allocated block
++groups without requiring flushoncommit.  A defensive retirement in
+@@ -16,4 +18,6 @@
+-An ordered extent whose stripe run was opened after the committing
+-transaction's retire point cannot insert its file extent into that
+-transaction, so btrfs_finish_one_ordered() ends its handle and waits
+-for the commit's critical section to end.  That wait must not be taken
++Joins are still accepted between the retirement and
++TRANS_STATE_COMMIT_DOING.  An ordered extent whose stripe run was opened
++after the committing transaction's retire point cannot insert its file
++extent into that transaction, so btrfs_finish_one_ordered() ends its
++handle and waits for the commit's critical section to end.  That wait
++must not be taken
+@@ -100,0 +105 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#20** (old 28, main): btrfs: stripe_alloc: report read-modify-write of uncovered stripes
+
+```diff
+@@ -13,3 +13,3 @@
+-is to make the exposure visible rather than to fill the log, and paired
+-with a meta_rmw counter in the existing stripe_park_stats sysfs file so
+-the rate can be read off without grepping dmesg.
++is to make the exposure visible rather than to fill the log.  (A
++meta_rmw counter in stripe_park_stats, to read the rate off without
++grepping dmesg, is debug code and is added in the debug subtopic.)
+@@ -20,0 +21 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#90** (old 42, main): btrfs: stripe_alloc: give a queued stripe group a chunk to relocate into when the supply is short
+
+```diff
+@@ -21,0 +22,3 @@
++The stripe_meta block group part of this change moved to
++"btrfs: stripe_meta: extend stripe reclaim to metadata block groups".
++
+@@ -22,0 +26 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#91** (old 46, main): btrfs: stripe_alloc: hand groups full of trapped free space to the reclaim worker
+
+```diff
+@@ -42,0 +43,3 @@
++The stripe_meta block group part of this change moved to
++"btrfs: stripe_meta: extend stripe reclaim to metadata block groups".
++
+@@ -44,0 +48 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#93** (old 47, main): btrfs: stripe_alloc: relocate a queued stripe group even while it has reserved or pinned bytes
+
+```diff
+@@ -5,6 +5,7 @@
+-and may be about to go empty on its own.  A stripe_alloc or stripe_meta
+-group is queued for the opposite reason -- free space trapped in
+-partially used stripes, which no amount of waiting frees -- and under
+-COW churn a metadata group has blocks reserved or pinned at every
+-moment, so the worker skipped every one of seven queued metadata
+-groups for the whole of a fill-to-the-edge test and relocated none.
++and may be about to go empty on its own.  A stripe_alloc group is
++queued for the opposite reason -- free space trapped in partially used
++stripes, which no amount of waiting frees -- and under COW churn it can
++have blocks reserved or pinned at any moment, so the worker can defer it
++indefinitely.  Metadata showed it: under stripe_meta, the worker skipped
++every one of seven queued metadata groups for the whole of a
++fill-to-the-edge test and relocated none.
+@@ -13,0 +15,3 @@
++The stripe_meta block group part of this change moved to
++"btrfs: stripe_meta: extend stripe reclaim to metadata block groups".
++
+@@ -14,0 +19 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#94** (old 70, main): btrfs: stripe_alloc: compact mostly live groups instead of skipping them
+
+```diff
+@@ -3,9 +3,9 @@
+-Reclaim only takes a stripe_alloc / stripe_meta group whose live data is
+-below bg_reclaim_threshold: moving everything out of a fuller group costs
+-nearly a group's worth of writes and needs that much claimable space
+-elsewhere.  But trapped free space is not confined to emptyish groups.
+-Under steady COW churn the metadata groups stay mostly live while every
+-commit leaves partially used stripes behind, and on a raid6 metadata fill
+-the trapped share of the metadata free space reached 88% with no group
+-ever falling below the threshold: reclaim never ran, and the space never
+-came back.
++Reclaim only takes a stripe_alloc group whose live data is below
++bg_reclaim_threshold: moving everything out of a fuller group costs nearly
++a group's worth of writes and needs that much claimable space elsewhere.
++But trapped free space is not confined to emptyish groups.  Under steady
++COW churn a group can stay mostly live while every commit leaves
++partially used stripes behind.  Metadata under stripe_meta showed it
++first: on a raid6 metadata fill the trapped share of the metadata free
++space reached 88% with no group ever falling below the threshold:
++reclaim never ran, and the space never came back.
+@@ -18,2 +18 @@
+-partial stripes under "shares an extent with".  A tree block never spans a
+-stripe, so for a metadata group it is just the partial stripes.
++partial stripes under "shares an extent with".
+@@ -56,0 +56,3 @@
++The stripe_meta block group part of this change moved to
++"btrfs: stripe_meta: extend stripe reclaim to metadata block groups".
++
+```
+
+**#99** (old 114, main): btrfs: stripe_alloc: add stripe_reclaim_now to reclaim stripes on demand
+
+```diff
+@@ -3 +3 @@
+-Background reclaim of stripe_alloc / stripe_meta raid56 groups runs when a
++Background reclaim of stripe_alloc raid56 groups runs when a
+@@ -13 +13 @@
+-      Queue every stripe_alloc / stripe_meta raid56 group that the
++      Queue every stripe_alloc raid56 group that the
+@@ -37 +37 @@
+-stripe_alloc / stripe_meta raid56 group (balance's vrange filter relocates
++stripe_alloc raid56 group (balance's vrange filter relocates
+@@ -63,0 +64,3 @@
++The stripe_meta block group part of this change moved to
++"btrfs: stripe_meta: extend stripe reclaim to metadata block groups".
++
+```
+
+**#102** (old 13, main): btrfs: stripe_alloc: settle a logged extent's stripes at log commit
+
+```diff
+@@ -26,6 +26,10 @@
+-The drain is bounded and join-free: run inflight is counted from
+-allocation, which happens during writeback with submission following in
+-the same pass, so the wait is bio flight time plus the parked-write
+-deadline that the flush short-circuits; write_done reporting needs no
+-transaction join, so waiting under the inode log mutex and a running
+-transaction handle is safe.
++The drain is join-free: write_done reporting needs no transaction join,
++so waiting under the inode log mutex and a running transaction handle is
++safe.  It is not bounded: it has no timeout and waits for data IO to
++complete.  Run inflight is counted from allocation, which happens during
++writeback with submission following in the same pass, so in practice the
++wait is bio flight time plus the parked-write deadline that the flush
++short-circuits.  (A later patch shares LOG runs per log transaction and
++makes that the default; its settle waits until every allocated sector in
++the logged extent's stripes is written, other writers' sectors included,
++and is not bounded either.)
+@@ -42 +46 @@
+-(cherry picked from commit 53c44fdbca58bd1fa267a5648e236ed4238d99ed)
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#116** (old 28, part): btrfs: stripe_alloc: report read-modify-write of uncovered stripes (debug part)
+
+```diff
+@@ -4,3 +4,2 @@
+-for the subtopic reorder: its hunks that need code from
+-"btrfs: add a write-hole invariant checker to the raid56 write path",
+-which comes later in the new order.
++for the subtopic reorder: the meta_rmw counter in stripe_park_stats, which
++is debug code.  The warning stays in the base subtopic.
+```
+
diff --git a/scripts/sa-reorder/post/msgs.py b/scripts/sa-reorder/post/msgs.py
new file mode 100644 (file)
index 0000000..94b23e6
--- /dev/null
@@ -0,0 +1,123 @@
+# Message edits shared by both lanes (rulings A and C4).  Keys are old
+# patch numbers in the misc-next numbering; wpost specs map them to anchors.
+EXT_TITLE = 'btrfs: stripe_meta: extend stripe reclaim to metadata block groups'
+MOVED = ('The stripe_meta block group part of this change moved to\n'
+         f'"{EXT_TITLE}".\n\n')
+OPUS = 'Assisted-by: Claude:claude-opus-5-5'
+
+def moved(trailer_first):
+    """insert MOVED before the trailer block, which starts with trailer_first"""
+    return [(trailer_first, MOVED + trailer_first)]
+
+MSG = {
+    4: [("Assisted-by: Claude:claude-fable-5\n(cherry picked from commit ecd4d3de8a0493f7c406d919d533f88e8b45390c)\n",
+         "Assisted-by: Claude:claude-fable-5\n")],
+    6: [("""Hook stripe run retirement into the transaction commit, right after
+TRANS_STATE_COMMIT_DOING stops accepting joins with a single writer
+left.  At that point every data extent the transaction references was
+inserted by an ordered extent completion that joined earlier, implying
+its own data IO is done; the retirement drain waits out in-flight
+neighbour writes in the same stripes (a pure data-IO wait, never an
+ordered extent wait, which would deadlock on the blocked join).  After
+the drain, no stripe this transaction references can ever be written
+again, so a crash after the superblock write cannot tear it -- closing
+the raid56 write hole for stripe-allocated block groups without
+requiring flushoncommit.  A defensive retirement in
+btrfs_free_block_groups() covers the transaction abort path.
+
+An ordered extent whose stripe run was opened after the committing
+transaction's retire point cannot insert its file extent into that
+transaction, so btrfs_finish_one_ordered() ends its handle and waits
+for the commit's critical section to end.  That wait must not be taken""", """Hook stripe run retirement into the transaction commit, after the wait
+for pending ordered extents and before TRANS_STATE_COMMIT_DOING stops
+accepting joins.  The retirement drain waits out in-flight data writes
+into the stripes of the transaction's runs: a pure data-IO wait, never
+an ordered extent wait.  It must run while the transaction still
+accepts joins: a task holding unreported stripe run bytes (a reserved
+extent whose bio has not completed) can block on a transaction join,
+for example for a chunk allocation while walking a delalloc range, and
+the drain waits for those bytes, so retiring after joins are blocked
+would deadlock.  After the drain, no stripe this transaction references
+can ever be written again, so a crash after the superblock write cannot
+tear it -- closing the raid56 write hole for stripe-allocated block
+groups without requiring flushoncommit.  A defensive retirement in
+btrfs_free_block_groups() covers the transaction abort path.
+
+Joins are still accepted between the retirement and
+TRANS_STATE_COMMIT_DOING.  An ordered extent whose stripe run was opened
+after the committing transaction's retire point cannot insert its file
+extent into that transaction, so btrfs_finish_one_ordered() ends its
+handle and waits for the commit's critical section to end.  That wait
+must not be taken"""),
+        ("Assisted-by: Claude:claude-fable-5\n", "Assisted-by: Claude:claude-fable-5\n" + OPUS + "\n")],
+    13: [("""The drain is bounded and join-free: run inflight is counted from
+allocation, which happens during writeback with submission following in
+the same pass, so the wait is bio flight time plus the parked-write
+deadline that the flush short-circuits; write_done reporting needs no
+transaction join, so waiting under the inode log mutex and a running
+transaction handle is safe.""", """The drain is join-free: write_done reporting needs no transaction join,
+so waiting under the inode log mutex and a running transaction handle is
+safe.  It is not bounded: it has no timeout and waits for data IO to
+complete.  Run inflight is counted from allocation, which happens during
+writeback with submission following in the same pass, so in practice the
+wait is bio flight time plus the parked-write deadline that the flush
+short-circuits.  (A later patch shares LOG runs per log transaction and
+makes that the default; its settle waits until every allocated sector in
+the logged extent's stripes is written, other writers' sectors included,
+and is not bounded either.)"""),
+         ("Assisted-by: Claude:claude-fable-5\n(cherry picked from commit 53c44fdbca58bd1fa267a5648e236ed4238d99ed)",
+          "Assisted-by: Claude:claude-fable-5\n" + OPUS)],
+    28: [("""because a raid56-metadata filesystem does this continuously and the point
+is to make the exposure visible rather than to fill the log, and paired
+with a meta_rmw counter in the existing stripe_park_stats sysfs file so
+the rate can be read off without grepping dmesg.""", """because a raid56-metadata filesystem does this continuously and the point
+is to make the exposure visible rather than to fill the log.  (A
+meta_rmw counter in stripe_park_stats, to read the rate off without
+grepping dmesg, is debug code and is added in the debug subtopic.)"""),
+         ("Assisted-by: Claude:claude-fable-5\n", "Assisted-by: Claude:claude-fable-5\n" + OPUS + "\n")],
+    42: moved('Assisted-by: Claude:claude-fable-5\n') +
+        [("Assisted-by: Claude:claude-fable-5\n", "Assisted-by: Claude:claude-fable-5\n" + OPUS + "\n")],
+    46: moved('Assisted-by: Claude:claude-fable-5\n') +
+        [("Assisted-by: Claude:claude-fable-5-1\n", "Assisted-by: Claude:claude-fable-5-1\n" + OPUS + "\n")],
+    47: [("""and may be about to go empty on its own.  A stripe_alloc or stripe_meta
+group is queued for the opposite reason -- free space trapped in
+partially used stripes, which no amount of waiting frees -- and under
+COW churn a metadata group has blocks reserved or pinned at every
+moment, so the worker skipped every one of seven queued metadata
+groups for the whole of a fill-to-the-edge test and relocated none.""", """and may be about to go empty on its own.  A stripe_alloc group is
+queued for the opposite reason -- free space trapped in partially used
+stripes, which no amount of waiting frees -- and under COW churn it can
+have blocks reserved or pinned at any moment, so the worker can defer it
+indefinitely.  Metadata showed it: under stripe_meta, the worker skipped
+every one of seven queued metadata groups for the whole of a
+fill-to-the-edge test and relocated none.""")] +
+        moved('Assisted-by: Claude:claude-fable-5\n') +
+        [("Assisted-by: Claude:claude-fable-5\n", "Assisted-by: Claude:claude-fable-5\n" + OPUS + "\n")],
+    70: [("""Reclaim only takes a stripe_alloc / stripe_meta group whose live data is
+below bg_reclaim_threshold: moving everything out of a fuller group costs
+nearly a group's worth of writes and needs that much claimable space
+elsewhere.  But trapped free space is not confined to emptyish groups.
+Under steady COW churn the metadata groups stay mostly live while every
+commit leaves partially used stripes behind, and on a raid6 metadata fill
+the trapped share of the metadata free space reached 88% with no group
+ever falling below the threshold: reclaim never ran, and the space never
+came back.""", """Reclaim only takes a stripe_alloc group whose live data is below
+bg_reclaim_threshold: moving everything out of a fuller group costs nearly
+a group's worth of writes and needs that much claimable space elsewhere.
+But trapped free space is not confined to emptyish groups.  Under steady
+COW churn a group can stay mostly live while every commit leaves
+partially used stripes behind.  Metadata under stripe_meta showed it
+first: on a raid6 metadata fill the trapped share of the metadata free
+space reached 88% with no group ever falling below the threshold:
+reclaim never ran, and the space never came back."""),
+         ("""partial stripes under "shares an extent with".  A tree block never spans a
+stripe, so for a metadata group it is just the partial stripes.
+""", """partial stripes under "shares an extent with".
+""")] + moved(OPUS + '\n'),
+    114: [("Background reclaim of stripe_alloc / stripe_meta raid56 groups runs when a\n",
+           "Background reclaim of stripe_alloc raid56 groups runs when a\n"),
+          ("\tQueue every stripe_alloc / stripe_meta raid56 group that the\n",
+           "\tQueue every stripe_alloc raid56 group that the\n"),
+          ("stripe_alloc / stripe_meta raid56 group (balance's vrange filter relocates\n",
+           "stripe_alloc raid56 group (balance's vrange filter relocates\n")] + moved(OPUS + '\n'),
+}
diff --git a/scripts/sa-reorder/post/notes13.py b/scripts/sa-reorder/post/notes13.py
new file mode 100644 (file)
index 0000000..0ae3ed7
--- /dev/null
@@ -0,0 +1,44 @@
+NOTES = {
+ 7: "debug: CONFIG_BTRFS_DEBUG checker (S6a). 19's edit of it follows it (#117); 38's edits of it are in 38's main commit, which now comes after it",
+ 19: 'allow-rmw; its "fsync" word checks sit in 13\'s and 15\'s code and go to S4 (#105, #108); its checker edit goes to S6a (#117)',
+ 27: "user-facing mount warning (\"stripe_alloc does not cover raid56 metadata\"); narrowed by 38 and removed by 65, both in S5",
+ 28: "ruling C4: the rate-limited \"write hole applies\" warning stays in S1 (main commit); the meta_rmw counter (fs.h field, sysfs line, increment) is one debug part, #116 S6a. Message edited (the counter)",
+ 29: "debug: metadata RMW audit (reads headers under the stripe lock); S6b, after S5",
+ 38: "stripe_meta main commit. Folds in 73's retained test in run_freed_on_drain() (FOLD 73 into 38) and the \"meta\" name in 80's class_names table (synthetic 80.5, `into` 38); 80's BUILD_BUG_ON on the table size needs the name in the commit that adds the class",
+ 39: "debug: exists only to keep the write-hole checker quiet; the drain worker runs on every runtime enable (production path). S6a",
+ 42: "ruling A: data-only form in S3 (`if (btrfs_is_stripe_alloc_bg(bg))`, comment names stripe_alloc only); the stripe_meta test is in #129. Message: moved line",
+ 46: "reclaim trigger. Ruling A: the cleaner tick scans the data space_info only (`BTRFS_BLOCK_GROUP_DATA`); the metadata scan is in #129. Message: moved line",
+ 47: "ruling A: data-only form in S3 (bail-out exempts stripe_alloc groups); the stripe_meta exemption is in #129. Message: metadata wording, moved line",
+ 55: "debug: RMW audit refinement; S6b",
+ 57: "generic stranded-stripe accounting. Its edit of 46's reclaim predicate goes to S3 (#92); its stranded field in the space_info dump sits on 50's format line: S5 (#133)",
+ 59: "stripe_run_stats (ruling c); test-only. Its NOCOW counter bump goes to S2 (#68)",
+ 61: "stripe_meta runtime enable/disable; touches 39's drain worker (S6a, before it now), so it needs no part",
+ 64: "mount message. Removing the old enable-time message is in 39's code, so it goes to S6a (#119): S1-S4 print the line twice at mount",
+ 65: "stripe_meta system chunks; also extends 46's cleaner tick to SYSTEM",
+ 67: "every hunk edits S2 code (19, 20) or S4 code (13, 15). Its main commit lands in S2 (#74) with stripe_round_down(); stripe_is_aligned() goes with its only user to S4 (#107). No S1 code had the bug",
+ 70: "compaction. Ruling A: data-only form; the metadata extent items in compact_plan() and the stripe_meta comments are in #129. Its edit of 42's block is now in its main commit. Message: metadata wording, moved line",
+ 71: "debug: RMW attribution counters; records the pad verdict on the rbio. S6a; its stats lines that follow 29's format are S6b (#156)",
+ 73: "relocation runs retained. Ruling A: S1-S4 frees at the three write-done report sites test `!run->retained` (overlay `retained-glue`, from #43 to 38's #127, which replaces those sites with open_stripe_run_drain_reported()); its run_freed_on_drain() test is folded into 38. Sysfs line: #95 S3",
+ 75: "rbio pin. The NOCOW early return in run_written_range() goes to S2 (#69); its counters' sysfs lines to S6b (#158)",
+ 76: "pads unwritten sectors. The NOCOW exclusion goes to S2 (#70)",
+ 78: "pin counters (test-only), S1 with 75 and 79 that bump them; sysfs lines from S6b (#159)",
+ 79: "core: stale-pin sweep + commit request; counters ride along (sysfs lines #160 S6b)",
+ 80: "debug: per-class breakdown, S6a. Its class_names entry \"meta\" is written by 38 (synthetic 80.5 folded into 38), so S6a's table has the four data classes",
+ 81: "stripe_meta: META_LOG runs; adds \"meta_log\" to 80's table (80 is now before it)",
+ 83: "fsync: shared LOG runs; the init line stays in 83 (transfer). Its log_* counters' sysfs lines and comment sit in 81's code: S5 (#143)",
+ 85: "keys runs by root: S2. Its edits of 83 (S4, #111) and 81 (S5, #142) follow them",
+ 91: "its STRIPE_ALLOC test of 50's reserve block goes to S5 (#134)",
+ 94: "debug: fix to 29/55 audits; S6b",
+ 104: "comment-only; split by hunk into each subtopic's code (ruling e), see the parts column. Its S3 piece (#96) trims 42's comment",
+ 105: "comment-only; split by hunk into each subtopic's code (ruling e), see the parts column",
+ 107: "debug: removes dead pad reasons/counters (71/30/31). S6b whole, last: the stats lines that read the removed counters are 30's, 31's and 71's S6b parts (#154-#156), which sit in 29's format",
+ 108: "debug: counter + rate-limited log; the marking it counts is 87's. S6a; its stats lines follow 81's: S6b (#152)",
+ 109: "generic; its edit of btrfs_is_stripe_meta_bg goes to S5 (#128, #148)",
+ 110: "admission; its unmanaged_free in the space_info dump sits on 50's format line: S5 (#135, one part: the format and its argument, JOIN)",
+ 111: "stripe_meta: tests btrfs_is_stripe_meta_bg in the trim debit; S5 whole (trim debit is not reclaim). Also adds stripe_whole_bytes(), which is unused at the series tip (W=1 warning, an original-series defect)",
+ 112: "S5 with 111, which it fixes",
+ 113: "reclaim: Zygo's production diagnostic, a reclaim log message that dynamic debug can enable; S3 whole",
+ 114: "ruling A: data-only form in S3 (one group and \"all\" accept stripe_alloc groups); stripe_meta groups are accepted from #129. Message: metadata wording, moved line",
+ 115: "reclaim ENOSPC backoff, S3 whole (ruling A). Its relocation metadata room check (stripe_reclaim_meta_room()) is for relocating data groups and stays",
+ 116: "reclaim yields the exclusive operation between groups; S3 whole",
+}
diff --git a/scripts/sa-reorder/post/residual-618.diff b/scripts/sa-reorder/post/residual-618.diff
new file mode 100644 (file)
index 0000000..392cb5a
--- /dev/null
@@ -0,0 +1,56 @@
+diff --git a/fs/btrfs/block-group.c b/fs/btrfs/block-group.c
+index 1b18a0a4f3a85..41931c2152b4b 100644
+--- a/fs/btrfs/block-group.c
++++ b/fs/btrfs/block-group.c
+@@ -1580,12 +1580,10 @@ bool btrfs_stripe_run_strands(struct btrfs_block_group *bg, u64 stripe)
+ }
+ 
+ /*
+- * Parse a stripe_alloc_allow_rmw word list ("nodatacow",
+- * "prealloc", "fsync") into its mask.  Words are separated by comma,
+- * space or colon; the mount option form must use colon, since mount
+- * itself splits options at commas.  An empty value yields an empty
+- * mask.  Returns -EINVAL on any unknown word.  Shared by the mount
+- * option and the filesystem property.
++ * Parse the value of the btrfs.stripe_alloc_allow_rmw property, a word list
++ * ("nodatacow", "prealloc", "fsync"), into its mask.  Words are separated by
++ * comma, space or colon.  An empty value yields an empty mask.  Returns
++ * -EINVAL on any unknown word.
+  */
+ int btrfs_parse_stripe_rmw(const char *value, size_t len, u32 *mask)
+ {
+@@ -1615,22 +1613,6 @@ int btrfs_parse_stripe_rmw(const char *value, size_t len, u32 *mask)
+       return 0;
+ }
+ 
+-void btrfs_show_stripe_rmw(struct seq_file *seq, u32 mask)
+-{
+-      const char *sep = "";
+-
+-      if (mask & BTRFS_STRIPE_RMW_NODATACOW) {
+-              seq_printf(seq, "%snodatacow", sep);
+-              sep = ":";
+-      }
+-      if (mask & BTRFS_STRIPE_RMW_PREALLOC) {
+-              seq_printf(seq, "%sprealloc", sep);
+-              sep = ":";
+-      }
+-      if (mask & BTRFS_STRIPE_RMW_FSYNC)
+-              seq_printf(seq, "%sfsync", sep);
+-}
+-
+ /*
+  * Does every committed extent in [start, start + len) belong solely to
+  * @ino in @root_id -- exactly one reference, a plain data ref, count 1?
+diff --git a/fs/btrfs/block-group.h b/fs/btrfs/block-group.h
+index fa0c0a4d6229d..1defe8f297f85 100644
+--- a/fs/btrfs/block-group.h
++++ b/fs/btrfs/block-group.h
+@@ -599,7 +599,6 @@ bool btrfs_stripe_run_pad_mask(struct btrfs_fs_info *fs_info, u64 stripe_start,
+ bool btrfs_stripe_nocow_writable(struct btrfs_inode *inode, u64 start,
+                                u64 num_bytes, u32 which, bool nowait);
+ int btrfs_parse_stripe_rmw(const char *value, size_t len, u32 *mask);
+-void btrfs_show_stripe_rmw(struct seq_file *seq, u32 mask);
+ void btrfs_log_settle_stripes(struct btrfs_inode *inode, u64 file_start,
+                             u64 file_len, u64 bytenr, u64 num_bytes);
+ int btrfs_stripe_alloc_check_support(struct btrfs_fs_info *fs_info);
diff --git a/scripts/sa-reorder/post/residual-mn.diff b/scripts/sa-reorder/post/residual-mn.diff
new file mode 100644 (file)
index 0000000..2661462
--- /dev/null
@@ -0,0 +1,56 @@
+diff --git a/fs/btrfs/block-group.c b/fs/btrfs/block-group.c
+index d596cf1b563ea..1a5b326b2e643 100644
+--- a/fs/btrfs/block-group.c
++++ b/fs/btrfs/block-group.c
+@@ -1608,12 +1608,10 @@ bool btrfs_stripe_run_strands(struct btrfs_block_group *bg, u64 stripe)
+ }
+ 
+ /*
+- * Parse a stripe_alloc_allow_rmw word list ("nodatacow",
+- * "prealloc", "fsync") into its mask.  Words are separated by comma,
+- * space or colon; the mount option form must use colon, since mount
+- * itself splits options at commas.  An empty value yields an empty
+- * mask.  Returns -EINVAL on any unknown word.  Shared by the mount
+- * option and the filesystem property.
++ * Parse the value of the btrfs.stripe_alloc_allow_rmw property, a word list
++ * ("nodatacow", "prealloc", "fsync"), into its mask.  Words are separated by
++ * comma, space or colon.  An empty value yields an empty mask.  Returns
++ * -EINVAL on any unknown word.
+  */
+ int btrfs_parse_stripe_rmw(const char *value, size_t len, u32 *mask)
+ {
+@@ -1643,22 +1641,6 @@ int btrfs_parse_stripe_rmw(const char *value, size_t len, u32 *mask)
+       return 0;
+ }
+ 
+-void btrfs_show_stripe_rmw(struct seq_file *seq, u32 mask)
+-{
+-      const char *sep = "";
+-
+-      if (mask & BTRFS_STRIPE_RMW_NODATACOW) {
+-              seq_printf(seq, "%snodatacow", sep);
+-              sep = ":";
+-      }
+-      if (mask & BTRFS_STRIPE_RMW_PREALLOC) {
+-              seq_printf(seq, "%sprealloc", sep);
+-              sep = ":";
+-      }
+-      if (mask & BTRFS_STRIPE_RMW_FSYNC)
+-              seq_printf(seq, "%sfsync", sep);
+-}
+-
+ /*
+  * Does every committed extent in [start, start + len) belong solely to
+  * @ino in @root_id -- exactly one reference, a plain data ref, count 1?
+diff --git a/fs/btrfs/block-group.h b/fs/btrfs/block-group.h
+index 115d8fa7369af..bb3af6ea7aa08 100644
+--- a/fs/btrfs/block-group.h
++++ b/fs/btrfs/block-group.h
+@@ -609,7 +609,6 @@ bool btrfs_stripe_run_pad_mask(struct btrfs_fs_info *fs_info, u64 stripe_start,
+ bool btrfs_stripe_nocow_writable(struct btrfs_inode *inode, u64 start,
+                                u64 num_bytes, u32 which, bool nowait);
+ int btrfs_parse_stripe_rmw(const char *value, size_t len, u32 *mask);
+-void btrfs_show_stripe_rmw(struct seq_file *seq, u32 mask);
+ void btrfs_log_settle_stripes(struct btrfs_inode *inode, u64 file_start,
+                             u64 file_len, u64 bytenr, u64 num_bytes);
+ int btrfs_stripe_alloc_check_support(struct btrfs_fs_info *fs_info);
diff --git a/scripts/sa-reorder/post/wpost-618.py b/scripts/sa-reorder/post/wpost-618.py
new file mode 100644 (file)
index 0000000..a43e02d
--- /dev/null
@@ -0,0 +1,166 @@
+import os, json
+_D = os.path.dirname(os.path.abspath(SPECF))
+exec(open(os.path.join(_D, 'msgs.py')).read())
+_M = {int(k): v for k, v in json.load(open(os.path.join(_D, '../mn2s618.json'))).items()}
+ZYGO = ('Zygo Blaxell', 'ce3g8jdj@umail.furryterror.org')
+NOW = '1792702025 -0400'
+BASE = '2ff600d29ee478d0a8d46ef8a58afb5e038fe692'
+ORIG = [l.split()[0] for l in open(os.path.join(_D, '../order618.orig132')) if l.strip()]
+_BG = 'fs/btrfs/block-group.c'
+_mnspec = {'SPECF': os.path.join(_D, 'wpost-mn.py')}
+exec(open(os.path.join(_D, 'wpost-mn.py')).read(), _mnspec)
+_ov = {o['name']: o for o in _mnspec['OVERLAYS']}
+OLD_WARN = '''/*
+ * stripe_alloc covers raid56 *data* block groups only.  A filesystem whose
+ * metadata is also raid56 keeps the write hole there.  The data guarantee is
+ * easy to read as a filesystem-wide one, so say once at mount what is not
+ * covered.  (Mixed block groups cannot get here: the mount is refused, see
+ * btrfs_check_mountopts().)
+ */
+static void warn_stripe_alloc_uncovered(struct btrfs_fs_info *info)
+{
+       const u64 meta_bits = info->avail_metadata_alloc_bits |
+                             info->avail_system_alloc_bits;
+
+       if (!btrfs_test_opt(info, STRIPE_ALLOC))
+               return;
+
+       if (meta_bits & BTRFS_BLOCK_GROUP_RAID56_MASK)
+               btrfs_warn(info,
+"stripe_alloc does not cover raid56 metadata: the write hole remains for metadata, consider converting it to raid1c3/raid1c4");
+}
+
+'''
+NEW_WARN = '''/*
+ * stripe_alloc covers raid56 *data* block groups only.  A filesystem whose
+ * metadata is also raid56 keeps the write hole there.  The data guarantee is
+ * easy to read as a filesystem-wide one, so say once, when the policy turns
+ * on, what is not covered.  That is btrfs_enable_stripe_alloc(): at mount the
+ * property applies after the block groups are read, so a report from
+ * btrfs_read_block_groups() would find the flag still clear.  (Mixed block
+ * groups cannot get here: the property refuses them.)
+ */
+static void warn_stripe_alloc_uncovered(struct btrfs_fs_info *info)
+{
+       const u64 meta_bits = info->avail_metadata_alloc_bits |
+                             info->avail_system_alloc_bits;
+
+       if (!btrfs_test_opt(info, STRIPE_ALLOC))
+               return;
+
+       if (meta_bits & BTRFS_BLOCK_GROUP_RAID56_MASK)
+               btrfs_warn(info,
+"stripe_alloc does not cover raid56 metadata: the write hole remains for metadata, consider converting it to raid1c3/raid1c4");
+}
+
+'''
+OLD_WARN39 = '''/*
+ * stripe_alloc covers raid56 *data* block groups only.  A filesystem whose
+ * metadata is also raid56 keeps the write hole there.  The data guarantee is
+ * easy to read as a filesystem-wide one, so say once at mount what is not
+ * covered.  (Mixed block groups cannot get here: the mount is refused, see
+ * btrfs_check_mountopts().)
+ */
+static void warn_stripe_alloc_uncovered(struct btrfs_fs_info *info)
+{
+       if (!btrfs_test_opt(info, STRIPE_ALLOC))
+               return;
+
+       /*
+        * raid56 metadata is covered now that the policy follows the chunk
+        * profile.  System chunks are not: btrfs_is_stripe_meta_bg() tests
+        * the METADATA flag, and a system chunk does not carry it, so a
+        * raid56 system chunk keeps the legacy read-modify-write and its
+        * write hole.  They are small and rewritten rarely, but say so
+        * rather than let the earlier "covered" message imply otherwise.
+        */
+       if (info->avail_system_alloc_bits & BTRFS_BLOCK_GROUP_RAID56_MASK)
+               btrfs_warn(info,
+"stripe_alloc does not cover raid56 system chunks: the write hole remains for them, consider converting to raid1c3/raid1c4");
+}
+
+'''
+NEW_WARN39 = '''/*
+ * stripe_alloc covers raid56 *data* block groups only.  A filesystem whose
+ * metadata is also raid56 keeps the write hole there.  The data guarantee is
+ * easy to read as a filesystem-wide one, so say once, when the policy turns
+ * on, what is not covered.  That is btrfs_enable_stripe_alloc(): at mount the
+ * property applies after the block groups are read, so a report from
+ * btrfs_read_block_groups() would find the flag still clear.  (Mixed block
+ * groups cannot get here: the property refuses them.)
+ */
+static void warn_stripe_alloc_uncovered(struct btrfs_fs_info *info)
+{
+       if (!btrfs_test_opt(info, STRIPE_ALLOC))
+               return;
+
+       /*
+        * raid56 metadata is covered now that the policy follows the chunk
+        * profile.  System chunks are not: btrfs_is_stripe_meta_bg() tests
+        * the METADATA flag, and a system chunk does not carry it, so a
+        * raid56 system chunk keeps the legacy read-modify-write and its
+        * write hole.  They are small and rewritten rarely, but say so
+        * rather than let the earlier "covered" message imply otherwise.
+        */
+       if (info->avail_system_alloc_bits & BTRFS_BLOCK_GROUP_RAID56_MASK)
+               btrfs_warn(info,
+"stripe_alloc does not cover raid56 system chunks: the write hole remains for them, consider converting to raid1c3/raid1c4");
+}
+
+'''
+def _warn_edits(old, new):
+    return [
+        (_BG, old, ''),
+        (_BG, '''                      inc_block_group_ro(cache, 1);
+       }
+
+       warn_stripe_alloc_uncovered(info);
+''', '''                       inc_block_group_ro(cache, 1);
+       }
+
+'''),
+        (_BG, (('''}
+
+/*
+ * Drain the writes the legacy allocator placed before stripe_alloc was
+''', '''}
+
+''' + new + '''/*
+ * Drain the writes the legacy allocator placed before stripe_alloc was
+'''), ('''}
+
+/*
+ * Turn on stripe-exclusive allocation, from the "stripe_alloc" filesystem
+''', '''}
+
+''' + new + '''/*
+ * Turn on stripe-exclusive allocation, from the "stripe_alloc" filesystem
+''')), None),
+        (_BG, '''      btrfs_set_opt(fs_info->mount_opt, STRIPE_ALLOC);
+''', '''       btrfs_set_opt(fs_info->mount_opt, STRIPE_ALLOC);
+       warn_stripe_alloc_uncovered(fs_info);
+'''),
+    ]
+OVERLAYS = [
+    dict(_ov['retained-glue'], at=('main', 88), until=('main', 39)),
+    dict(_ov['allow-rmw-cleanup'], at=('main', 20), until=None),
+    dict(name='reclaim-room-call', at=('main', 131), until=('main', 52), edits=[
+        ('fs/btrfs/free-space-cache.c',
+         "\t     btrfs_can_overcommit(fs_info, meta, bytes, BTRFS_RESERVE_FLUSH_ALL, true);\n",
+         "\t     btrfs_can_overcommit(fs_info, meta, bytes, BTRFS_RESERVE_FLUSH_ALL);\n")]),
+    # C2: the mount warning for uncovered raid56 metadata in the base
+    # subtopic: 76 moves it to the enable path with its pre-stripe_meta body
+    dict(name='uncovered-warning', at=('main', 76), until=('main', 39), edits=_warn_edits(OLD_WARN, NEW_WARN)),
+    # 39 makes raid56 metadata covered and turns the warning into the
+    # system chunk one, now in its new place: 76's stripe_meta part, which
+    # did the move in the engine's order, is left empty and dropped
+    dict(name='uncovered-warning-meta', at=('main', 39), until=('part', 76, 2),
+         edits=_warn_edits(OLD_WARN39, NEW_WARN39)),
+]
+DROPS = [('part', 76, 2)]
+MSG_EDITS = {('main', _M[k]): v for k, v in MSG.items()}
+MSG_EDITS[('main', 76)] = [
+    ('The "does not cover raid56 system chunks" warning moves from\n',
+     'The warning about the raid56 groups stripe_alloc does not cover moves from\n'),
+    ('Assisted-by: Claude:claude-fable-5-1\n', 'Assisted-by: Claude:claude-fable-5-1\n' + OPUS + '\n')]
+MSG_EDITS[('part', 29, 1)] = _mnspec['MSG_EDITS'][('part', 28, 1)]
diff --git a/scripts/sa-reorder/post/wpost-mn.py b/scripts/sa-reorder/post/wpost-mn.py
new file mode 100644 (file)
index 0000000..4fd8b43
--- /dev/null
@@ -0,0 +1,79 @@
+import os
+exec(open(os.path.join(os.path.dirname(os.path.abspath(SPECF)), 'msgs.py')).read())
+ZYGO = ('Zygo Blaxell', 'ce3g8jdj@umail.furryterror.org')
+NOW = '1792702025 -0400'
+BASE = '0c48d26d46bdd6422bb91ba7f1c519a2993116dc'
+ORIG = [l.split()[0] for l in open(os.path.join(os.path.dirname(os.path.abspath(SPECF)), '../order.orig116')) if l.strip()]
+_BG = 'fs/btrfs/block-group.c'
+OVERLAYS = [
+    # 73 before 38: the run report sites 38 rewrites keep a retained
+    # relocation run until relocation releases it
+    dict(name='retained-glue', at=('main', 73), until=('main', 38), edits=[
+        (_BG, """                      run_live_set(run, start, num_bytes, false);
+                       run->inflight_bytes -= num_bytes;
+                       if (open_stripe_run_drained(run))
+""", """                       run_live_set(run, start, num_bytes, false);
+                       run->inflight_bytes -= num_bytes;
+                       if (open_stripe_run_drained(run) && !run->retained)
+"""),
+        (_BG, """                      ASSERT(run->inflight_bytes >= num_bytes);
+                       run->inflight_bytes -= num_bytes;
+                       if (open_stripe_run_drained(run))
+""", """                       ASSERT(run->inflight_bytes >= num_bytes);
+                       run->inflight_bytes -= num_bytes;
+                       if (open_stripe_run_drained(run) && !run->retained)
+"""),
+        (_BG, """
+       if (open_stripe_run_drained(run))
+               free_open_stripe_run(bg, run);
+       spin_unlock_irqrestore""", """
+       if (open_stripe_run_drained(run) && !run->retained)
+               free_open_stripe_run(bg, run);
+       spin_unlock_irqrestore"""),
+    ]),
+    # 115 before 50: btrfs_can_overcommit() gets its reloc argument (the
+    # stripe_meta relocation reserve) from 50, which updates this call
+    dict(name='reclaim-room-call', at=('main', 115), until=('main', 50), edits=[
+        ('fs/btrfs/free-space-cache.c',
+         "\t     btrfs_can_overcommit(meta, bytes, BTRFS_RESERVE_FLUSH_ALL, true);\n",
+         "\t     btrfs_can_overcommit(meta, bytes, BTRFS_RESERVE_FLUSH_ALL);\n")]),
+    # C4: dead code and the stale comment, from the patch that adds them
+    dict(name='allow-rmw-cleanup', at=('main', 19), until=None, edits=[
+        (_BG, """/*
+ * Parse a stripe_alloc_allow_rmw word list ("nodatacow",
+ * "prealloc", "fsync") into its mask.  Words are separated by comma,
+ * space or colon; the mount option form must use colon, since mount
+ * itself splits options at commas.  An empty value yields an empty
+ * mask.  Returns -EINVAL on any unknown word.  Shared by the mount
+ * option and the filesystem property.
+ */""", """/*
+ * Parse the value of the btrfs.stripe_alloc_allow_rmw property, a word list
+ * ("nodatacow", "prealloc", "fsync"), into its mask.  Words are separated by
+ * comma, space or colon.  An empty value yields an empty mask.  Returns
+ * -EINVAL on any unknown word.
+ */"""),
+        (_BG, """void btrfs_show_stripe_rmw(struct seq_file *seq, u32 mask)
+{
+       const char *sep = "";
+
+       if (mask & BTRFS_STRIPE_RMW_NODATACOW) {
+               seq_printf(seq, "%snodatacow", sep);
+               sep = ":";
+       }
+       if (mask & BTRFS_STRIPE_RMW_PREALLOC) {
+               seq_printf(seq, "%sprealloc", sep);
+               sep = ":";
+       }
+       if (mask & BTRFS_STRIPE_RMW_FSYNC)
+               seq_printf(seq, "%sfsync", sep);
+}
+
+""", ""),
+        ('fs/btrfs/block-group.h', "void btrfs_show_stripe_rmw(struct seq_file *seq, u32 mask);\n", ""),
+    ]),
+]
+MSG_EDITS = {('main', k): v for k, v in MSG.items()}
+MSG_EDITS[('part', 28, 1)] = [("""for the subtopic reorder: its hunks that need code from
+"btrfs: add a write-hole invariant checker to the raid56 write path",
+which comes later in the new order.""", """for the subtopic reorder: the meta_rmw counter in stripe_park_stats, which
+is debug code.  The warning stays in the base subtopic.""")]
diff --git a/scripts/sa-reorder/queue7.sh b/scripts/sa-reorder/queue7.sh
new file mode 100755 (executable)
index 0000000..5b5a2ff
--- /dev/null
@@ -0,0 +1,10 @@
+#!/bin/bash
+# queue7.sh: rulings A and C: all seven boundaries on both lanes (W=1 fs/btrfs + bzImage),
+# then per-commit W=1 from S3 to the end on both lanes (6.18 merged with raid56-disguise)
+cd /mnt/linux/wt-osord-mn
+M=/mnt/linux/config-r5fix-mn-kasan; E=/mnt/linux/wt-osord-mn/config-review-618ffe-kasan
+for s in 1 2 3 4 5 6 7; do ./build-one2.sh refs/tmp/o-sord/p13c/S$s p13-S$s $M; done
+for s in 1 2 3 4 5 6 7; do ./build-one2.sh refs/tmp/o-sord/q13c/S$s q13-S$s $E; done
+./each-commit2.sh refs/tmp/o-sord/p13c/pre refs/tmp/o-sord/p13 p13-each $M
+./each-commit2.sh refs/tmp/o-sord/q13c/pre refs/tmp/o-sord/q13c/each q13-each $E
+echo ALLDONE > /mnt/linux/wt-osord-mn/queue7.done
diff --git a/scripts/sa-reorder/queue8.sh b/scripts/sa-reorder/queue8.sh
new file mode 100755 (executable)
index 0000000..d62cfc3
--- /dev/null
@@ -0,0 +1,9 @@
+#!/bin/bash
+# queue8.sh: after the reclaim-room-call fix: 6.18 boundaries and chain, then mn S3/S4/S6a and chain
+cd /mnt/linux/wt-osord-mn
+M=/mnt/linux/config-r5fix-mn-kasan; E=/mnt/linux/wt-osord-mn/config-review-618ffe-kasan
+for s in 1 2 3 4 5 6 7; do ./build-one2.sh refs/tmp/o-sord/q14c/S$s q14-S$s $E; done
+./each-commit2.sh refs/tmp/o-sord/q14c/pre refs/tmp/o-sord/q14c/each q14-each $E
+for s in 3 4 5; do ./build-one2.sh refs/tmp/o-sord/p14c/S$s p14-S$s $M; done
+./each-commit2.sh refs/tmp/o-sord/p14c/pre refs/tmp/o-sord/p14 p14-each $M
+echo ALLDONE > /mnt/linux/wt-osord-mn/queue8.done
diff --git a/scripts/sa-reorder/queue9.sh b/scripts/sa-reorder/queue9.sh
new file mode 100755 (executable)
index 0000000..d66fb46
--- /dev/null
@@ -0,0 +1,9 @@
+#!/bin/bash
+# queue9.sh: p16/q16 (compact_plan fs_info, 107 in debug_meta): changed boundaries, then per-commit from S3
+cd /mnt/linux/wt-osord-mn
+M=/mnt/linux/config-r5fix-mn-kasan; E=/mnt/linux/wt-osord-mn/config-review-618ffe-kasan
+for s in 3 4 5 6 7; do ./build-one2.sh refs/tmp/o-sord/p16c/S$s p16-S$s $M; done
+./each-commit2.sh refs/tmp/o-sord/p16c/pre refs/tmp/o-sord/p16 p16-each $M
+for s in 3 4 5 6 7; do ./build-one2.sh refs/tmp/o-sord/q16c/S$s q16-S$s $E; done
+./each-commit2.sh refs/tmp/o-sord/q16c/pre refs/tmp/o-sord/q16c/each q16-each $E
+echo ALLDONE > /mnt/linux/wt-osord-mn/queue9.done
diff --git a/scripts/sa-reorder/rev9-S1.txt b/scripts/sa-reorder/rev9-S1.txt
new file mode 100644 (file)
index 0000000..24e825e
--- /dev/null
@@ -0,0 +1,462 @@
+##### fs/btrfs/block-group.c: struct btrfs_open_stripe_run {
+   ...
+       old2  |         u64 start;
+       old2  |         u64 end;                        /* exclusive; shrunk to offset on close */
+       old2  |         u64 offset;                     /* next unallocated byte */
+       old2  |         u64 inflight_bytes;             /* reserved bytes with data IO pending */
+       old2  |         u64 open_seq;                   /* fs_info->stripe_retire_seq at open */
+   >S5 old38 |         u64 transid;                    /* fs_info->generation at open */
+   <S2 old14 |         u64 owner;                      /* LOG class: btrfs_ino of the owner */
+   >S2 old85 |         /*
+   >S2 old85 |          * Private runs are found by (root, owner): root is the subvolume's
+   >S2 old85 |          * root id, owner the inode number (LOG, NOCOW), a shared LOG key
+   >S2 old85 |          * (bit 63 set, see stripe_run_owner()), or for META_LOG the root id
+   >S2 old85 |          * again.  Inode numbers are only unique within a subvolume.
+   >S2 old85 |          */
+##### fs/btrfs/block-group.c: int btrfs_alloc_from_inode_stripe_run(struct btrfs_block_group *bg, u64 ino,
+   ...
+   >S2 old20 | int btrfs_alloc_from_inode_stripe_run(struct btrfs_block_group *bg,
+   >S2 old20 |                                       struct btrfs_inode *inode,
+   >S2 old18 |                                       enum btrfs_stripe_run_class class,
+   <S2 old14 |                                       u64 num_bytes, u64 *ret_offset,
+   <S2 old14 |                                       u64 *available)
+   >S2 old20 |                                       u64 num_bytes, u64 readopt_hint,
+   >S2 old20 |                                       u64 *ret_offset, u64 *available)
+       old14 | {
+       old14 |         struct btrfs_fs_info *fs_info = bg->fs_info;
+       old14 |         const u64 fsl = bg->full_stripe_len;
+   >S2 old85 |         const u64 root_id = btrfs_root_id(inode->root);
+   ...
+       old14 | 
+       old14 |         ASSERT(num_bytes);
+       old14 |         *available = 0;
+       old14 | 
+       old14 |         spin_lock_irqsave(&bg->stripe_run_lock, flags);
+       old14 |         list_for_each_entry(run, &bg->open_stripe_runs, list) {
+   <S2 old14 |                 if (run->class != BTRFS_STRIPE_RUN_LOG || run->owner != ino ||
+   <S2 old14 |                     !run->open)
+   >S2 old85 |                 if (run->class != class || run->root != root_id ||
+   >S2 old85 |                     run->owner != ino || !run->open)
+       old14 |                         continue;
+       old14 |                 if (num_bytes <= run->end - run->offset) {
+       old14 |                         *ret_offset = run->offset;
+       old33 |                         run_live_set(run, run->offset, num_bytes, true);
+   ...
+       old14 |                 btrfs_add_free_space(bg, start, len);
+       old14 |                 *available = 0;
+       old14 |                 ret = -ENOSPC;
+       old14 |                 goto out;
+       old14 |         }
+       old14 |         new_run->bg = bg;
+   <S2 old14 |         new_run->class = BTRFS_STRIPE_RUN_LOG;
+   >S2 old18 |         new_run->class = class;
+   >S2 old58 |         /*
+   >S2 old58 |          * A NOCOW run outlives commits only while the stripe_alloc_allow_rmw
+   >S2 old58 |          * policy lets nocow data be written in place at all (see
+   >S2 old58 |          * close_block_group_stripe_runs()).  Decided once, here: the commit
+   >S2 old58 |          * path's close and settle predicates must agree with each other for
+##### fs/btrfs/block-group.c: bool btrfs_stripe_run_pad_mask(struct btrfs_fs_info *fs_info, u64 stripe_start,
+   ...
+       old33 |                  * sub-stripe free space nothing can claim while the stripe
+       old33 |                  * holds live data.  They were never allocated, their live
+       old33 |                  * bits are clear, and they are exactly what a kicked park
+       old33 |                  * needs to pad.  An open run's end is stripe aligned, so
+       old33 |                  * overhang there means a stripe the run does not own.
+       old33 |                  */
+   <S6 old33 |                 if (stripe_start + stripe_len > run->end && run->open)
+   >S6 old71 |                 if (stripe_start + stripe_len > run->end && run->open) {
+   >S6 old71 |                         if (info)
+   >S6 old71 |                                 info->norun = BTRFS_STRIPE_NORUN_OVERHANG;
+       old33 |                         break;
+   >S6 old71 |                 }
+       old33 | 
+   ...
+       old33 |                 /*
+       old33 |                  * And wholly inside the map.  Declining here costs a
+       old33 |                  * read-modify-write; reading past the map would be a lie about
+       old33 |                  * which sectors are dead, and padding acts on that by
+       old33 |                  * overwriting them.
+       old33 |                  */
+   <S6 old33 |                 if (first + nsectors > run->live_nbits)
+   >S6 old71 |                 if (first + nsectors > run->live_nbits) {
+   >S6 old71 |                         if (info)
+   >S6 old71 |                                 info->norun = BTRFS_STRIPE_NORUN_PAST_MAP;
+       old33 |                         break;
+   >S6 old71 |                 }
+       old33 |                 bitmap_zero(dead, nsectors);
+##### fs/btrfs/block-group.c: void btrfs_scan_stripe_unusable(struct btrfs_fs_info *fs_info, bool force)
+   ...
+       old57 |                 u64 total_stranded = 0;
+   >S5 old50 |                 u64 largest = 0;
+   >S5 old50 |                 u64 unit = 0;
+   >S5 old50 |                 u32 nr_rw = 0;
+       old8  |                 int raid;
+       old8  | 
+   <S5 old8  |                 if (!(sinfo->flags & BTRFS_BLOCK_GROUP_DATA))
+   >S5 old48 |                 /*
+   >S5 old48 |                  * Data groups under stripe_alloc and metadata groups under
+   >S5 old48 |                  * stripe_meta both place extents in whole stripes only, so
+   >S5 old48 |                  * both carry trapped free space.  Mixed groups are refused.
+   >S5 old48 |                  */
+   >S5 old48 |                 if (!(sinfo->flags & (BTRFS_BLOCK_GROUP_DATA |
+##### fs/btrfs/block-group.c: static int inc_block_group_ro(struct btrfs_block_group *cache, bool force)
+   ...
+       old0  |                  * BTRFS_RESERVE_NO_FLUSH to give ourselves the most amount of
+       old0  |                  * leeway to allow us to mark this block group as read only.
+   >S5 old48 |                  *
+   >S5 old48 |                  * As for data above: a stripe_meta group's trapped bytes are
+   >S5 old48 |                  * already in the space_info total, do not re-provide them.
+       old0  |                  */
+   <S5 old0  |                 if (btrfs_can_overcommit(sinfo, num_bytes, BTRFS_RESERVE_NO_FLUSH))
+   >S5 old48 |                 u64 trapped = 0;
+   >S5 old48 | 
+   >S5 old48 |                 if (READ_ONCE(cache->stripe_unusable_ready))
+   >S5 old48 |                         trapped = min(READ_ONCE(cache->stripe_unusable), num_bytes);
+   >S5 old53 |                 /*
+   >S5 old53 |                  * The stripe_meta reserve is the room a group's live blocks
+##### fs/btrfs/extent-tree.c: static int do_allocation_stripe(struct btrfs_block_group *block_group,
+   ...
+       old44 |                 spin_unlock(&block_group->space_info->lock);
+       old44 |         }
+       old3  |         if (skip)
+       old3  |                 return 1;
+       old3  | 
+       old14 |         /*
+   <S2 old14 |          * A log-active inode allocates from its own private LOG-class run so
+   <S2 old14 |          * its log commits settle only its own stripes.  If this block group
+   <S2 old14 |          * has no fully-free stripes left for a private run, fall through to
+   <S2 old14 |          * the shared runs: the data is then placed exactly as before 3b.1
+   <S2 old14 |          * and the log-commit settling keeps it safe, just less cheaply.
+   >S2 old105|          * Steered allocations come from a private run of the requested class:
+   >S2 old105|          * the inode's own, or for LOG-class allocations under a full stripe
+   >S2 old105|          * with stripe_log_data_shared, the run its subvolume shares for the
+   >S2 old105|          * current log transaction (stripe_run_owner()).  If this block group
+   >S2 old105|          * has no fully free stripe for such a run, fall through to the shared
+   >S2 old105|          * runs: log-commit settling covers any placement, and a nocow/prealloc
+   >S2 old105|          * extent in a shared stripe is simply COWed.
+       old14 |          */
+   <S2 old14 |         if (ffe_ctl->for_log_inode) {
+   <S2 old14 |                 struct btrfs_inode *log_inode = ffe_ctl->for_log_inode;
+   >S2 old18 |         if (ffe_ctl->steer_inode) {
+   >S2 old18 |                 struct btrfs_inode *steer_inode = ffe_ctl->steer_inode;
+       old14 | 
+       old14 |                 ret = btrfs_alloc_from_inode_stripe_run(block_group,
+   <S2 old14 |                                 btrfs_ino(log_inode), ffe_ctl->num_bytes,
+   <S2 old14 |                                 &offset, &available);
+   >S2 old20 |                                 steer_inode, ffe_ctl->steer_class,
+   >S2 old20 |                                 ffe_ctl->num_bytes, ffe_ctl->hint_byte,
+   >S2 old20 |                                 &offset, &available);
+       old14 |                 if (ret == -ENOMEM)
+       old14 |                         return ret;
+       old14 |                 if (!ret) {
+   >S2 old19 |                         if (ffe_ctl->steer_class == BTRFS_STRIPE_RUN_NOCOW)
+   >S2 old19 |                                 set_bit(BLOCK_GROUP_FLAG_STRIPE_NOCOW_USED,
+   >S2 old19 |                                         &block_group->runtime_flags);
+   <S2 old14 |                         WRITE_ONCE(log_inode->log_run_hint, offset);
+   >S2 old18 |                         WRITE_ONCE(steer_inode->log_run_hint, offset);
+       old14 |                         ffe_ctl->found_offset = offset;
+       old14 |                         ffe_ctl->search_start = offset;
+       old14 |                         return 0;
+       old14 |                 }
+       old14 |                 if (available > ffe_ctl->max_extent_size)
+##### fs/btrfs/extent-tree.c: int btrfs_reserve_extent(struct btrfs_root *root, struct btrfs_inode *inode,
+   ...
+       old14 | int btrfs_reserve_extent(struct btrfs_root *root, struct btrfs_inode *inode,
+       old14 |                          u64 ram_bytes, u64 num_bytes, u64 min_alloc_size,
+       old0  |                          u64 empty_size, u64 hint_byte,
+   <S2 old0  |                          struct btrfs_key *ins, bool is_data, bool delalloc)
+   >S2 old18 |                          struct btrfs_key *ins, bool is_data, bool delalloc,
+   >S2 old18 |                          bool for_prealloc)
+       old0  | {
+       old0  |         struct btrfs_fs_info *fs_info = root->fs_info;
+       old0  |         struct find_free_extent_ctl ffe_ctl = {};
+       old0  |         bool final_tried = num_bytes == min_alloc_size;
+   ...
+   >S5 old81 |          * names the commit; together they key the private stripe run that
+   >S5 old81 |          * keeps one log commit's blocks off every later writer's stripes.
+   >S5 old81 |          */
+   >S5 old81 |         u64 log_owner = for_treelog ? root->root_key.offset : 0;
+   >S5 old81 |         u64 log_transid = for_treelog ? root->log_transid : 0;
+       old0  |         bool for_data_reloc = (btrfs_is_data_reloc_root(root) && is_data);
+   <S2 old14 |         struct btrfs_inode *for_log_inode = NULL;
+   >S2 old18 |         struct btrfs_inode *steer_inode = NULL;
+   >S2 old18 |         enum btrfs_stripe_run_class steer_class = BTRFS_STRIPE_RUN_COW;
+       old14 | 
+       old14 |         /*
+   <S2 old14 |          * Steer a log-active inode's datacow data into its private LOG-class
+   <S2 old14 |          * stripe run, seeded with the run's location as the search hint; see
+   <S2 old14 |          * BTRFS_INODE_LOG_ALLOC.  Purely placement: any allocation that
+   <S2 old14 |          * cannot be served from a private run falls back to the shared runs.
+   >S2 old105|          * Steer this inode's data into a private stripe run, using its last
+   >S2 old105|          * private allocation as the search hint.  Placement only: what a
+   >S2 old105|          * private run cannot serve falls back to the shared runs.
+   >S2 old105|          *  - NOCOW class for preallocated and nodatacow extents, but only while
+   >S2 old105|          *    stripe_alloc_allow_rmw lets them be written in place; otherwise
+   >S2 old105|          *    they are COWed anyway, and a private run, which outlives commits,
+   >S2 old105|          *    would only strand whole stripes.
+   >S2 old105|          *  - LOG class for log-active inodes (BTRFS_INODE_LOG_ALLOC).
+       old14 |          */
+       old14 |         if (inode && is_data && !for_data_reloc &&
+   <S2 old14 |             btrfs_test_opt(fs_info, STRIPE_ALLOC) &&
+   <S2 old14 |             test_bit(BTRFS_INODE_LOG_ALLOC, &inode->runtime_flags)) {
+   <S2 old14 |                 u64 log_hint = READ_ONCE(inode->log_run_hint);
+   >S2 old18 |             btrfs_test_opt(fs_info, STRIPE_ALLOC)) {
+   >S2 old58 |                 const u32 rmw = btrfs_stripe_allow_rmw(fs_info);
+   >S2 old58 | 
+   >S2 old58 |                 if ((for_prealloc && (rmw & BTRFS_STRIPE_RMW_PREALLOC)) ||
+   >S2 old58 |                     (!for_prealloc && (inode->flags & BTRFS_INODE_NODATACOW) &&
+   >S2 old58 |                      (rmw & BTRFS_STRIPE_RMW_NODATACOW))) {
+   ...
+   >S2 old18 |                         steer_inode = inode;
+   >S2 old18 |                         steer_class = BTRFS_STRIPE_RUN_LOG;
+   >S2 old18 |                 }
+   >S2 old18 |                 if (steer_inode) {
+   >S2 old18 |                         u64 run_hint = READ_ONCE(inode->log_run_hint);
+       old14 | 
+   <S2 old14 |                 for_log_inode = inode;
+   <S2 old14 |                 if (log_hint)
+   <S2 old14 |                         hint_byte = log_hint;
+   >S2 old18 |                         if (run_hint)
+   >S2 old18 |                                 hint_byte = run_hint;
+   >S2 old20 |                         else if (steer_class == BTRFS_STRIPE_RUN_NOCOW &&
+   >S2 old20 |                                  !hint_byte)
+   >S2 old20 |                                 hint_byte = btrfs_nocow_alloc_hint(inode);
+   >S2 old18 |                 }
+   ...
+       old0  |         ffe_ctl.delalloc = delalloc;
+       old0  |         ffe_ctl.hint_byte = hint_byte;
+       old0  |         ffe_ctl.for_treelog = for_treelog;
+   >S5 old81 |         ffe_ctl.log_owner = log_owner;
+   >S5 old81 |         ffe_ctl.log_transid = log_transid;
+       old0  |         ffe_ctl.for_data_reloc = for_data_reloc;
+   <S2 old14 |         ffe_ctl.for_log_inode = for_log_inode;
+   >S2 old18 |         ffe_ctl.steer_inode = steer_inode;
+   >S2 old18 |         ffe_ctl.steer_class = steer_class;
+       old0  | 
+       old0  |         ret = find_free_extent(root, ins, &ffe_ctl);
+       old0  |         if (!ret && !is_data) {
+       old0  |                 btrfs_dec_block_group_reservations(fs_info, ins->objectid);
+##### fs/btrfs/free-space-cache.c: void btrfs_block_group_init_stripe_unusable(struct btrfs_block_group *bg)
+   ...
+       old8  | void btrfs_block_group_init_stripe_unusable(struct btrfs_block_group *bg)
+       old8  | {
+       old8  |         struct btrfs_free_space_ctl *ctl = bg->free_space_ctl;
+       old34 |         u64 trapped, claimable, nstripes;
+       old8  |         u32 *freep;
+       old8  | 
+   <S5 old8  |         if (!btrfs_is_stripe_alloc_bg(bg))
+   >S5 old38 |         if (!btrfs_is_stripe_alloc_bg(bg) && !btrfs_is_stripe_meta_bg(bg))
+       old8  |                 return;
+       old8  |         if (READ_ONCE(bg->stripe_unusable_ready))
+       old8  |                 return;
+       old8  | 
+       old8  |         nstripes = stripe_unusable_nstripes(bg);
+##### fs/btrfs/free-space-cache.c: void btrfs_block_group_disarm_stripe_unusable(struct btrfs_block_group *bg)
+   ...
+       old8  | void btrfs_block_group_disarm_stripe_unusable(struct btrfs_block_group *bg)
+       old8  | {
+       old8  |         struct btrfs_free_space_ctl *ctl = bg->free_space_ctl;
+       old8  |         u64 trapped;
+       old34 |         u64 claimable;
+       old8  | 
+   <S5 old8  |         if (!btrfs_is_stripe_alloc_bg(bg))
+   >S5 old48 |         if (!btrfs_is_stripe_alloc_bg(bg) && !btrfs_is_stripe_meta_bg(bg))
+       old8  |                 return;
+       old8  | 
+       old8  |         spin_lock(&ctl->tree_lock);
+       old8  |         if (!bg->stripe_unusable_ready) {
+       old8  |                 spin_unlock(&ctl->tree_lock);
+##### fs/btrfs/free-space-cache.c: void btrfs_block_group_rescan_stripe_unusable(struct btrfs_block_group *bg)
+   ...
+       old8  | {
+       old8  |         struct btrfs_free_space_ctl *ctl = bg->free_space_ctl;
+   >S3 old46 |         bool reclaim = false;
+       old8  |         u64 nstripes;
+       old8  |         u32 *freep;
+       old8  | 
+   <S5 old8  |         if (!btrfs_is_stripe_alloc_bg(bg))
+   >S5 old48 |         if (!btrfs_is_stripe_alloc_bg(bg) && !btrfs_is_stripe_meta_bg(bg))
+       old8  |                 return;
+       old8  | 
+       old8  |         nstripes = stripe_unusable_nstripes(bg);
+       old8  |         freep = kvcalloc(nstripes, sizeof(*freep), GFP_NOFS);
+       old8  |         if (!freep)
+##### fs/btrfs/fs.h: struct btrfs_fs_info {
+   ...
+       old30 |                 /*
+       old105|                  * Data read-modify-writes in a covered block group, parked or
+       old105|                  * not; zero with allow_rmw empty.  rmw_reads counts only the
+       old105|                  * parked ones.
+       old30 |                  */
+       old30 |                 atomic64_t data_rmw;
+   <S6 old30 |                 /*
+   <S6 old105|                  * Why padding declined: live (the rest of the stripe is
+   <S6 old105|                  * allocated and not yet written), no_run (no open run covers
+   <S6 old105|                  * the stripe), unallocated (the run's frontier has not reached
+   <S6 old105|                  * the stripe).
+   <S6 old30 |                  */
+   <S6 old30 |                 atomic64_t pad_decline_live;
+   >S6 old107|                 /* Why padding declined: no open run covers the stripe. */
+       old30 |                 atomic64_t pad_decline_no_run;
+   <S6 old30 |                 atomic64_t pad_decline_unallocated;
+       old105|                 /*
+       old105|                  * Oracle allowed padding, but a sector below the frontier is
+       old105|                  * not covered by this write: another allocation shares the
+       old105|                  * stripe.
+       old105|                  */
+       old31 |                 atomic64_t pad_decline_uncovered;
+   ...
+   >S4 old83 |          * stripe or more stay in the inode's private run, and the commit waits
+   >S4 old83 |          * only for the logged extent's own stripes.  Clear: one private run
+   >S4 old83 |          * per fsyncing inode, closed at each log commit, with carry-forward of
+   >S4 old83 |          * its final partial stripe.  See btrfs_log_settle_stripes().
+   >S4 old83 |          */
+   >S4 old83 |         bool stripe_log_data_shared;
+   <S4 old59 |         /*
+   <S4 old59 |          * Stripe run lifecycle observability: lifetime counters exposed
+   <S4 old59 |          * through sysfs stripe_run_stats, so a test can show it exercised
+   <S4 old59 |          * the nocow private-run and stranded-stripe paths at all.
+   <S4 old59 |          */
+   >S4 old105|         /* Stripe run lifecycle counters (sysfs stripe_run_stats). */
+       old59 |         struct {
+       old59 |                 /* private NOCOW runs opened (they outlive commits) */
+       old59 |                 atomic64_t nocow_run_opened;
+       old59 |                 /* claim candidates refused for overlapping a live run */
+       old59 |                 atomic64_t claim_refused_live_run;
+   ...
+       old0  | 
+       old0  |         /* Device replace state */
+       old0  |         struct btrfs_dev_replace dev_replace;
+       old0  | 
+       old0  |         struct semaphore uuid_tree_rescan_sem;
+       old0  | 
+   <S6 old0  |         /* Used to reclaim the metadata space in the background. */
+   >S6 old105|         /* Drains legacy writes after stripe_alloc is enabled at runtime. */
+   >S6 old39 |         struct work_struct stripe_alloc_enable_work;
+   >S6 old105|         /* Used to reclaim the metadata space in the background. */
+       old0  |         struct work_struct async_reclaim_work;
+       old0  |         struct work_struct async_data_reclaim_work;
+       old0  |         struct work_struct preempt_reclaim_work;
+##### fs/btrfs/inode.c: ssize_t btrfs_do_encoded_write(struct kiocb *iocb, struct iov_iter *from,
+   ...
+       old0  |                                 ret = orig_count;
+       old0  |                         goto out_delalloc_release;
+       old0  |                 }
+       old0  |         }
+       old0  | 
+       old14 |         ret = btrfs_reserve_extent(root, inode, disk_num_bytes, disk_num_bytes,
+   <S2 old0  |                                    disk_num_bytes, 0, 0, &ins, true, true);
+   >S2 old18 |                                    disk_num_bytes, 0, 0, &ins, true, true,
+   >S2 old18 |                                    false);
+       old60 |         btrfs_stripe_prealloc_release(fs_info, stripe_held);
+       old60 |         stripe_held = 0;
+       old0  |         if (ret)
+       old0  |                 goto out_delalloc_release;
+##### fs/btrfs/raid56.c: static bool rbio_try_park(struct btrfs_raid_bio *rbio)
+   ...
+       old11 |         struct btrfs_stripe_hash_table *table = fs_info->stripe_hash_table;
+       old30 |         const unsigned int sync_timeout_ms =
+       old30 |                 READ_ONCE(fs_info->stripe_park_sync_timeout_ms);
+       old30 |         unsigned int timeout_ms = READ_ONCE(fs_info->stripe_park_timeout_ms);
+   >S2 old21 |         enum btrfs_stripe_run_class class;
+       old11 | 
+   <S2 old11 |         if (!btrfs_stripe_in_open_run(fs_info, rbio->bioc->full_stripe_logical))
+   >S2 old21 |         if (!btrfs_stripe_open_run_class(fs_info,
+   >S2 old21 |                                          rbio->bioc->full_stripe_logical,
+   >S2 old21 |                                          &class))
+       old11 |                 return false;
+       old11 | 
+       old11 |         spin_lock(&rbio->bio_list_lock);
+##### fs/btrfs/space-info.c: void btrfs_try_granting_tickets(struct btrfs_space_info *space_info)
+   ...
+   >S5 old50 |                  */
+   >S5 old50 |                 tused = used;
+   >S5 old50 |                 if (ticket->reloc)
+   >S5 old50 |                         tused -= min(tused, space_info->bytes_stripe_reserve);
+       old0  | 
+       old0  |                 /* Check and see if our ticket can be satisfied now. */
+   <S5 old36 |                 if ((used_after <= space_info->total_bytes ||
+   <S5 old36 |                      can_overcommit(space_info, used, ticket->bytes, flush)) &&
+   <S5 old43 |                     stripe_claimable_admit(space_info, ticket->bytes, false)) {
+   >S5 old50 |                 if ((tused + ticket->bytes <= space_info->total_bytes ||
+   >S5 old50 |                      can_overcommit(space_info, tused, ticket->bytes, flush)) &&
+   >S5 old50 |                     stripe_claimable_admit(space_info, ticket->bytes, ticket->reloc)) {
+       old0  |                         btrfs_space_info_update_bytes_may_use(space_info, ticket->bytes);
+       old60 |                         if (ticket->hold_stripe)
+       old60 |                                 ticket->held = stripe_hold_locked(space_info);
+##### fs/btrfs/space-info.h: struct btrfs_space_info {
+   ...
+       old24 |                                            space cache but not yet allocated;
+       old24 |                                            will either be allocated or become
+       old24 |                                            trapped tails when the runs close, so
+       old24 |                                            reservations must not count on it
+       old24 |                                            either.  Synced from the block groups'
+       old24 |                                            stripe_open_remainder. */
+   <S5 old25 |         u64 bytes_stripe_margin;        /* stripe_alloc pessimistic reservation
+   <S5 old25 |                                            margin: one full stripe width per
+   <S5 old25 |                                            outstanding delalloc extent.  Pre-pays
+   <S5 old25 |                                            the worst-case sub-stripe tail each
+   <S5 old25 |                                            future extent can strand when its run
+   <S5 old25 |                                            closes, so commits between write() and
+   <S5 old25 |                                            writeback can never trap space out
+   <S5 old25 |                                            from under an admitted reservation.
+   <S5 old25 |                                            Charged and released in lockstep with
+   <S5 old25 |                                            the inodes' outstanding_extents. */
+   >S5 old105|         u64 bytes_stripe_margin;        /* data: one full stripe per
+   >S5 old105|                                            outstanding delalloc extent or
+   >S5 old105|                                            preallocation in flight, pre-paying
+   >S5 old105|                                            the sub-stripe tail a commit can trap
+   >S5 old105|                                            before writeback (see
+   >S5 old105|                                            btrfs_stripe_margin_mod()).
+##### fs/btrfs/sysfs.c: static ssize_t btrfs_stripe_park_stats_show(struct kobject *kobj,
+   ...
+       old22 | static ssize_t btrfs_stripe_park_stats_show(struct kobject *kobj,
+       old22 |                                             struct kobj_attribute *a, char *buf)
+       old22 | {
+       old22 |         struct btrfs_fs_info *fs_info = to_fs_info(kobj);
+   <S6 old78 |         int cached, pinned, live;
+   >S6 old80 |         /* Indexed by enum btrfs_stripe_run_class. */
+   >S6 old80 |         static const char * const class_names[] = {
+   >S6 old81 |                 "cow", "reloc", "log", "nocow", "meta", "meta_log",
+   >S6 old80 |         };
+   >S6 old80 |         int live_by_class[BTRFS_STRIPE_RUN_NR_CLASSES];
+   >S6 old80 |         int open_runs[BTRFS_STRIPE_RUN_NR_CLASSES];
+   >S6 old80 |         int cached, pinned, live, class;
+   >S6 old80 |         ssize_t len;
+       old22 | 
+   <S6 old78 |         btrfs_rbio_cache_usage(fs_info, &cached, &pinned, &live);
+   <S6 old22 |         return sysfs_emit(buf,
+   >S6 old80 |         BUILD_BUG_ON(ARRAY_SIZE(class_names) != BTRFS_STRIPE_RUN_NR_CLASSES);
+   >S6 old80 |         btrfs_rbio_cache_usage(fs_info, &cached, &pinned, &live, live_by_class);
+   >S6 old80 |         btrfs_count_open_stripe_runs(fs_info, open_runs);
+   >S6 old80 |         len = sysfs_emit(buf,
+       old22 |                 "parked %lld\n"
+       old22 |                 "merged_bytes %lld\n"
+   ...
+       old32 |                 "unparked_ready %lld\n"
+       old22 |                 "kicked %lld\n"
+       old22 |                 "expired %lld\n"
+       old32 |                 "stuck %lld\n"
+       old22 |                 "padded %lld\n"
+       old76 |                 "padded_unwritten %lld\n"
+   <S6 old22 |                 "rmw_reads %lld\n",
+   >S6 old28 |                 "rmw_reads %lld\n"
+   >S6 old30 |                 "data_rmw %lld\n"
+   >S6 old30 |                 "pad_decline_no_run %lld\n"
+   >S6 old31 |                 "pad_decline_uncovered %lld\n"
+   >S6 old71 |                 "data_rmw_pad_ok_nomem %lld\n"
+   >S6 old71 |                 "data_rmw_no_run %lld\n"
+   ...
+       old32 |                 atomic64_read(&fs_info->stripe_park_stats.unparked_ready),
+       old22 |                 atomic64_read(&fs_info->stripe_park_stats.kicked),
+       old22 |                 atomic64_read(&fs_info->stripe_park_stats.expired),
+       old32 |                 atomic64_read(&fs_info->stripe_park_stats.stuck),
+       old22 |                 atomic64_read(&fs_info->stripe_park_stats.padded),
+       old76 |                 atomic64_read(&fs_info->stripe_park_stats.padded_unwritten),
+   <S6 old22 |                 atomic64_read(&fs_info->stripe_park_stats.rmw_reads));
+   >S6 old28 |                 atomic64_read(&fs_info->stripe_park_stats.rmw_reads),
+   >S6 old30 |                 atomic64_read(&fs_info->stripe_park_stats.data_rmw),
+   >S6 old30 |                 atomic64_read(&fs_info->stripe_park_stats.pad_decline_no_run),
+   >S6 old31 |                 atomic64_read(&fs_info->stripe_park_stats.pad_decline_uncovered),
+   >S6 old107|                 atomic64_read(&fs_info->stripe_park_stats.data_rmw_by[BTRFS_STRIPE_PAD_OK]),
+   >S6 old107|                 atomic64_read(&fs_info->stripe_park_stats.data_rmw_by[BTRFS_STRIPE_PAD_NO_RUN]),
diff --git a/scripts/sa-reorder/rev9-S2.txt b/scripts/sa-reorder/rev9-S2.txt
new file mode 100644 (file)
index 0000000..257205d
--- /dev/null
@@ -0,0 +1,268 @@
+##### fs/btrfs/block-group.c: int btrfs_alloc_from_inode_stripe_run(struct btrfs_block_group *bg,
+   ...
+       old20 |                                       u64 num_bytes, u64 readopt_hint,
+       old20 |                                       u64 *ret_offset, u64 *available)
+       old14 | {
+       old14 |         struct btrfs_fs_info *fs_info = bg->fs_info;
+       old14 |         const u64 fsl = bg->full_stripe_len;
+       old85 |         const u64 root_id = btrfs_root_id(inode->root);
+   <S4 old20 |         const u64 ino = btrfs_ino(inode);
+   >S4 old83 |         const u64 ino = stripe_run_owner(inode, class, num_bytes, fsl);
+       old14 |         struct btrfs_open_stripe_run *new_run;
+       old14 |         struct btrfs_open_stripe_run *run;
+       old14 |         unsigned long flags;
+       old14 |         u64 tail_start = 0;
+       old14 |         u64 tail_len = 0;
+##### fs/btrfs/block-group.c: bool btrfs_stripe_run_pad_mask(struct btrfs_fs_info *fs_info, u64 stripe_start,
+   ...
+       old33 |                  * sub-stripe free space nothing can claim while the stripe
+       old33 |                  * holds live data.  They were never allocated, their live
+       old33 |                  * bits are clear, and they are exactly what a kicked park
+       old33 |                  * needs to pad.  An open run's end is stripe aligned, so
+       old33 |                  * overhang there means a stripe the run does not own.
+       old33 |                  */
+   <S6 old33 |                 if (stripe_start + stripe_len > run->end && run->open)
+   >S6 old71 |                 if (stripe_start + stripe_len > run->end && run->open) {
+   >S6 old71 |                         if (info)
+   >S6 old71 |                                 info->norun = BTRFS_STRIPE_NORUN_OVERHANG;
+       old33 |                         break;
+   >S6 old71 |                 }
+       old33 | 
+   ...
+       old33 |                 /*
+       old33 |                  * And wholly inside the map.  Declining here costs a
+       old33 |                  * read-modify-write; reading past the map would be a lie about
+       old33 |                  * which sectors are dead, and padding acts on that by
+       old33 |                  * overwriting them.
+       old33 |                  */
+   <S6 old33 |                 if (first + nsectors > run->live_nbits)
+   >S6 old71 |                 if (first + nsectors > run->live_nbits) {
+   >S6 old71 |                         if (info)
+   >S6 old71 |                                 info->norun = BTRFS_STRIPE_NORUN_PAST_MAP;
+       old33 |                         break;
+   >S6 old71 |                 }
+       old33 |                 bitmap_zero(dead, nsectors);
+##### fs/btrfs/block-group.c: void btrfs_scan_stripe_unusable(struct btrfs_fs_info *fs_info, bool force)
+   ...
+       old57 |                 u64 total_stranded = 0;
+   >S5 old50 |                 u64 largest = 0;
+   >S5 old50 |                 u64 unit = 0;
+   >S5 old50 |                 u32 nr_rw = 0;
+       old8  |                 int raid;
+       old8  | 
+   <S5 old8  |                 if (!(sinfo->flags & BTRFS_BLOCK_GROUP_DATA))
+   >S5 old48 |                 /*
+   >S5 old48 |                  * Data groups under stripe_alloc and metadata groups under
+   >S5 old48 |                  * stripe_meta both place extents in whole stripes only, so
+   >S5 old48 |                  * both carry trapped free space.  Mixed groups are refused.
+   >S5 old48 |                  */
+   >S5 old48 |                 if (!(sinfo->flags & (BTRFS_BLOCK_GROUP_DATA |
+##### fs/btrfs/block-group.c: static int inc_block_group_ro(struct btrfs_block_group *cache, bool force)
+   ...
+       old0  |                  * BTRFS_RESERVE_NO_FLUSH to give ourselves the most amount of
+       old0  |                  * leeway to allow us to mark this block group as read only.
+   >S5 old48 |                  *
+   >S5 old48 |                  * As for data above: a stripe_meta group's trapped bytes are
+   >S5 old48 |                  * already in the space_info total, do not re-provide them.
+       old0  |                  */
+   <S5 old0  |                 if (btrfs_can_overcommit(sinfo, num_bytes, BTRFS_RESERVE_NO_FLUSH))
+   >S5 old48 |                 u64 trapped = 0;
+   >S5 old48 | 
+   >S5 old48 |                 if (READ_ONCE(cache->stripe_unusable_ready))
+   >S5 old48 |                         trapped = min(READ_ONCE(cache->stripe_unusable), num_bytes);
+   >S5 old53 |                 /*
+   >S5 old53 |                  * The stripe_meta reserve is the room a group's live blocks
+##### fs/btrfs/free-space-cache.c: void btrfs_block_group_init_stripe_unusable(struct btrfs_block_group *bg)
+   ...
+       old8  | void btrfs_block_group_init_stripe_unusable(struct btrfs_block_group *bg)
+       old8  | {
+       old8  |         struct btrfs_free_space_ctl *ctl = bg->free_space_ctl;
+       old34 |         u64 trapped, claimable, nstripes;
+       old8  |         u32 *freep;
+       old8  | 
+   <S5 old8  |         if (!btrfs_is_stripe_alloc_bg(bg))
+   >S5 old38 |         if (!btrfs_is_stripe_alloc_bg(bg) && !btrfs_is_stripe_meta_bg(bg))
+       old8  |                 return;
+       old8  |         if (READ_ONCE(bg->stripe_unusable_ready))
+       old8  |                 return;
+       old8  | 
+       old8  |         nstripes = stripe_unusable_nstripes(bg);
+##### fs/btrfs/free-space-cache.c: void btrfs_block_group_disarm_stripe_unusable(struct btrfs_block_group *bg)
+   ...
+       old8  | void btrfs_block_group_disarm_stripe_unusable(struct btrfs_block_group *bg)
+       old8  | {
+       old8  |         struct btrfs_free_space_ctl *ctl = bg->free_space_ctl;
+       old8  |         u64 trapped;
+       old34 |         u64 claimable;
+       old8  | 
+   <S5 old8  |         if (!btrfs_is_stripe_alloc_bg(bg))
+   >S5 old48 |         if (!btrfs_is_stripe_alloc_bg(bg) && !btrfs_is_stripe_meta_bg(bg))
+       old8  |                 return;
+       old8  | 
+       old8  |         spin_lock(&ctl->tree_lock);
+       old8  |         if (!bg->stripe_unusable_ready) {
+       old8  |                 spin_unlock(&ctl->tree_lock);
+##### fs/btrfs/free-space-cache.c: void btrfs_block_group_rescan_stripe_unusable(struct btrfs_block_group *bg)
+   ...
+       old8  | {
+       old8  |         struct btrfs_free_space_ctl *ctl = bg->free_space_ctl;
+   >S3 old46 |         bool reclaim = false;
+       old8  |         u64 nstripes;
+       old8  |         u32 *freep;
+       old8  | 
+   <S5 old8  |         if (!btrfs_is_stripe_alloc_bg(bg))
+   >S5 old48 |         if (!btrfs_is_stripe_alloc_bg(bg) && !btrfs_is_stripe_meta_bg(bg))
+       old8  |                 return;
+       old8  | 
+       old8  |         nstripes = stripe_unusable_nstripes(bg);
+       old8  |         freep = kvcalloc(nstripes, sizeof(*freep), GFP_NOFS);
+       old8  |         if (!freep)
+##### fs/btrfs/fs.h: struct btrfs_fs_info {
+   ...
+       old30 |                 /*
+       old105|                  * Data read-modify-writes in a covered block group, parked or
+       old105|                  * not; zero with allow_rmw empty.  rmw_reads counts only the
+       old105|                  * parked ones.
+       old30 |                  */
+       old30 |                 atomic64_t data_rmw;
+   <S6 old30 |                 /*
+   <S6 old105|                  * Why padding declined: live (the rest of the stripe is
+   <S6 old105|                  * allocated and not yet written), no_run (no open run covers
+   <S6 old105|                  * the stripe), unallocated (the run's frontier has not reached
+   <S6 old105|                  * the stripe).
+   <S6 old30 |                  */
+   <S6 old30 |                 atomic64_t pad_decline_live;
+   >S6 old107|                 /* Why padding declined: no open run covers the stripe. */
+       old30 |                 atomic64_t pad_decline_no_run;
+   <S6 old30 |                 atomic64_t pad_decline_unallocated;
+       old105|                 /*
+       old105|                  * Oracle allowed padding, but a sector below the frontier is
+       old105|                  * not covered by this write: another allocation shares the
+       old105|                  * stripe.
+       old105|                  */
+       old31 |                 atomic64_t pad_decline_uncovered;
+   ...
+   >S4 old83 |          * stripe or more stay in the inode's private run, and the commit waits
+   >S4 old83 |          * only for the logged extent's own stripes.  Clear: one private run
+   >S4 old83 |          * per fsyncing inode, closed at each log commit, with carry-forward of
+   >S4 old83 |          * its final partial stripe.  See btrfs_log_settle_stripes().
+   >S4 old83 |          */
+   >S4 old83 |         bool stripe_log_data_shared;
+   <S4 old59 |         /*
+   <S4 old59 |          * Stripe run lifecycle observability: lifetime counters exposed
+   <S4 old59 |          * through sysfs stripe_run_stats, so a test can show it exercised
+   <S4 old59 |          * the nocow private-run and stranded-stripe paths at all.
+   <S4 old59 |          */
+   >S4 old105|         /* Stripe run lifecycle counters (sysfs stripe_run_stats). */
+       old59 |         struct {
+       old59 |                 /* private NOCOW runs opened (they outlive commits) */
+       old59 |                 atomic64_t nocow_run_opened;
+       old59 |                 /* claim candidates refused for overlapping a live run */
+       old59 |                 atomic64_t claim_refused_live_run;
+   ...
+       old0  | 
+       old0  |         /* Device replace state */
+       old0  |         struct btrfs_dev_replace dev_replace;
+       old0  | 
+       old0  |         struct semaphore uuid_tree_rescan_sem;
+       old0  | 
+   <S6 old0  |         /* Used to reclaim the metadata space in the background. */
+   >S6 old105|         /* Drains legacy writes after stripe_alloc is enabled at runtime. */
+   >S6 old39 |         struct work_struct stripe_alloc_enable_work;
+   >S6 old105|         /* Used to reclaim the metadata space in the background. */
+       old0  |         struct work_struct async_reclaim_work;
+       old0  |         struct work_struct async_data_reclaim_work;
+       old0  |         struct work_struct preempt_reclaim_work;
+##### fs/btrfs/space-info.c: void btrfs_try_granting_tickets(struct btrfs_space_info *space_info)
+   ...
+   >S5 old50 |                  */
+   >S5 old50 |                 tused = used;
+   >S5 old50 |                 if (ticket->reloc)
+   >S5 old50 |                         tused -= min(tused, space_info->bytes_stripe_reserve);
+       old0  | 
+       old0  |                 /* Check and see if our ticket can be satisfied now. */
+   <S5 old36 |                 if ((used_after <= space_info->total_bytes ||
+   <S5 old36 |                      can_overcommit(space_info, used, ticket->bytes, flush)) &&
+   <S5 old43 |                     stripe_claimable_admit(space_info, ticket->bytes, false)) {
+   >S5 old50 |                 if ((tused + ticket->bytes <= space_info->total_bytes ||
+   >S5 old50 |                      can_overcommit(space_info, tused, ticket->bytes, flush)) &&
+   >S5 old50 |                     stripe_claimable_admit(space_info, ticket->bytes, ticket->reloc)) {
+       old0  |                         btrfs_space_info_update_bytes_may_use(space_info, ticket->bytes);
+       old60 |                         if (ticket->hold_stripe)
+       old60 |                                 ticket->held = stripe_hold_locked(space_info);
+##### fs/btrfs/space-info.h: struct btrfs_space_info {
+   ...
+       old24 |                                            space cache but not yet allocated;
+       old24 |                                            will either be allocated or become
+       old24 |                                            trapped tails when the runs close, so
+       old24 |                                            reservations must not count on it
+       old24 |                                            either.  Synced from the block groups'
+       old24 |                                            stripe_open_remainder. */
+   <S5 old25 |         u64 bytes_stripe_margin;        /* stripe_alloc pessimistic reservation
+   <S5 old25 |                                            margin: one full stripe width per
+   <S5 old25 |                                            outstanding delalloc extent.  Pre-pays
+   <S5 old25 |                                            the worst-case sub-stripe tail each
+   <S5 old25 |                                            future extent can strand when its run
+   <S5 old25 |                                            closes, so commits between write() and
+   <S5 old25 |                                            writeback can never trap space out
+   <S5 old25 |                                            from under an admitted reservation.
+   <S5 old25 |                                            Charged and released in lockstep with
+   <S5 old25 |                                            the inodes' outstanding_extents. */
+   >S5 old105|         u64 bytes_stripe_margin;        /* data: one full stripe per
+   >S5 old105|                                            outstanding delalloc extent or
+   >S5 old105|                                            preallocation in flight, pre-paying
+   >S5 old105|                                            the sub-stripe tail a commit can trap
+   >S5 old105|                                            before writeback (see
+   >S5 old105|                                            btrfs_stripe_margin_mod()).
+##### fs/btrfs/sysfs.c: static ssize_t btrfs_stripe_park_stats_show(struct kobject *kobj,
+   ...
+       old22 | static ssize_t btrfs_stripe_park_stats_show(struct kobject *kobj,
+       old22 |                                             struct kobj_attribute *a, char *buf)
+       old22 | {
+       old22 |         struct btrfs_fs_info *fs_info = to_fs_info(kobj);
+   <S6 old78 |         int cached, pinned, live;
+   >S6 old80 |         /* Indexed by enum btrfs_stripe_run_class. */
+   >S6 old80 |         static const char * const class_names[] = {
+   >S6 old81 |                 "cow", "reloc", "log", "nocow", "meta", "meta_log",
+   >S6 old80 |         };
+   >S6 old80 |         int live_by_class[BTRFS_STRIPE_RUN_NR_CLASSES];
+   >S6 old80 |         int open_runs[BTRFS_STRIPE_RUN_NR_CLASSES];
+   >S6 old80 |         int cached, pinned, live, class;
+   >S6 old80 |         ssize_t len;
+       old22 | 
+   <S6 old78 |         btrfs_rbio_cache_usage(fs_info, &cached, &pinned, &live);
+   <S6 old22 |         return sysfs_emit(buf,
+   >S6 old80 |         BUILD_BUG_ON(ARRAY_SIZE(class_names) != BTRFS_STRIPE_RUN_NR_CLASSES);
+   >S6 old80 |         btrfs_rbio_cache_usage(fs_info, &cached, &pinned, &live, live_by_class);
+   >S6 old80 |         btrfs_count_open_stripe_runs(fs_info, open_runs);
+   >S6 old80 |         len = sysfs_emit(buf,
+       old22 |                 "parked %lld\n"
+       old22 |                 "merged_bytes %lld\n"
+   ...
+       old32 |                 "unparked_ready %lld\n"
+       old22 |                 "kicked %lld\n"
+       old22 |                 "expired %lld\n"
+       old32 |                 "stuck %lld\n"
+       old22 |                 "padded %lld\n"
+       old76 |                 "padded_unwritten %lld\n"
+   <S6 old22 |                 "rmw_reads %lld\n",
+   >S6 old28 |                 "rmw_reads %lld\n"
+   >S6 old30 |                 "data_rmw %lld\n"
+   >S6 old30 |                 "pad_decline_no_run %lld\n"
+   >S6 old31 |                 "pad_decline_uncovered %lld\n"
+   >S6 old71 |                 "data_rmw_pad_ok_nomem %lld\n"
+   >S6 old71 |                 "data_rmw_no_run %lld\n"
+   ...
+       old32 |                 atomic64_read(&fs_info->stripe_park_stats.unparked_ready),
+       old22 |                 atomic64_read(&fs_info->stripe_park_stats.kicked),
+       old22 |                 atomic64_read(&fs_info->stripe_park_stats.expired),
+       old32 |                 atomic64_read(&fs_info->stripe_park_stats.stuck),
+       old22 |                 atomic64_read(&fs_info->stripe_park_stats.padded),
+       old76 |                 atomic64_read(&fs_info->stripe_park_stats.padded_unwritten),
+   <S6 old22 |                 atomic64_read(&fs_info->stripe_park_stats.rmw_reads));
+   >S6 old28 |                 atomic64_read(&fs_info->stripe_park_stats.rmw_reads),
+   >S6 old30 |                 atomic64_read(&fs_info->stripe_park_stats.data_rmw),
+   >S6 old30 |                 atomic64_read(&fs_info->stripe_park_stats.pad_decline_no_run),
+   >S6 old31 |                 atomic64_read(&fs_info->stripe_park_stats.pad_decline_uncovered),
+   >S6 old107|                 atomic64_read(&fs_info->stripe_park_stats.data_rmw_by[BTRFS_STRIPE_PAD_OK]),
+   >S6 old107|                 atomic64_read(&fs_info->stripe_park_stats.data_rmw_by[BTRFS_STRIPE_PAD_NO_RUN]),
diff --git a/scripts/sa-reorder/rev9-S3.txt b/scripts/sa-reorder/rev9-S3.txt
new file mode 100644 (file)
index 0000000..5d5ddf1
--- /dev/null
@@ -0,0 +1,326 @@
+##### fs/btrfs/block-group.c: int btrfs_alloc_from_inode_stripe_run(struct btrfs_block_group *bg,
+   ...
+       old20 |                                       u64 num_bytes, u64 readopt_hint,
+       old20 |                                       u64 *ret_offset, u64 *available)
+       old14 | {
+       old14 |         struct btrfs_fs_info *fs_info = bg->fs_info;
+       old14 |         const u64 fsl = bg->full_stripe_len;
+       old85 |         const u64 root_id = btrfs_root_id(inode->root);
+   <S4 old20 |         const u64 ino = btrfs_ino(inode);
+   >S4 old83 |         const u64 ino = stripe_run_owner(inode, class, num_bytes, fsl);
+       old14 |         struct btrfs_open_stripe_run *new_run;
+       old14 |         struct btrfs_open_stripe_run *run;
+       old14 |         unsigned long flags;
+       old14 |         u64 tail_start = 0;
+       old14 |         u64 tail_len = 0;
+##### fs/btrfs/block-group.c: bool btrfs_stripe_run_pad_mask(struct btrfs_fs_info *fs_info, u64 stripe_start,
+   ...
+       old33 |                  * sub-stripe free space nothing can claim while the stripe
+       old33 |                  * holds live data.  They were never allocated, their live
+       old33 |                  * bits are clear, and they are exactly what a kicked park
+       old33 |                  * needs to pad.  An open run's end is stripe aligned, so
+       old33 |                  * overhang there means a stripe the run does not own.
+       old33 |                  */
+   <S6 old33 |                 if (stripe_start + stripe_len > run->end && run->open)
+   >S6 old71 |                 if (stripe_start + stripe_len > run->end && run->open) {
+   >S6 old71 |                         if (info)
+   >S6 old71 |                                 info->norun = BTRFS_STRIPE_NORUN_OVERHANG;
+       old33 |                         break;
+   >S6 old71 |                 }
+       old33 | 
+   ...
+       old33 |                 /*
+       old33 |                  * And wholly inside the map.  Declining here costs a
+       old33 |                  * read-modify-write; reading past the map would be a lie about
+       old33 |                  * which sectors are dead, and padding acts on that by
+       old33 |                  * overwriting them.
+       old33 |                  */
+   <S6 old33 |                 if (first + nsectors > run->live_nbits)
+   >S6 old71 |                 if (first + nsectors > run->live_nbits) {
+   >S6 old71 |                         if (info)
+   >S6 old71 |                                 info->norun = BTRFS_STRIPE_NORUN_PAST_MAP;
+       old33 |                         break;
+   >S6 old71 |                 }
+       old33 |                 bitmap_zero(dead, nsectors);
+##### fs/btrfs/block-group.c: void btrfs_scan_stripe_unusable(struct btrfs_fs_info *fs_info, bool force)
+   ...
+       old57 |                 u64 total_stranded = 0;
+   >S5 old50 |                 u64 largest = 0;
+   >S5 old50 |                 u64 unit = 0;
+   >S5 old50 |                 u32 nr_rw = 0;
+       old8  |                 int raid;
+       old8  | 
+   <S5 old8  |                 if (!(sinfo->flags & BTRFS_BLOCK_GROUP_DATA))
+   >S5 old48 |                 /*
+   >S5 old48 |                  * Data groups under stripe_alloc and metadata groups under
+   >S5 old48 |                  * stripe_meta both place extents in whole stripes only, so
+   >S5 old48 |                  * both carry trapped free space.  Mixed groups are refused.
+   >S5 old48 |                  */
+   >S5 old48 |                 if (!(sinfo->flags & (BTRFS_BLOCK_GROUP_DATA |
+##### fs/btrfs/block-group.c: static int inc_block_group_ro(struct btrfs_block_group *cache, bool force)
+   ...
+       old0  |                  * BTRFS_RESERVE_NO_FLUSH to give ourselves the most amount of
+       old0  |                  * leeway to allow us to mark this block group as read only.
+   >S5 old48 |                  *
+   >S5 old48 |                  * As for data above: a stripe_meta group's trapped bytes are
+   >S5 old48 |                  * already in the space_info total, do not re-provide them.
+       old0  |                  */
+   <S5 old0  |                 if (btrfs_can_overcommit(sinfo, num_bytes, BTRFS_RESERVE_NO_FLUSH))
+   >S5 old48 |                 u64 trapped = 0;
+   >S5 old48 | 
+   >S5 old48 |                 if (READ_ONCE(cache->stripe_unusable_ready))
+   >S5 old48 |                         trapped = min(READ_ONCE(cache->stripe_unusable), num_bytes);
+   >S5 old53 |                 /*
+   >S5 old53 |                  * The stripe_meta reserve is the room a group's live blocks
+##### fs/btrfs/block-group.c: static int btrfs_reclaim_block_group(struct btrfs_block_group *bg, int *reclaimed)
+   ...
+       old0  | 
+       old0  |         spin_lock(&space_info->lock);
+       old0  |         spin_lock(&bg->lock);
+   >S5 old114|         /* A forced reclaim is done once, or dropped with the group. */
+   >S5 old114|         forced = bg->stripe_reclaim_forced;
+   >S5 old114|         bg->stripe_reclaim_forced = STRIPE_RECLAIM_NONE;
+   <S5 old0  |         if (bg->reserved || bg->pinned || bg->ro) {
+   >S5 old47 |         if (bg->ro ||
+   >S5 old47 |             ((bg->reserved || bg->pinned) &&
+   >S5 old47 |              !btrfs_is_stripe_alloc_bg(bg) &&
+   >S5 old47 |              !btrfs_is_stripe_meta_bg(bg))) {
+       old0  |                 /*
+       old0  |                  * We want to bail if we made new allocations or have
+   ...
+       old0  |          *
+       old0  |          * Since the decision making process also depends on the amount
+       old0  |          * being freed, pass in a fake giant value to skip that extra
+       old0  |          * check, which is more meaningful when adding to the list in
+       old0  |          * the first place.
+       old0  |          */
+   <S5 old0  |         if (!should_reclaim_block_group(bg, bg->length)) {
+   >S5 old114|         if (forced) {
+   >S5 old114|                 /* stripe_reclaim_now chose already; the thresholds may say no. */
+   >S5 old114|                 compact = (forced == STRIPE_RECLAIM_COMPACT);
+   >S5 old114|         } else if (!should_reclaim_block_group(bg, bg->length)) {
+       old70 |                 /*
+       old70 |                  * Too full to relocate whole.  A stripe_alloc / stripe_meta
+   ...
+       old0  |         trace_btrfs_reclaim_block_group(bg);
+   >S6 old113|         btrfs_debug(fs_info,
+   >S6 old113| "reclaim: %s block group %llu flags 0x%llx length %llu used %llu reserved %llu trapped %llu",
+   >S6 old113|                     compact ? "compacting" : "relocating", bg->start, bg->flags,
+   >S6 old113|                     bg->length, used, reserved, trapped);
+       old70 |         if (compact) {
+   <S6 old70 |                 bool compacted;
+   <S6 old70 | 
+       old70 |                 ret = btrfs_compact_chunk(fs_info, bg->start, &compacted);
+       old70 |                 /*
+       old70 |                  * Compacted, the group stays: drop our read-only hold.  It
+       old70 |                  * gave back trapped space, not a chunk; what moved is counted
+       old70 |                  * in stripe_run_stats.
+       old70 |                  */
+   ...
+       old0  |         space_info->reclaim_count++;
+       old0  |         space_info->reclaim_bytes += used;
+       old0  |         space_info->reclaim_bytes += reserved;
+       old0  |         if (space_info->total_bytes < old_total)
+       old0  |                 btrfs_set_periodic_reclaim_ready(space_info, true);
+       old0  |         spin_unlock(&space_info->lock);
+   <S6 old0  |         if (!ret)
+   >S6 old113|         if (!ret) {
+       old0  |                 (*reclaimed)++;
+   >S6 old113|                 btrfs_debug(fs_info, "reclaim: %s block group %llu",
+   >S6 old113|                             compacted ? "compacted" : "relocated", bg->start);
+   >S6 old113|         }
+       old0  | 
+##### fs/btrfs/free-space-cache.c: void btrfs_block_group_init_stripe_unusable(struct btrfs_block_group *bg)
+   ...
+       old8  | void btrfs_block_group_init_stripe_unusable(struct btrfs_block_group *bg)
+       old8  | {
+       old8  |         struct btrfs_free_space_ctl *ctl = bg->free_space_ctl;
+       old34 |         u64 trapped, claimable, nstripes;
+       old8  |         u32 *freep;
+       old8  | 
+   <S5 old8  |         if (!btrfs_is_stripe_alloc_bg(bg))
+   >S5 old38 |         if (!btrfs_is_stripe_alloc_bg(bg) && !btrfs_is_stripe_meta_bg(bg))
+       old8  |                 return;
+       old8  |         if (READ_ONCE(bg->stripe_unusable_ready))
+       old8  |                 return;
+       old8  | 
+       old8  |         nstripes = stripe_unusable_nstripes(bg);
+##### fs/btrfs/free-space-cache.c: void btrfs_block_group_disarm_stripe_unusable(struct btrfs_block_group *bg)
+   ...
+       old8  | void btrfs_block_group_disarm_stripe_unusable(struct btrfs_block_group *bg)
+       old8  | {
+       old8  |         struct btrfs_free_space_ctl *ctl = bg->free_space_ctl;
+       old8  |         u64 trapped;
+       old34 |         u64 claimable;
+       old8  | 
+   <S5 old8  |         if (!btrfs_is_stripe_alloc_bg(bg))
+   >S5 old48 |         if (!btrfs_is_stripe_alloc_bg(bg) && !btrfs_is_stripe_meta_bg(bg))
+       old8  |                 return;
+       old8  | 
+       old8  |         spin_lock(&ctl->tree_lock);
+       old8  |         if (!bg->stripe_unusable_ready) {
+       old8  |                 spin_unlock(&ctl->tree_lock);
+##### fs/btrfs/free-space-cache.c: void btrfs_block_group_rescan_stripe_unusable(struct btrfs_block_group *bg)
+   ...
+       old8  | {
+       old8  |         struct btrfs_free_space_ctl *ctl = bg->free_space_ctl;
+       old46 |         bool reclaim = false;
+       old8  |         u64 nstripes;
+       old8  |         u32 *freep;
+       old8  | 
+   <S5 old8  |         if (!btrfs_is_stripe_alloc_bg(bg))
+   >S5 old48 |         if (!btrfs_is_stripe_alloc_bg(bg) && !btrfs_is_stripe_meta_bg(bg))
+       old8  |                 return;
+       old8  | 
+       old8  |         nstripes = stripe_unusable_nstripes(bg);
+       old8  |         freep = kvcalloc(nstripes, sizeof(*freep), GFP_NOFS);
+       old8  |         if (!freep)
+##### fs/btrfs/fs.h: struct btrfs_fs_info {
+   ...
+       old30 |                 /*
+       old105|                  * Data read-modify-writes in a covered block group, parked or
+       old105|                  * not; zero with allow_rmw empty.  rmw_reads counts only the
+       old105|                  * parked ones.
+       old30 |                  */
+       old30 |                 atomic64_t data_rmw;
+   <S6 old30 |                 /*
+   <S6 old105|                  * Why padding declined: live (the rest of the stripe is
+   <S6 old105|                  * allocated and not yet written), no_run (no open run covers
+   <S6 old105|                  * the stripe), unallocated (the run's frontier has not reached
+   <S6 old105|                  * the stripe).
+   <S6 old30 |                  */
+   <S6 old30 |                 atomic64_t pad_decline_live;
+   >S6 old107|                 /* Why padding declined: no open run covers the stripe. */
+       old30 |                 atomic64_t pad_decline_no_run;
+   <S6 old30 |                 atomic64_t pad_decline_unallocated;
+       old105|                 /*
+       old105|                  * Oracle allowed padding, but a sector below the frontier is
+       old105|                  * not covered by this write: another allocation shares the
+       old105|                  * stripe.
+       old105|                  */
+       old31 |                 atomic64_t pad_decline_uncovered;
+   ...
+   >S4 old83 |          * stripe or more stay in the inode's private run, and the commit waits
+   >S4 old83 |          * only for the logged extent's own stripes.  Clear: one private run
+   >S4 old83 |          * per fsyncing inode, closed at each log commit, with carry-forward of
+   >S4 old83 |          * its final partial stripe.  See btrfs_log_settle_stripes().
+   >S4 old83 |          */
+   >S4 old83 |         bool stripe_log_data_shared;
+   <S4 old59 |         /*
+   <S4 old59 |          * Stripe run lifecycle observability: lifetime counters exposed
+   <S4 old59 |          * through sysfs stripe_run_stats, so a test can show it exercised
+   <S4 old59 |          * the nocow private-run and stranded-stripe paths at all.
+   <S4 old59 |          */
+   >S4 old105|         /* Stripe run lifecycle counters (sysfs stripe_run_stats). */
+       old59 |         struct {
+       old59 |                 /* private NOCOW runs opened (they outlive commits) */
+       old59 |                 atomic64_t nocow_run_opened;
+       old59 |                 /* claim candidates refused for overlapping a live run */
+       old59 |                 atomic64_t claim_refused_live_run;
+   ...
+       old0  | 
+       old0  |         /* Device replace state */
+       old0  |         struct btrfs_dev_replace dev_replace;
+       old0  | 
+       old0  |         struct semaphore uuid_tree_rescan_sem;
+       old0  | 
+   <S6 old0  |         /* Used to reclaim the metadata space in the background. */
+   >S6 old105|         /* Drains legacy writes after stripe_alloc is enabled at runtime. */
+   >S6 old39 |         struct work_struct stripe_alloc_enable_work;
+   >S6 old105|         /* Used to reclaim the metadata space in the background. */
+       old0  |         struct work_struct async_reclaim_work;
+       old0  |         struct work_struct async_data_reclaim_work;
+       old0  |         struct work_struct preempt_reclaim_work;
+##### fs/btrfs/space-info.c: void btrfs_try_granting_tickets(struct btrfs_space_info *space_info)
+   ...
+   >S5 old50 |                  */
+   >S5 old50 |                 tused = used;
+   >S5 old50 |                 if (ticket->reloc)
+   >S5 old50 |                         tused -= min(tused, space_info->bytes_stripe_reserve);
+       old0  | 
+       old0  |                 /* Check and see if our ticket can be satisfied now. */
+   <S5 old36 |                 if ((used_after <= space_info->total_bytes ||
+   <S5 old36 |                      can_overcommit(space_info, used, ticket->bytes, flush)) &&
+   <S5 old43 |                     stripe_claimable_admit(space_info, ticket->bytes, false)) {
+   >S5 old50 |                 if ((tused + ticket->bytes <= space_info->total_bytes ||
+   >S5 old50 |                      can_overcommit(space_info, tused, ticket->bytes, flush)) &&
+   >S5 old50 |                     stripe_claimable_admit(space_info, ticket->bytes, ticket->reloc)) {
+       old0  |                         btrfs_space_info_update_bytes_may_use(space_info, ticket->bytes);
+       old60 |                         if (ticket->hold_stripe)
+       old60 |                                 ticket->held = stripe_hold_locked(space_info);
+##### fs/btrfs/space-info.h: struct btrfs_space_info {
+   ...
+       old24 |                                            space cache but not yet allocated;
+       old24 |                                            will either be allocated or become
+       old24 |                                            trapped tails when the runs close, so
+       old24 |                                            reservations must not count on it
+       old24 |                                            either.  Synced from the block groups'
+       old24 |                                            stripe_open_remainder. */
+   <S5 old25 |         u64 bytes_stripe_margin;        /* stripe_alloc pessimistic reservation
+   <S5 old25 |                                            margin: one full stripe width per
+   <S5 old25 |                                            outstanding delalloc extent.  Pre-pays
+   <S5 old25 |                                            the worst-case sub-stripe tail each
+   <S5 old25 |                                            future extent can strand when its run
+   <S5 old25 |                                            closes, so commits between write() and
+   <S5 old25 |                                            writeback can never trap space out
+   <S5 old25 |                                            from under an admitted reservation.
+   <S5 old25 |                                            Charged and released in lockstep with
+   <S5 old25 |                                            the inodes' outstanding_extents. */
+   >S5 old105|         u64 bytes_stripe_margin;        /* data: one full stripe per
+   >S5 old105|                                            outstanding delalloc extent or
+   >S5 old105|                                            preallocation in flight, pre-paying
+   >S5 old105|                                            the sub-stripe tail a commit can trap
+   >S5 old105|                                            before writeback (see
+   >S5 old105|                                            btrfs_stripe_margin_mod()).
+##### fs/btrfs/sysfs.c: static ssize_t btrfs_stripe_park_stats_show(struct kobject *kobj,
+   ...
+       old22 | static ssize_t btrfs_stripe_park_stats_show(struct kobject *kobj,
+       old22 |                                             struct kobj_attribute *a, char *buf)
+       old22 | {
+       old22 |         struct btrfs_fs_info *fs_info = to_fs_info(kobj);
+   <S6 old78 |         int cached, pinned, live;
+   >S6 old80 |         /* Indexed by enum btrfs_stripe_run_class. */
+   >S6 old80 |         static const char * const class_names[] = {
+   >S6 old81 |                 "cow", "reloc", "log", "nocow", "meta", "meta_log",
+   >S6 old80 |         };
+   >S6 old80 |         int live_by_class[BTRFS_STRIPE_RUN_NR_CLASSES];
+   >S6 old80 |         int open_runs[BTRFS_STRIPE_RUN_NR_CLASSES];
+   >S6 old80 |         int cached, pinned, live, class;
+   >S6 old80 |         ssize_t len;
+       old22 | 
+   <S6 old78 |         btrfs_rbio_cache_usage(fs_info, &cached, &pinned, &live);
+   <S6 old22 |         return sysfs_emit(buf,
+   >S6 old80 |         BUILD_BUG_ON(ARRAY_SIZE(class_names) != BTRFS_STRIPE_RUN_NR_CLASSES);
+   >S6 old80 |         btrfs_rbio_cache_usage(fs_info, &cached, &pinned, &live, live_by_class);
+   >S6 old80 |         btrfs_count_open_stripe_runs(fs_info, open_runs);
+   >S6 old80 |         len = sysfs_emit(buf,
+       old22 |                 "parked %lld\n"
+       old22 |                 "merged_bytes %lld\n"
+   ...
+       old32 |                 "unparked_ready %lld\n"
+       old22 |                 "kicked %lld\n"
+       old22 |                 "expired %lld\n"
+       old32 |                 "stuck %lld\n"
+       old22 |                 "padded %lld\n"
+       old76 |                 "padded_unwritten %lld\n"
+   <S6 old22 |                 "rmw_reads %lld\n",
+   >S6 old28 |                 "rmw_reads %lld\n"
+   >S6 old30 |                 "data_rmw %lld\n"
+   >S6 old30 |                 "pad_decline_no_run %lld\n"
+   >S6 old31 |                 "pad_decline_uncovered %lld\n"
+   >S6 old71 |                 "data_rmw_pad_ok_nomem %lld\n"
+   >S6 old71 |                 "data_rmw_no_run %lld\n"
+   ...
+       old32 |                 atomic64_read(&fs_info->stripe_park_stats.unparked_ready),
+       old22 |                 atomic64_read(&fs_info->stripe_park_stats.kicked),
+       old22 |                 atomic64_read(&fs_info->stripe_park_stats.expired),
+       old32 |                 atomic64_read(&fs_info->stripe_park_stats.stuck),
+       old22 |                 atomic64_read(&fs_info->stripe_park_stats.padded),
+       old76 |                 atomic64_read(&fs_info->stripe_park_stats.padded_unwritten),
+   <S6 old22 |                 atomic64_read(&fs_info->stripe_park_stats.rmw_reads));
+   >S6 old28 |                 atomic64_read(&fs_info->stripe_park_stats.rmw_reads),
+   >S6 old30 |                 atomic64_read(&fs_info->stripe_park_stats.data_rmw),
+   >S6 old30 |                 atomic64_read(&fs_info->stripe_park_stats.pad_decline_no_run),
+   >S6 old31 |                 atomic64_read(&fs_info->stripe_park_stats.pad_decline_uncovered),
+   >S6 old107|                 atomic64_read(&fs_info->stripe_park_stats.data_rmw_by[BTRFS_STRIPE_PAD_OK]),
+   >S6 old107|                 atomic64_read(&fs_info->stripe_park_stats.data_rmw_by[BTRFS_STRIPE_PAD_NO_RUN]),
diff --git a/scripts/sa-reorder/rev9-S4.txt b/scripts/sa-reorder/rev9-S4.txt
new file mode 100644 (file)
index 0000000..901daeb
--- /dev/null
@@ -0,0 +1,293 @@
+##### fs/btrfs/block-group.c: bool btrfs_stripe_run_pad_mask(struct btrfs_fs_info *fs_info, u64 stripe_start,
+   ...
+       old33 |                  * sub-stripe free space nothing can claim while the stripe
+       old33 |                  * holds live data.  They were never allocated, their live
+       old33 |                  * bits are clear, and they are exactly what a kicked park
+       old33 |                  * needs to pad.  An open run's end is stripe aligned, so
+       old33 |                  * overhang there means a stripe the run does not own.
+       old33 |                  */
+   <S6 old33 |                 if (stripe_start + stripe_len > run->end && run->open)
+   >S6 old71 |                 if (stripe_start + stripe_len > run->end && run->open) {
+   >S6 old71 |                         if (info)
+   >S6 old71 |                                 info->norun = BTRFS_STRIPE_NORUN_OVERHANG;
+       old33 |                         break;
+   >S6 old71 |                 }
+       old33 | 
+   ...
+       old33 |                 /*
+       old33 |                  * And wholly inside the map.  Declining here costs a
+       old33 |                  * read-modify-write; reading past the map would be a lie about
+       old33 |                  * which sectors are dead, and padding acts on that by
+       old33 |                  * overwriting them.
+       old33 |                  */
+   <S6 old33 |                 if (first + nsectors > run->live_nbits)
+   >S6 old71 |                 if (first + nsectors > run->live_nbits) {
+   >S6 old71 |                         if (info)
+   >S6 old71 |                                 info->norun = BTRFS_STRIPE_NORUN_PAST_MAP;
+       old33 |                         break;
+   >S6 old71 |                 }
+       old33 |                 bitmap_zero(dead, nsectors);
+##### fs/btrfs/block-group.c: void btrfs_scan_stripe_unusable(struct btrfs_fs_info *fs_info, bool force)
+   ...
+       old57 |                 u64 total_stranded = 0;
+   >S5 old50 |                 u64 largest = 0;
+   >S5 old50 |                 u64 unit = 0;
+   >S5 old50 |                 u32 nr_rw = 0;
+       old8  |                 int raid;
+       old8  | 
+   <S5 old8  |                 if (!(sinfo->flags & BTRFS_BLOCK_GROUP_DATA))
+   >S5 old48 |                 /*
+   >S5 old48 |                  * Data groups under stripe_alloc and metadata groups under
+   >S5 old48 |                  * stripe_meta both place extents in whole stripes only, so
+   >S5 old48 |                  * both carry trapped free space.  Mixed groups are refused.
+   >S5 old48 |                  */
+   >S5 old48 |                 if (!(sinfo->flags & (BTRFS_BLOCK_GROUP_DATA |
+##### fs/btrfs/block-group.c: static int inc_block_group_ro(struct btrfs_block_group *cache, bool force)
+   ...
+       old0  |                  * BTRFS_RESERVE_NO_FLUSH to give ourselves the most amount of
+       old0  |                  * leeway to allow us to mark this block group as read only.
+   >S5 old48 |                  *
+   >S5 old48 |                  * As for data above: a stripe_meta group's trapped bytes are
+   >S5 old48 |                  * already in the space_info total, do not re-provide them.
+       old0  |                  */
+   <S5 old0  |                 if (btrfs_can_overcommit(sinfo, num_bytes, BTRFS_RESERVE_NO_FLUSH))
+   >S5 old48 |                 u64 trapped = 0;
+   >S5 old48 | 
+   >S5 old48 |                 if (READ_ONCE(cache->stripe_unusable_ready))
+   >S5 old48 |                         trapped = min(READ_ONCE(cache->stripe_unusable), num_bytes);
+   >S5 old53 |                 /*
+   >S5 old53 |                  * The stripe_meta reserve is the room a group's live blocks
+##### fs/btrfs/block-group.c: static int btrfs_reclaim_block_group(struct btrfs_block_group *bg, int *reclaimed)
+   ...
+       old0  | 
+       old0  |         spin_lock(&space_info->lock);
+       old0  |         spin_lock(&bg->lock);
+   >S5 old114|         /* A forced reclaim is done once, or dropped with the group. */
+   >S5 old114|         forced = bg->stripe_reclaim_forced;
+   >S5 old114|         bg->stripe_reclaim_forced = STRIPE_RECLAIM_NONE;
+   <S5 old0  |         if (bg->reserved || bg->pinned || bg->ro) {
+   >S5 old47 |         if (bg->ro ||
+   >S5 old47 |             ((bg->reserved || bg->pinned) &&
+   >S5 old47 |              !btrfs_is_stripe_alloc_bg(bg) &&
+   >S5 old47 |              !btrfs_is_stripe_meta_bg(bg))) {
+       old0  |                 /*
+       old0  |                  * We want to bail if we made new allocations or have
+   ...
+       old0  |          *
+       old0  |          * Since the decision making process also depends on the amount
+       old0  |          * being freed, pass in a fake giant value to skip that extra
+       old0  |          * check, which is more meaningful when adding to the list in
+       old0  |          * the first place.
+       old0  |          */
+   <S5 old0  |         if (!should_reclaim_block_group(bg, bg->length)) {
+   >S5 old114|         if (forced) {
+   >S5 old114|                 /* stripe_reclaim_now chose already; the thresholds may say no. */
+   >S5 old114|                 compact = (forced == STRIPE_RECLAIM_COMPACT);
+   >S5 old114|         } else if (!should_reclaim_block_group(bg, bg->length)) {
+       old70 |                 /*
+       old70 |                  * Too full to relocate whole.  A stripe_alloc / stripe_meta
+   ...
+       old0  |         trace_btrfs_reclaim_block_group(bg);
+   >S6 old113|         btrfs_debug(fs_info,
+   >S6 old113| "reclaim: %s block group %llu flags 0x%llx length %llu used %llu reserved %llu trapped %llu",
+   >S6 old113|                     compact ? "compacting" : "relocating", bg->start, bg->flags,
+   >S6 old113|                     bg->length, used, reserved, trapped);
+       old70 |         if (compact) {
+   <S6 old70 |                 bool compacted;
+   <S6 old70 | 
+       old70 |                 ret = btrfs_compact_chunk(fs_info, bg->start, &compacted);
+       old70 |                 /*
+       old70 |                  * Compacted, the group stays: drop our read-only hold.  It
+       old70 |                  * gave back trapped space, not a chunk; what moved is counted
+       old70 |                  * in stripe_run_stats.
+       old70 |                  */
+   ...
+       old0  |         space_info->reclaim_count++;
+       old0  |         space_info->reclaim_bytes += used;
+       old0  |         space_info->reclaim_bytes += reserved;
+       old0  |         if (space_info->total_bytes < old_total)
+       old0  |                 btrfs_set_periodic_reclaim_ready(space_info, true);
+       old0  |         spin_unlock(&space_info->lock);
+   <S6 old0  |         if (!ret)
+   >S6 old113|         if (!ret) {
+       old0  |                 (*reclaimed)++;
+   >S6 old113|                 btrfs_debug(fs_info, "reclaim: %s block group %llu",
+   >S6 old113|                             compacted ? "compacted" : "relocated", bg->start);
+   >S6 old113|         }
+       old0  | 
+##### fs/btrfs/free-space-cache.c: void btrfs_block_group_init_stripe_unusable(struct btrfs_block_group *bg)
+   ...
+       old8  | void btrfs_block_group_init_stripe_unusable(struct btrfs_block_group *bg)
+       old8  | {
+       old8  |         struct btrfs_free_space_ctl *ctl = bg->free_space_ctl;
+       old34 |         u64 trapped, claimable, nstripes;
+       old8  |         u32 *freep;
+       old8  | 
+   <S5 old8  |         if (!btrfs_is_stripe_alloc_bg(bg))
+   >S5 old38 |         if (!btrfs_is_stripe_alloc_bg(bg) && !btrfs_is_stripe_meta_bg(bg))
+       old8  |                 return;
+       old8  |         if (READ_ONCE(bg->stripe_unusable_ready))
+       old8  |                 return;
+       old8  | 
+       old8  |         nstripes = stripe_unusable_nstripes(bg);
+##### fs/btrfs/free-space-cache.c: void btrfs_block_group_disarm_stripe_unusable(struct btrfs_block_group *bg)
+   ...
+       old8  | void btrfs_block_group_disarm_stripe_unusable(struct btrfs_block_group *bg)
+       old8  | {
+       old8  |         struct btrfs_free_space_ctl *ctl = bg->free_space_ctl;
+       old8  |         u64 trapped;
+       old34 |         u64 claimable;
+       old8  | 
+   <S5 old8  |         if (!btrfs_is_stripe_alloc_bg(bg))
+   >S5 old48 |         if (!btrfs_is_stripe_alloc_bg(bg) && !btrfs_is_stripe_meta_bg(bg))
+       old8  |                 return;
+       old8  | 
+       old8  |         spin_lock(&ctl->tree_lock);
+       old8  |         if (!bg->stripe_unusable_ready) {
+       old8  |                 spin_unlock(&ctl->tree_lock);
+##### fs/btrfs/free-space-cache.c: void btrfs_block_group_rescan_stripe_unusable(struct btrfs_block_group *bg)
+   ...
+       old8  | {
+       old8  |         struct btrfs_free_space_ctl *ctl = bg->free_space_ctl;
+       old46 |         bool reclaim = false;
+       old8  |         u64 nstripes;
+       old8  |         u32 *freep;
+       old8  | 
+   <S5 old8  |         if (!btrfs_is_stripe_alloc_bg(bg))
+   >S5 old48 |         if (!btrfs_is_stripe_alloc_bg(bg) && !btrfs_is_stripe_meta_bg(bg))
+       old8  |                 return;
+       old8  | 
+       old8  |         nstripes = stripe_unusable_nstripes(bg);
+       old8  |         freep = kvcalloc(nstripes, sizeof(*freep), GFP_NOFS);
+       old8  |         if (!freep)
+##### fs/btrfs/fs.h: struct btrfs_fs_info {
+   ...
+       old30 |                 /*
+       old105|                  * Data read-modify-writes in a covered block group, parked or
+       old105|                  * not; zero with allow_rmw empty.  rmw_reads counts only the
+       old105|                  * parked ones.
+       old30 |                  */
+       old30 |                 atomic64_t data_rmw;
+   <S6 old30 |                 /*
+   <S6 old105|                  * Why padding declined: live (the rest of the stripe is
+   <S6 old105|                  * allocated and not yet written), no_run (no open run covers
+   <S6 old105|                  * the stripe), unallocated (the run's frontier has not reached
+   <S6 old105|                  * the stripe).
+   <S6 old30 |                  */
+   <S6 old30 |                 atomic64_t pad_decline_live;
+   >S6 old107|                 /* Why padding declined: no open run covers the stripe. */
+       old30 |                 atomic64_t pad_decline_no_run;
+   <S6 old30 |                 atomic64_t pad_decline_unallocated;
+       old105|                 /*
+       old105|                  * Oracle allowed padding, but a sector below the frontier is
+       old105|                  * not covered by this write: another allocation shares the
+       old105|                  * stripe.
+       old105|                  */
+       old31 |                 atomic64_t pad_decline_uncovered;
+   ...
+       old0  | 
+       old0  |         /* Device replace state */
+       old0  |         struct btrfs_dev_replace dev_replace;
+       old0  | 
+       old0  |         struct semaphore uuid_tree_rescan_sem;
+       old0  | 
+   <S6 old0  |         /* Used to reclaim the metadata space in the background. */
+   >S6 old105|         /* Drains legacy writes after stripe_alloc is enabled at runtime. */
+   >S6 old39 |         struct work_struct stripe_alloc_enable_work;
+   >S6 old105|         /* Used to reclaim the metadata space in the background. */
+       old0  |         struct work_struct async_reclaim_work;
+       old0  |         struct work_struct async_data_reclaim_work;
+       old0  |         struct work_struct preempt_reclaim_work;
+##### fs/btrfs/space-info.c: void btrfs_try_granting_tickets(struct btrfs_space_info *space_info)
+   ...
+   >S5 old50 |                  */
+   >S5 old50 |                 tused = used;
+   >S5 old50 |                 if (ticket->reloc)
+   >S5 old50 |                         tused -= min(tused, space_info->bytes_stripe_reserve);
+       old0  | 
+       old0  |                 /* Check and see if our ticket can be satisfied now. */
+   <S5 old36 |                 if ((used_after <= space_info->total_bytes ||
+   <S5 old36 |                      can_overcommit(space_info, used, ticket->bytes, flush)) &&
+   <S5 old43 |                     stripe_claimable_admit(space_info, ticket->bytes, false)) {
+   >S5 old50 |                 if ((tused + ticket->bytes <= space_info->total_bytes ||
+   >S5 old50 |                      can_overcommit(space_info, tused, ticket->bytes, flush)) &&
+   >S5 old50 |                     stripe_claimable_admit(space_info, ticket->bytes, ticket->reloc)) {
+       old0  |                         btrfs_space_info_update_bytes_may_use(space_info, ticket->bytes);
+       old60 |                         if (ticket->hold_stripe)
+       old60 |                                 ticket->held = stripe_hold_locked(space_info);
+##### fs/btrfs/space-info.h: struct btrfs_space_info {
+   ...
+       old24 |                                            space cache but not yet allocated;
+       old24 |                                            will either be allocated or become
+       old24 |                                            trapped tails when the runs close, so
+       old24 |                                            reservations must not count on it
+       old24 |                                            either.  Synced from the block groups'
+       old24 |                                            stripe_open_remainder. */
+   <S5 old25 |         u64 bytes_stripe_margin;        /* stripe_alloc pessimistic reservation
+   <S5 old25 |                                            margin: one full stripe width per
+   <S5 old25 |                                            outstanding delalloc extent.  Pre-pays
+   <S5 old25 |                                            the worst-case sub-stripe tail each
+   <S5 old25 |                                            future extent can strand when its run
+   <S5 old25 |                                            closes, so commits between write() and
+   <S5 old25 |                                            writeback can never trap space out
+   <S5 old25 |                                            from under an admitted reservation.
+   <S5 old25 |                                            Charged and released in lockstep with
+   <S5 old25 |                                            the inodes' outstanding_extents. */
+   >S5 old105|         u64 bytes_stripe_margin;        /* data: one full stripe per
+   >S5 old105|                                            outstanding delalloc extent or
+   >S5 old105|                                            preallocation in flight, pre-paying
+   >S5 old105|                                            the sub-stripe tail a commit can trap
+   >S5 old105|                                            before writeback (see
+   >S5 old105|                                            btrfs_stripe_margin_mod()).
+##### fs/btrfs/sysfs.c: static ssize_t btrfs_stripe_park_stats_show(struct kobject *kobj,
+   ...
+       old22 | static ssize_t btrfs_stripe_park_stats_show(struct kobject *kobj,
+       old22 |                                             struct kobj_attribute *a, char *buf)
+       old22 | {
+       old22 |         struct btrfs_fs_info *fs_info = to_fs_info(kobj);
+   <S6 old78 |         int cached, pinned, live;
+   >S6 old80 |         /* Indexed by enum btrfs_stripe_run_class. */
+   >S6 old80 |         static const char * const class_names[] = {
+   >S6 old81 |                 "cow", "reloc", "log", "nocow", "meta", "meta_log",
+   >S6 old80 |         };
+   >S6 old80 |         int live_by_class[BTRFS_STRIPE_RUN_NR_CLASSES];
+   >S6 old80 |         int open_runs[BTRFS_STRIPE_RUN_NR_CLASSES];
+   >S6 old80 |         int cached, pinned, live, class;
+   >S6 old80 |         ssize_t len;
+       old22 | 
+   <S6 old78 |         btrfs_rbio_cache_usage(fs_info, &cached, &pinned, &live);
+   <S6 old22 |         return sysfs_emit(buf,
+   >S6 old80 |         BUILD_BUG_ON(ARRAY_SIZE(class_names) != BTRFS_STRIPE_RUN_NR_CLASSES);
+   >S6 old80 |         btrfs_rbio_cache_usage(fs_info, &cached, &pinned, &live, live_by_class);
+   >S6 old80 |         btrfs_count_open_stripe_runs(fs_info, open_runs);
+   >S6 old80 |         len = sysfs_emit(buf,
+       old22 |                 "parked %lld\n"
+       old22 |                 "merged_bytes %lld\n"
+   ...
+       old32 |                 "unparked_ready %lld\n"
+       old22 |                 "kicked %lld\n"
+       old22 |                 "expired %lld\n"
+       old32 |                 "stuck %lld\n"
+       old22 |                 "padded %lld\n"
+       old76 |                 "padded_unwritten %lld\n"
+   <S6 old22 |                 "rmw_reads %lld\n",
+   >S6 old28 |                 "rmw_reads %lld\n"
+   >S6 old30 |                 "data_rmw %lld\n"
+   >S6 old30 |                 "pad_decline_no_run %lld\n"
+   >S6 old31 |                 "pad_decline_uncovered %lld\n"
+   >S6 old71 |                 "data_rmw_pad_ok_nomem %lld\n"
+   >S6 old71 |                 "data_rmw_no_run %lld\n"
+   ...
+       old32 |                 atomic64_read(&fs_info->stripe_park_stats.unparked_ready),
+       old22 |                 atomic64_read(&fs_info->stripe_park_stats.kicked),
+       old22 |                 atomic64_read(&fs_info->stripe_park_stats.expired),
+       old32 |                 atomic64_read(&fs_info->stripe_park_stats.stuck),
+       old22 |                 atomic64_read(&fs_info->stripe_park_stats.padded),
+       old76 |                 atomic64_read(&fs_info->stripe_park_stats.padded_unwritten),
+   <S6 old22 |                 atomic64_read(&fs_info->stripe_park_stats.rmw_reads));
+   >S6 old28 |                 atomic64_read(&fs_info->stripe_park_stats.rmw_reads),
+   >S6 old30 |                 atomic64_read(&fs_info->stripe_park_stats.data_rmw),
+   >S6 old30 |                 atomic64_read(&fs_info->stripe_park_stats.pad_decline_no_run),
+   >S6 old31 |                 atomic64_read(&fs_info->stripe_park_stats.pad_decline_uncovered),
+   >S6 old107|                 atomic64_read(&fs_info->stripe_park_stats.data_rmw_by[BTRFS_STRIPE_PAD_OK]),
+   >S6 old107|                 atomic64_read(&fs_info->stripe_park_stats.data_rmw_by[BTRFS_STRIPE_PAD_NO_RUN]),
diff --git a/scripts/sa-reorder/rev9-S5.txt b/scripts/sa-reorder/rev9-S5.txt
new file mode 100644 (file)
index 0000000..c90be37
--- /dev/null
@@ -0,0 +1,149 @@
+##### fs/btrfs/block-group.c: bool btrfs_stripe_run_pad_mask(struct btrfs_fs_info *fs_info, u64 stripe_start,
+   ...
+       old33 |                  * sub-stripe free space nothing can claim while the stripe
+       old33 |                  * holds live data.  They were never allocated, their live
+       old33 |                  * bits are clear, and they are exactly what a kicked park
+       old33 |                  * needs to pad.  An open run's end is stripe aligned, so
+       old33 |                  * overhang there means a stripe the run does not own.
+       old33 |                  */
+   <S6 old33 |                 if (stripe_start + stripe_len > run->end && run->open)
+   >S6 old71 |                 if (stripe_start + stripe_len > run->end && run->open) {
+   >S6 old71 |                         if (info)
+   >S6 old71 |                                 info->norun = BTRFS_STRIPE_NORUN_OVERHANG;
+       old33 |                         break;
+   >S6 old71 |                 }
+       old33 | 
+   ...
+       old33 |                 /*
+       old33 |                  * And wholly inside the map.  Declining here costs a
+       old33 |                  * read-modify-write; reading past the map would be a lie about
+       old33 |                  * which sectors are dead, and padding acts on that by
+       old33 |                  * overwriting them.
+       old33 |                  */
+   <S6 old33 |                 if (first + nsectors > run->live_nbits)
+   >S6 old71 |                 if (first + nsectors > run->live_nbits) {
+   >S6 old71 |                         if (info)
+   >S6 old71 |                                 info->norun = BTRFS_STRIPE_NORUN_PAST_MAP;
+       old33 |                         break;
+   >S6 old71 |                 }
+       old33 |                 bitmap_zero(dead, nsectors);
+##### fs/btrfs/block-group.c: static int btrfs_reclaim_block_group(struct btrfs_block_group *bg, int *reclaimed)
+   ...
+       old0  |         trace_btrfs_reclaim_block_group(bg);
+   >S6 old113|         btrfs_debug(fs_info,
+   >S6 old113| "reclaim: %s block group %llu flags 0x%llx length %llu used %llu reserved %llu trapped %llu",
+   >S6 old113|                     compact ? "compacting" : "relocating", bg->start, bg->flags,
+   >S6 old113|                     bg->length, used, reserved, trapped);
+       old70 |         if (compact) {
+   <S6 old70 |                 bool compacted;
+   <S6 old70 | 
+       old70 |                 ret = btrfs_compact_chunk(fs_info, bg->start, &compacted);
+       old70 |                 /*
+       old70 |                  * Compacted, the group stays: drop our read-only hold.  It
+       old70 |                  * gave back trapped space, not a chunk; what moved is counted
+       old70 |                  * in stripe_run_stats.
+       old70 |                  */
+   ...
+       old0  |         space_info->reclaim_count++;
+       old0  |         space_info->reclaim_bytes += used;
+       old0  |         space_info->reclaim_bytes += reserved;
+       old0  |         if (space_info->total_bytes < old_total)
+       old0  |                 btrfs_set_periodic_reclaim_ready(space_info, true);
+       old0  |         spin_unlock(&space_info->lock);
+   <S6 old0  |         if (!ret)
+   >S6 old113|         if (!ret) {
+       old0  |                 (*reclaimed)++;
+   >S6 old113|                 btrfs_debug(fs_info, "reclaim: %s block group %llu",
+   >S6 old113|                             compacted ? "compacted" : "relocated", bg->start);
+   >S6 old113|         }
+       old0  | 
+##### fs/btrfs/fs.h: struct btrfs_fs_info {
+   ...
+       old30 |                 /*
+       old105|                  * Data read-modify-writes in a covered block group, parked or
+       old105|                  * not; zero with allow_rmw empty.  rmw_reads counts only the
+       old105|                  * parked ones.
+       old30 |                  */
+       old30 |                 atomic64_t data_rmw;
+   <S6 old30 |                 /*
+   <S6 old105|                  * Why padding declined: live (the rest of the stripe is
+   <S6 old105|                  * allocated and not yet written), no_run (no open run covers
+   <S6 old105|                  * the stripe), unallocated (the run's frontier has not reached
+   <S6 old105|                  * the stripe).
+   <S6 old30 |                  */
+   <S6 old30 |                 atomic64_t pad_decline_live;
+   >S6 old107|                 /* Why padding declined: no open run covers the stripe. */
+       old30 |                 atomic64_t pad_decline_no_run;
+   <S6 old30 |                 atomic64_t pad_decline_unallocated;
+       old105|                 /*
+       old105|                  * Oracle allowed padding, but a sector below the frontier is
+       old105|                  * not covered by this write: another allocation shares the
+       old105|                  * stripe.
+       old105|                  */
+       old31 |                 atomic64_t pad_decline_uncovered;
+   ...
+       old0  | 
+       old0  |         /* Device replace state */
+       old0  |         struct btrfs_dev_replace dev_replace;
+       old0  | 
+       old0  |         struct semaphore uuid_tree_rescan_sem;
+       old0  | 
+   <S6 old0  |         /* Used to reclaim the metadata space in the background. */
+   >S6 old105|         /* Drains legacy writes after stripe_alloc is enabled at runtime. */
+   >S6 old39 |         struct work_struct stripe_alloc_enable_work;
+   >S6 old105|         /* Used to reclaim the metadata space in the background. */
+       old0  |         struct work_struct async_reclaim_work;
+       old0  |         struct work_struct async_data_reclaim_work;
+       old0  |         struct work_struct preempt_reclaim_work;
+##### fs/btrfs/sysfs.c: static ssize_t btrfs_stripe_park_stats_show(struct kobject *kobj,
+   ...
+       old22 | static ssize_t btrfs_stripe_park_stats_show(struct kobject *kobj,
+       old22 |                                             struct kobj_attribute *a, char *buf)
+       old22 | {
+       old22 |         struct btrfs_fs_info *fs_info = to_fs_info(kobj);
+   <S6 old78 |         int cached, pinned, live;
+   >S6 old80 |         /* Indexed by enum btrfs_stripe_run_class. */
+   >S6 old80 |         static const char * const class_names[] = {
+   >S6 old81 |                 "cow", "reloc", "log", "nocow", "meta", "meta_log",
+   >S6 old80 |         };
+   >S6 old80 |         int live_by_class[BTRFS_STRIPE_RUN_NR_CLASSES];
+   >S6 old80 |         int open_runs[BTRFS_STRIPE_RUN_NR_CLASSES];
+   >S6 old80 |         int cached, pinned, live, class;
+   >S6 old80 |         ssize_t len;
+       old22 | 
+   <S6 old78 |         btrfs_rbio_cache_usage(fs_info, &cached, &pinned, &live);
+   <S6 old22 |         return sysfs_emit(buf,
+   >S6 old80 |         BUILD_BUG_ON(ARRAY_SIZE(class_names) != BTRFS_STRIPE_RUN_NR_CLASSES);
+   >S6 old80 |         btrfs_rbio_cache_usage(fs_info, &cached, &pinned, &live, live_by_class);
+   >S6 old80 |         btrfs_count_open_stripe_runs(fs_info, open_runs);
+   >S6 old80 |         len = sysfs_emit(buf,
+       old22 |                 "parked %lld\n"
+       old22 |                 "merged_bytes %lld\n"
+   ...
+       old32 |                 "unparked_ready %lld\n"
+       old22 |                 "kicked %lld\n"
+       old22 |                 "expired %lld\n"
+       old32 |                 "stuck %lld\n"
+       old22 |                 "padded %lld\n"
+       old76 |                 "padded_unwritten %lld\n"
+   <S6 old22 |                 "rmw_reads %lld\n",
+   >S6 old28 |                 "rmw_reads %lld\n"
+   >S6 old30 |                 "data_rmw %lld\n"
+   >S6 old30 |                 "pad_decline_no_run %lld\n"
+   >S6 old31 |                 "pad_decline_uncovered %lld\n"
+   >S6 old71 |                 "data_rmw_pad_ok_nomem %lld\n"
+   >S6 old71 |                 "data_rmw_no_run %lld\n"
+   ...
+       old32 |                 atomic64_read(&fs_info->stripe_park_stats.unparked_ready),
+       old22 |                 atomic64_read(&fs_info->stripe_park_stats.kicked),
+       old22 |                 atomic64_read(&fs_info->stripe_park_stats.expired),
+       old32 |                 atomic64_read(&fs_info->stripe_park_stats.stuck),
+       old22 |                 atomic64_read(&fs_info->stripe_park_stats.padded),
+       old76 |                 atomic64_read(&fs_info->stripe_park_stats.padded_unwritten),
+   <S6 old22 |                 atomic64_read(&fs_info->stripe_park_stats.rmw_reads));
+   >S6 old28 |                 atomic64_read(&fs_info->stripe_park_stats.rmw_reads),
+   >S6 old30 |                 atomic64_read(&fs_info->stripe_park_stats.data_rmw),
+   >S6 old30 |                 atomic64_read(&fs_info->stripe_park_stats.pad_decline_no_run),
+   >S6 old31 |                 atomic64_read(&fs_info->stripe_park_stats.pad_decline_uncovered),
+   >S6 old107|                 atomic64_read(&fs_info->stripe_park_stats.data_rmw_by[BTRFS_STRIPE_PAD_OK]),
+   >S6 old107|                 atomic64_read(&fs_info->stripe_park_stats.data_rmw_by[BTRFS_STRIPE_PAD_NO_RUN]),
diff --git a/scripts/sa-reorder/review4-618.txt b/scripts/sa-reorder/review4-618.txt
new file mode 100644 (file)
index 0000000..8893af7
--- /dev/null
@@ -0,0 +1,64 @@
+3-class hunks placed outside the subtopic: 0
+functions the subtopic wrote code in: 38
+  S3 final  fs/btrfs/block-group.c: bool btrfs_reclaim_backoff_active(struct btrfs_space_info *space_info)
+  later  fs/btrfs/block-group.c: int btrfs_stripe_reclaim_now(struct btrfs_fs_info *fs_info, bool all, 
+        S6 old132.5: 3 lines: -                } else if (!btrfs_is_stripe_alloc_bg(bg)) { | +         } else if (!btrfs_is_stripe_alloc_bg(bg) && | +                    !btrfs_is_stripe_meta_bg(bg)) {
+        S6 old132.5: 3 lines: -                                if (!btrfs_is_stripe_alloc_bg(bg)) | +                          if (!btrfs_is_stripe_alloc_bg(bg) && | +                                    !btrfs_is_stripe_meta_bg(bg))
+  S3 final  fs/btrfs/block-group.c: static bool reclaim_yielding(const struct btrfs_fs_info *fs_info)
+  S3 final  fs/btrfs/block-group.c: static bool stripe_reclaim_now_queue(struct btrfs_block_group *bg,
+  S3 final  fs/btrfs/block-group.c: static u64 reclaim_free_bytes(const struct btrfs_space_info *space_inf
+  S3 final  fs/btrfs/block-group.c: static u64 stripe_reclaim_chunk_room(struct btrfs_block_group *bg)
+  later  fs/btrfs/block-group.c: static void btrfs_stripe_reclaim_tick(struct btrfs_fs_info *fs_info)
+        S6 old49.5: 3 lines: -         if (!(sinfo->flags & BTRFS_BLOCK_GROUP_DATA)) | +               if (!(sinfo->flags & (BTRFS_BLOCK_GROUP_DATA | | +                                    BTRFS_BLOCK_GROUP_METADATA)))
+        S6 old77: 3 lines: -                                 BTRFS_BLOCK_GROUP_METADATA))) | +                               BTRFS_BLOCK_GROUP_METADATA | | +                                BTRFS_BLOCK_GROUP_SYSTEM)))
+  S3 final  fs/btrfs/block-group.c: static void reclaim_note_result(struct btrfs_block_group *bg, bool eno
+  later  fs/btrfs/block-group.c: void btrfs_reclaim_bgs_work(struct work_struct *work)
+        S6 old49.5: 2 lines: -          * A stripe_alloc group's live extents can only | +              * A stripe_alloc / stripe_meta group's live extents can 
+        S6 old49.5: 2 lines: -         if (btrfs_is_stripe_alloc_bg(bg)) { | +         if (btrfs_is_stripe_alloc_bg(bg) || btrfs_is_stripe_meta_
+        S6 old49.5: 3 lines: -              !btrfs_is_stripe_alloc_bg(bg))) { | +                   !btrfs_is_stripe_alloc_bg(bg) && | +                    !btrfs_is_stripe_meta_bg(bg))) {
+        S6 old49.5: 2 lines: -                  * Not for a stripe_alloc group: under | +                       * Not for a stripe_alloc or stripe_meta group: under
+        S6 old132.5: 4 lines: -                         * Too full to relocate whole.  A stripe_alloc | +                       * Too full to relocate whole.  A stripe_alloc / | -                     * group whose free space is trapped in
+  later  fs/btrfs/disk-io.c: void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)
+        S5 old40: 1 lines: +   INIT_WORK(&fs_info->stripe_alloc_enable_work, btrfs_stripe
+        S6 old96: 5 lines: +   /* | +   * Closing the log-tree fsync write hole is on by default; | +   * turn it off so the change can be measured against itsel
+        S6 old98: 3 lines: +    * LOG-class data runs shared per log transaction are the  | +   * clearing stripe_log_data_shared goes back to private ru | +   * carry-forward.
+        S6 old120: 8 lines: -   * Closing the log-tree fsync write hole is on by default; | -   * turn it off so the change can be measured against itsel | -   * LOG-class data runs shared per log transaction are the 
+  S3 final  fs/btrfs/free-space-cache.c: bool btrfs_stripe_bg_wants_compaction(struct btrfs_block_group *bg)
+  S3 final  fs/btrfs/free-space-cache.c: bool btrfs_stripe_bg_wants_reclaim(struct btrfs_block_group *bg)
+  S3 final  fs/btrfs/free-space-cache.c: enum stripe_reclaim_kind btrfs_stripe_bg_reclaim_now_kind(struct btrfs
+  S3 final  fs/btrfs/free-space-cache.c: s64 btrfs_stripe_partial_map(struct btrfs_block_group *bg, unsigned lo
+  S3 final  fs/btrfs/free-space-cache.c: static bool stripe_reclaim_meta_room(struct btrfs_fs_info *fs_info)
+  S3 final  fs/btrfs/free-space-cache.c: static enum stripe_reclaim_kind __stripe_bg_reclaim_kind(struct btrfs_
+  S3 final  fs/btrfs/free-space-cache.c: static enum stripe_reclaim_kind stripe_bg_reclaim_kind(struct btrfs_bl
+  S3 final  fs/btrfs/free-space-cache.c: static u64 stripe_free_walk(struct btrfs_block_group *bg, u32 *freep)
+  S3 final  fs/btrfs/free-space-cache.c: static u64 stripe_unusable_scan(struct btrfs_block_group *bg, u32 *fre
+  later  fs/btrfs/free-space-cache.c: void btrfs_block_group_rescan_stripe_unusable(struct btrfs_block_group
+        S6 old50: 2 lines: -   if (!btrfs_is_stripe_alloc_bg(bg)) | +  if (!btrfs_is_stripe_alloc_bg(bg) && !btrfs_is_stripe_meta
+  S3 final  fs/btrfs/fs.c: bool btrfs_exclop_start(struct btrfs_fs_info *fs_info,
+  S3 final  fs/btrfs/fs.c: bool btrfs_exclop_start_reclaim(struct btrfs_fs_info *fs_info)
+  S3 final  fs/btrfs/fs.c: void btrfs_exclop_finish(struct btrfs_fs_info *fs_info)
+  later  fs/btrfs/relocation.c: int btrfs_relocate_block_group(struct btrfs_fs_info *fs_info, u64 grou
+        S6 old82: 1 lines: +   WRITE_ONCE(fs_info->reloc_owner, current);
+        S6 old82: 1 lines: +   WRITE_ONCE(fs_info->reloc_owner, NULL);
+  S3 final  fs/btrfs/relocation.c: int find_next_extent(struct reloc_control *rc, struct btrfs_path *path
+  S3 final  fs/btrfs/relocation.c: int replace_file_extents(struct btrfs_trans_handle *trans,
+  S3 final  fs/btrfs/relocation.c: static bool compact_selected(const struct reloc_control *rc, u64 start
+  later  fs/btrfs/relocation.c: static int compact_plan(struct reloc_control *rc, u64 *moved, u64 *nse
+        S6 old132.5: 1 lines: +        struct btrfs_fs_info *fs_info = bg->fs_info;
+        S6 old132.5: 2 lines: +                else if (key.type == BTRFS_METADATA_ITEM_KEY) | +                       len = fs_info->nodesize;
+  S3 final  fs/btrfs/relocation.c: static int compact_prepare(struct reloc_control *rc)
+  S3 final  fs/btrfs/relocation.c: static u32 compact_root(u32 *parent, u32 x)
+  S3 final  fs/btrfs/relocation.c: static void free_reloc_control(struct reloc_control *rc)
+  S3 final  fs/btrfs/sysfs.c: static ssize_t btrfs_stripe_compact_show(struct kobject *kobj,
+  S3 final  fs/btrfs/sysfs.c: static ssize_t btrfs_stripe_compact_store(struct kobject *kobj,
+  S3 final  fs/btrfs/sysfs.c: static ssize_t btrfs_stripe_reclaim_now_store(struct kobject *kobj,
+  later  fs/btrfs/sysfs.c: static ssize_t btrfs_stripe_run_stats_show(struct kobject *kobj,
+        S6 old96: 3 lines: -           "compact_bytes %lld\n", | +             "compact_bytes %lld\n" | +              "log_run_opened %lld\n",
+        S6 old96: 3 lines: -           atomic64_read(&fs_info->stripe_run_stats.compact_bytes)); | +           atomic64_read(&fs_info->stripe_run_stats.compact_bytes), | +            atomic64_read(&fs_info->stripe_run_stats.log_run_opened))
+        S6 old98: 8 lines: -           "log_run_opened %lld\n", | +            "log_run_opened %lld\n" | +             "log_settle_waits %lld\n"
+        S6 old98: 8 lines: -           atomic64_read(&fs_info->stripe_run_stats.log_run_opened)) | +           atomic64_read(&fs_info->stripe_run_stats.log_run_opened), | +           atomic64_read(&fs_info->stripe_run_stats.log_settle_waits
+        S7 old123: 4 lines: -          "log_seal_bytes %lld\n", | +            "log_seal_bytes %lld\n" | +             "unwritten_on_end %lld\n"
+        S7 old123: 4 lines: -          atomic64_read(&fs_info->stripe_run_stats.log_seal_bytes)) | +           atomic64_read(&fs_info->stripe_run_stats.log_seal_bytes), | +           atomic64_read(&fs_info->stripe_run_stats.unwritten_on_end
+  S3 final  fs/btrfs/volumes.c: int btrfs_compact_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offse
+  S3 final  fs/btrfs/volumes.c: int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offs
+  S3 final  fs/btrfs/volumes.c: static int relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_off
diff --git a/scripts/sa-reorder/review4-mn.txt b/scripts/sa-reorder/review4-mn.txt
new file mode 100644 (file)
index 0000000..49c78d2
--- /dev/null
@@ -0,0 +1,66 @@
+3-class hunks placed outside the subtopic: 0
+functions the subtopic wrote code in: 40
+  S3 final  fs/btrfs/block-group.c: bool btrfs_reclaim_backoff_active(struct btrfs_space_info *space_info)
+  later  fs/btrfs/block-group.c: int btrfs_stripe_reclaim_now(struct btrfs_fs_info *fs_info, bool all, 
+        S6 old116.5: 3 lines: -                } else if (!btrfs_is_stripe_alloc_bg(bg)) { | +         } else if (!btrfs_is_stripe_alloc_bg(bg) && | +                    !btrfs_is_stripe_meta_bg(bg)) {
+        S6 old116.5: 3 lines: -                                if (!btrfs_is_stripe_alloc_bg(bg)) | +                          if (!btrfs_is_stripe_alloc_bg(bg) && | +                                    !btrfs_is_stripe_meta_bg(bg))
+  S3 final  fs/btrfs/block-group.c: static bool reclaim_yielding(const struct btrfs_fs_info *fs_info)
+  S3 final  fs/btrfs/block-group.c: static bool stripe_reclaim_now_queue(struct btrfs_block_group *bg,
+  later  fs/btrfs/block-group.c: static int btrfs_reclaim_block_group(struct btrfs_block_group *bg, int
+        S6 old64.5: 2 lines: -  * A stripe_alloc group's live extents can only move into | +    * A stripe_alloc / stripe_meta group's live extents can o
+        S6 old64.5: 2 lines: - if (btrfs_is_stripe_alloc_bg(bg)) { | + if (btrfs_is_stripe_alloc_bg(bg) || btrfs_is_stripe_meta_b
+        S6 old64.5: 3 lines: -      !btrfs_is_stripe_alloc_bg(bg))) { | +           !btrfs_is_stripe_alloc_bg(bg) && | +            !btrfs_is_stripe_meta_bg(bg))) {
+        S6 old64.5: 2 lines: -          * Not for a stripe_alloc group: under | +               * Not for a stripe_alloc or stripe_meta group: under
+        S6 old116.5: 2 lines: -                 * Too full to relocate whole.  A stripe_alloc | +               * Too full to relocate whole.  A stripe_alloc / stripe_m
+  S3 final  fs/btrfs/block-group.c: static u64 reclaim_free_bytes(const struct btrfs_space_info *space_inf
+  S3 final  fs/btrfs/block-group.c: static u64 stripe_reclaim_chunk_room(struct btrfs_block_group *bg)
+  later  fs/btrfs/block-group.c: static void btrfs_stripe_reclaim_tick(struct btrfs_fs_info *fs_info)
+        S6 old64.5: 3 lines: -         if (!(sinfo->flags & BTRFS_BLOCK_GROUP_DATA)) | +               if (!(sinfo->flags & (BTRFS_BLOCK_GROUP_DATA | | +                                    BTRFS_BLOCK_GROUP_METADATA)))
+        S6 old65: 3 lines: -                                 BTRFS_BLOCK_GROUP_METADATA))) | +                               BTRFS_BLOCK_GROUP_METADATA | | +                                BTRFS_BLOCK_GROUP_SYSTEM)))
+  S3 final  fs/btrfs/block-group.c: static void reclaim_note_result(struct btrfs_block_group *bg, bool eno
+  S3 final  fs/btrfs/block-group.c: void btrfs_reclaim_block_groups(struct btrfs_fs_info *fs_info, unsigne
+  later  fs/btrfs/disk-io.c: void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)
+        S5 old39: 1 lines: +   INIT_WORK(&fs_info->stripe_alloc_enable_work, btrfs_stripe
+        S6 old81: 5 lines: +   /* | +   * Closing the log-tree fsync write hole is on by default; | +   * turn it off so the change can be measured against itsel
+        S6 old83: 3 lines: +    * LOG-class data runs shared per log transaction are the  | +   * clearing stripe_log_data_shared goes back to private ru | +   * carry-forward.
+        S6 old105: 8 lines: -   * Closing the log-tree fsync write hole is on by default; | -   * turn it off so the change can be measured against itsel | -   * LOG-class data runs shared per log transaction are the 
+  S3 final  fs/btrfs/free-space-cache.c: bool btrfs_stripe_bg_wants_compaction(struct btrfs_block_group *bg)
+  S3 final  fs/btrfs/free-space-cache.c: bool btrfs_stripe_bg_wants_reclaim(struct btrfs_block_group *bg)
+  S3 final  fs/btrfs/free-space-cache.c: enum stripe_reclaim_kind btrfs_stripe_bg_reclaim_now_kind(struct btrfs
+  S3 final  fs/btrfs/free-space-cache.c: s64 btrfs_stripe_partial_map(struct btrfs_block_group *bg, unsigned lo
+  S3 final  fs/btrfs/free-space-cache.c: static bool stripe_reclaim_meta_room(struct btrfs_fs_info *fs_info)
+  S3 final  fs/btrfs/free-space-cache.c: static enum stripe_reclaim_kind __stripe_bg_reclaim_kind(struct btrfs_
+  S3 final  fs/btrfs/free-space-cache.c: static enum stripe_reclaim_kind stripe_bg_reclaim_kind(struct btrfs_bl
+  S3 final  fs/btrfs/free-space-cache.c: static u64 stripe_free_walk(struct btrfs_block_group *bg, u32 *freep)
+  S3 final  fs/btrfs/free-space-cache.c: static u64 stripe_unusable_scan(struct btrfs_block_group *bg, u32 *fre
+  later  fs/btrfs/free-space-cache.c: void btrfs_block_group_rescan_stripe_unusable(struct btrfs_block_group
+        S6 old48: 2 lines: -   if (!btrfs_is_stripe_alloc_bg(bg)) | +  if (!btrfs_is_stripe_alloc_bg(bg) && !btrfs_is_stripe_meta
+  S3 final  fs/btrfs/fs.c: bool btrfs_exclop_start(struct btrfs_fs_info *fs_info,
+  S3 final  fs/btrfs/fs.c: bool btrfs_exclop_start_reclaim(struct btrfs_fs_info *fs_info)
+  S3 final  fs/btrfs/fs.c: void btrfs_exclop_finish(struct btrfs_fs_info *fs_info)
+  later  fs/btrfs/relocation.c: int btrfs_relocate_block_group(struct btrfs_fs_info *fs_info, u64 grou
+        S6 old50: 1 lines: +   WRITE_ONCE(fs_info->reloc_owner, current);
+        S6 old50: 1 lines: +   WRITE_ONCE(fs_info->reloc_owner, NULL);
+  S3 final  fs/btrfs/relocation.c: int find_next_extent(struct reloc_control *rc, struct btrfs_path *path
+  S3 final  fs/btrfs/relocation.c: int replace_file_extents(struct btrfs_trans_handle *trans,
+  S3 final  fs/btrfs/relocation.c: static bool compact_selected(const struct reloc_control *rc, u64 start
+  later  fs/btrfs/relocation.c: static int compact_plan(struct reloc_control *rc, u64 *moved, u64 *nse
+        S6 old116.5: 1 lines: +        struct btrfs_fs_info *fs_info = bg->fs_info;
+        S6 old116.5: 2 lines: +                else if (key.type == BTRFS_METADATA_ITEM_KEY) | +                       len = fs_info->nodesize;
+  S3 final  fs/btrfs/relocation.c: static int compact_prepare(struct reloc_control *rc)
+  S3 final  fs/btrfs/relocation.c: static int do_nonremap_reloc(struct btrfs_fs_info *fs_info, bool verbo
+  S3 final  fs/btrfs/relocation.c: static u32 compact_root(u32 *parent, u32 x)
+  S3 final  fs/btrfs/relocation.c: static void put_reloc_control(struct reloc_control *rc)
+  S3 final  fs/btrfs/sysfs.c: static ssize_t btrfs_stripe_compact_show(struct kobject *kobj,
+  S3 final  fs/btrfs/sysfs.c: static ssize_t btrfs_stripe_compact_store(struct kobject *kobj,
+  S3 final  fs/btrfs/sysfs.c: static ssize_t btrfs_stripe_reclaim_now_store(struct kobject *kobj,
+  later  fs/btrfs/sysfs.c: static ssize_t btrfs_stripe_run_stats_show(struct kobject *kobj,
+        S6 old81: 3 lines: -           "compact_bytes %lld\n", | +             "compact_bytes %lld\n" | +              "log_run_opened %lld\n",
+        S6 old81: 3 lines: -           atomic64_read(&fs_info->stripe_run_stats.compact_bytes)); | +           atomic64_read(&fs_info->stripe_run_stats.compact_bytes), | +            atomic64_read(&fs_info->stripe_run_stats.log_run_opened))
+        S6 old83: 8 lines: -           "log_run_opened %lld\n", | +            "log_run_opened %lld\n" | +             "log_settle_waits %lld\n"
+        S6 old83: 8 lines: -           atomic64_read(&fs_info->stripe_run_stats.log_run_opened)) | +           atomic64_read(&fs_info->stripe_run_stats.log_run_opened), | +           atomic64_read(&fs_info->stripe_run_stats.log_settle_waits
+        S7 old108: 4 lines: -          "log_seal_bytes %lld\n", | +            "log_seal_bytes %lld\n" | +             "unwritten_on_end %lld\n"
+        S7 old108: 4 lines: -          atomic64_read(&fs_info->stripe_run_stats.log_seal_bytes)) | +           atomic64_read(&fs_info->stripe_run_stats.log_seal_bytes), | +           atomic64_read(&fs_info->stripe_run_stats.unwritten_on_end
+  S3 final  fs/btrfs/volumes.c: int btrfs_compact_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offse
+  S3 final  fs/btrfs/volumes.c: int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offs
+  S3 final  fs/btrfs/volumes.c: static int relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_off
diff --git a/scripts/sa-reorder/wpost-p16.json b/scripts/sa-reorder/wpost-p16.json
new file mode 100644 (file)
index 0000000..742fc1a
--- /dev/null
@@ -0,0 +1,2345 @@
+[
+ {
+  "sha": "53ba8a7913e5278f552c26f1e2ad76ac91ea4fe2",
+  "anchor": [
+   "main",
+   1
+  ],
+  "src": 1,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "0ff761d2af8513b85416850a2aaf13a69878ffe5",
+  "overlaid": false,
+  "subject": "btrfs: add btrfs_claim_free_stripe_run() for stripe-exclusive allocation",
+  "msg_changed": false
+ },
+ {
+  "sha": "0e3b923d068f8a8ed6d079eb079c11f765b4b2b1",
+  "anchor": [
+   "main",
+   2
+  ],
+  "src": 2,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "dfe88651458caa353b2fe44c2b3bbe50d8830717",
+  "overlaid": false,
+  "subject": "btrfs: add open stripe run tracking for stripe-exclusive allocation",
+  "msg_changed": false
+ },
+ {
+  "sha": "91d82a62a9b8cd4760baaeb4e6b86856166aa428",
+  "anchor": [
+   "main",
+   3
+  ],
+  "src": 3,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "6996907b26e73fd6db7245415649dc950c95e5ec",
+  "overlaid": false,
+  "subject": "btrfs: add the stripe_alloc allocation policy for raid56 data",
+  "msg_changed": false
+ },
+ {
+  "sha": "9e5bb9d16e5ad80b86da1a8505ec12602ae4859a",
+  "anchor": [
+   "main",
+   4
+  ],
+  "src": 4,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "25fbab8ca25f4b68eebfcafe854737822879bd11",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: control the policy with a filesystem property",
+  "msg_changed": true
+ },
+ {
+  "sha": "57c75df42ff9bb62bf9fd4dcc3e2a391089061df",
+  "anchor": [
+   "main",
+   5
+  ],
+  "src": 5,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "62f56a27bbc810eb1ff5ec51e691695335a6c8cb",
+  "overlaid": false,
+  "subject": "btrfs: report stripe run data IO through the ordered extent lifecycle",
+  "msg_changed": false
+ },
+ {
+  "sha": "bc8d48e1a097a6f9652ddd6eb7e3e9b3754c2c1c",
+  "anchor": [
+   "main",
+   6
+  ],
+  "src": 6,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "80c70aea496a533e3a554523fc71650f8e28ffbd",
+  "overlaid": false,
+  "subject": "btrfs: retire stripe runs at commit and gate stripe_alloc",
+  "msg_changed": true
+ },
+ {
+  "sha": "93f9689a3547b58c10593baeea855bf8962e893b",
+  "anchor": [
+   "main",
+   8
+  ],
+  "src": 8,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "529ae5d168c6ce976544b696c7ceb88ea14d0e14",
+  "overlaid": false,
+  "subject": "btrfs: account stripe_alloc trapped free space for honest statfs",
+  "msg_changed": false
+ },
+ {
+  "sha": "da1e7414ea589de76593472824ec04094397d22d",
+  "anchor": [
+   "main",
+   9
+  ],
+  "src": 9,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "764c719cd0597ad07334c4e36f052f4ed887acf0",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: keep an open run per size band to trap less",
+  "msg_changed": false
+ },
+ {
+  "sha": "32de7e8592e238480ece0e20bb53f81f3c379e43",
+  "anchor": [
+   "main",
+   10
+  ],
+  "src": 10,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "3a3f55749583348affc0b1ef98dbadabc98e49b6",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: grow the frontier run instead of stranding its tail",
+  "msg_changed": false
+ },
+ {
+  "sha": "44f6b99d3a81572dda76ccedbae957f8ae853e12",
+  "anchor": [
+   "main",
+   11
+  ],
+  "src": 11,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "fd93c7cf90bf8c919fa52fb9f92bfcf389b5c91e",
+  "overlaid": false,
+  "subject": "btrfs: raid56: batch stripe_alloc partial writes into full-stripe writes",
+  "msg_changed": false
+ },
+ {
+  "sha": "8b509d4d0471426570b76aaaedb077f15eebcc87",
+  "anchor": [
+   "main",
+   12
+  ],
+  "src": 12,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "8c9e32db749430f2becc72d56553f5a6b521fd1e",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: never claim stripes covered by a live run",
+  "msg_changed": false
+ },
+ {
+  "sha": "8047a827bf8d448a24584553f56141074ad56698",
+  "anchor": [
+   "main",
+   14
+  ],
+  "src": 14,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "aa07565744723011844b3b49d6828f2cd8538a4f",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: private per-inode stripe runs for log-active inodes",
+  "msg_changed": false
+ },
+ {
+  "sha": "7dd543fef4e4c1224989dbf3a5f368e12abf0242",
+  "anchor": [
+   "main",
+   17
+  ],
+  "src": 17,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "014efd25c440cdec940fec5df9887392fa7547f2",
+  "overlaid": false,
+  "subject": "btrfs: raid56: pad sub-stripe writes to full stripes in open runs",
+  "msg_changed": false
+ },
+ {
+  "sha": "c5b1b8be45cbcb7c91d20365e3e7cf84f3c4b847",
+  "anchor": [
+   "main",
+   22
+  ],
+  "src": 22,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "e141403bd555f13dbf7d82b8776e19d2f981ec74",
+  "overlaid": false,
+  "subject": "btrfs: raid56: expose parking statistics in sysfs",
+  "msg_changed": false
+ },
+ {
+  "sha": "e63b201b2f43b7a45c4b4397eb8e9d3951171d81",
+  "anchor": [
+   "main",
+   23
+  ],
+  "src": 23,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "ce982693f87f90597cfeb363f50ff47c071b3100",
+  "overlaid": false,
+  "subject": "btrfs: raid56: skip parking for sync rbios finished by their unplug batch",
+  "msg_changed": false
+ },
+ {
+  "sha": "d63e5cb2699bb173832f1524421f5161e7bc47fb",
+  "anchor": [
+   "main",
+   24
+  ],
+  "src": 24,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "67faa552b1a680dbfcad5d1f818d76c921591741",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations",
+  "msg_changed": false
+ },
+ {
+  "sha": "51b6740c9909d1ee50019a7609cb18be9d1ef661",
+  "anchor": [
+   "main",
+   25
+  ],
+  "src": 25,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "16d4b3754e2ab40d9fe071957dc905e5c8c812c8",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: pessimistic data reservation margin",
+  "msg_changed": false
+ },
+ {
+  "sha": "1a306de9f21741bc502fb3384f3fb9cf39686cf0",
+  "anchor": [
+   "main",
+   26
+  ],
+  "src": 26,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "35841aca5f5fe84504464b7591a258270cdf3c9d",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: claim fully-free stripes that span free space entries",
+  "msg_changed": false
+ },
+ {
+  "sha": "f2fabdfbb66d985e67c73ac476699f7c0457dced",
+  "anchor": [
+   "main",
+   27
+  ],
+  "src": 27,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "c02721e6f0c8f042d6406d7214727853b3758c27",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: warn when raid56 metadata is not covered",
+  "msg_changed": false
+ },
+ {
+  "sha": "8e6f3bed5a5b9b1b918c63fada69dd6871190fe6",
+  "anchor": [
+   "main",
+   28
+  ],
+  "src": 28,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "50eb42c1670d96ab0643054072b480a6995c2798",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: report read-modify-write of uncovered stripes",
+  "msg_changed": true
+ },
+ {
+  "sha": "5f97eae925d0b456d1f7b2892026350ca2f5bfc0",
+  "anchor": [
+   "main",
+   30
+  ],
+  "src": 30,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "d494b6f73c51a7a9ed5382e28d56709edcbdd7fc",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined",
+  "msg_changed": false
+ },
+ {
+  "sha": "7f6ac3e51a010b2bc3ad9be9d25ab8739fca2f80",
+  "anchor": [
+   "main",
+   31
+  ],
+  "src": 31,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "150e01cc8b5f8e9271a246e73b91f5f205fb310c",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: trace why padding declined, at the moment it declined",
+  "msg_changed": false
+ },
+ {
+  "sha": "a767739f1e99dbff33dd7ca711c8a81d6fa96af6",
+  "anchor": [
+   "main",
+   32
+  ],
+  "src": 32,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "b50899b8f05f8ab966773977a5c5cfdb39732262",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: complete parked writes on allocation coverage, not clocks",
+  "msg_changed": false
+ },
+ {
+  "sha": "ac979e48c06355035b14ebc7aef7852e9f2a9b00",
+  "anchor": [
+   "main",
+   33
+  ],
+  "src": 33,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "54574bcca4f587864827d2a303e74776a278032e",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: track per-sector liveness and pad from the map",
+  "msg_changed": false
+ },
+ {
+  "sha": "2a42771b1ce0be464b4bcb3d16efcc8648afb185",
+  "anchor": [
+   "main",
+   34
+  ],
+  "src": 34,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "9ddaa7aa9797d934642390c2302e33fa3eb25892",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: count claimable whole-stripe supply directly",
+  "msg_changed": false
+ },
+ {
+  "sha": "7db677b5a23586153e7d7fb344bc0cbc43739520",
+  "anchor": [
+   "main",
+   35
+  ],
+  "src": 35,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "a8c4297477bd21bafef1225a79519f1a22510377",
+  "overlaid": false,
+  "subject": "btrfs: raid56: adaptive park deadline from the parked-rbio backlog",
+  "msg_changed": false
+ },
+ {
+  "sha": "3de0f438b97bfc2d89ca169aefd09fdb6b0e8cc0",
+  "anchor": [
+   "main",
+   36
+  ],
+  "src": 36,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "34bbfe843390534a0fa19f586f78266cf7f725c1",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: gate data admission on claimable whole-stripe supply",
+  "msg_changed": false
+ },
+ {
+  "sha": "9b7b57554e0705dbe80e5d557a64fa99822df30f",
+  "anchor": [
+   "main",
+   37
+  ],
+  "src": 37,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "d8b7a6884ff739bc3ad22fb0dc3b8bd4f565fecf",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: cache a failed stripe run scan per block group",
+  "msg_changed": false
+ },
+ {
+  "sha": "dfe42d77601cde84ac5736a6782dfd647d61e48c",
+  "anchor": [
+   "main",
+   40
+  ],
+  "src": 40,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "9f6828935e5664dd3df6ef611422ba77df7f7412",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: keep the admitted bytes placeable when a group goes read-only",
+  "msg_changed": false
+ },
+ {
+  "sha": "20fded529b712032fa2eb53080577c2b8ff1f462",
+  "anchor": [
+   "main",
+   41
+  ],
+  "src": 41,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "c4661beb2dbfd6a2f71b6df1e4cce4b7d10637a3",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: never let relocation wait on the whole-stripe gate",
+  "msg_changed": false
+ },
+ {
+  "sha": "e81d6cd2dbc3679bcd5ce89c402c2deacc14e3b7",
+  "anchor": [
+   "main",
+   43
+  ],
+  "src": 43,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "6981d6148840c3de8e34905aa6129aa15ecb313e",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: charge relocation a margin per reservation, not per extent",
+  "msg_changed": false
+ },
+ {
+  "sha": "e6f27d109fb5d954e93fd7d9ec396b5de9ae6407",
+  "anchor": [
+   "main",
+   44
+  ],
+  "src": 44,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "b74dc09c20cd2a4495e3627ba45f0429709d0743",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: keep the relocation group's stripes out of the admission supply",
+  "msg_changed": false
+ },
+ {
+  "sha": "620d39cb6a345670d5a0de8b0f1498620789dd64",
+  "anchor": [
+   "main",
+   45
+  ],
+  "src": 45,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "5d1596087b2114f2ba9c396c311171e11c1f44f1",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: let a data write fall back to the relocation group rather than drop",
+  "msg_changed": false
+ },
+ {
+  "sha": "b64ea46019c1b084aa994ce49c11b99aee41d013",
+  "anchor": [
+   "main",
+   54
+  ],
+  "src": 54,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "0560fb56d6eb75d6d13afe026e8d2c3b406b87e8",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: show per-group trapped bytes in the space info dump",
+  "msg_changed": false
+ },
+ {
+  "sha": "c347e4a473288ce3909fed3ce7ea8e8fde799caa",
+  "anchor": [
+   "main",
+   57
+  ],
+  "src": 57,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "8fa80bd94dbea69a56dbd0c127c288ef30fab5c7",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped",
+  "msg_changed": false
+ },
+ {
+  "sha": "5816f99eecd90ae6e2c7f7a1b12ad85b52932e0d",
+  "anchor": [
+   "main",
+   59
+  ],
+  "src": 59,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "14ff917d04dcc8d751638ce9607a3337c78f156c",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: count nocow run lifecycles and stranded stripes in sysfs",
+  "msg_changed": false
+ },
+ {
+  "sha": "aa2a16a87ce077a6761b4f8eb7620a528d97df19",
+  "anchor": [
+   "main",
+   60
+  ],
+  "src": 60,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "d7b49313d285e654ffc67ec4edb39b6365911677",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: hold a stripe of margin across a preallocation",
+  "msg_changed": false
+ },
+ {
+  "sha": "af600ccf95f232b80846c4aad39a520b60ed3318",
+  "anchor": [
+   "main",
+   62
+  ],
+  "src": 62,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "01a3936d13e7c91c772aa066e259c18f31ae816b",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: return a group's allocation cluster before scanning its stripes",
+  "msg_changed": false
+ },
+ {
+  "sha": "cc7f5012e68cc7c0e61c73cb518f98a02907b7ca",
+  "anchor": [
+   "main",
+   63
+  ],
+  "src": 63,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "e7d1c0527ad156ad2fc1e526675fc4f1ceb35031",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: release open stripe runs when a mount fails or an aborted filesystem unmounts",
+  "msg_changed": false
+ },
+ {
+  "sha": "8d55f6470ba096288740e43026c5a7792f28c57b",
+  "anchor": [
+   "main",
+   64
+  ],
+  "src": 64,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "01707c824e837148346709e08dbf47e54bdc5977",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: say at mount whether the policy is on",
+  "msg_changed": false
+ },
+ {
+  "sha": "f7ae6f49b1dc2af503e2e1a7ec0a1343b5df070c",
+  "anchor": [
+   "main",
+   68
+  ],
+  "src": 68,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "b9548e251fe98af39ba7235446227c102a6fadfa",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: do not wait for stripe runs to drain on an errored filesystem",
+  "msg_changed": false
+ },
+ {
+  "sha": "c5d893d04cd25d009a8989c1abd7bf395a271f4c",
+  "anchor": [
+   "main",
+   69
+  ],
+  "src": 69,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "132656ed0da660d8229b18178804a32c89db7ec7",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: end the commit-time and log drains on an errored filesystem too",
+  "msg_changed": false
+ },
+ {
+  "sha": "607b63bee553f89792b3ba5800d222f427919532",
+  "anchor": [
+   "main",
+   73
+  ],
+  "src": 73,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "8889dfe345cd72f0de6a9d0e8ba511380a65b539",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: keep relocation's stripe runs until relocation ends",
+  "msg_changed": false
+ },
+ {
+  "sha": "698d58a009b3c6d253b961caf54bc51e8b04a9ec",
+  "anchor": [
+   "main",
+   74
+  ],
+  "src": 74,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "b5a6efe1f87e58f1c7a29d199af3cf01bd5d1b2c",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: let relocation allocate a data chunk before it fails",
+  "msg_changed": false
+ },
+ {
+  "sha": "237c76a34bbb6be619ad04be890a1c14303c39b1",
+  "anchor": [
+   "main",
+   75
+  ],
+  "src": 75,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "bf1856d36945e08f3336db623b3ce89b7fb4b3c2",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it",
+  "msg_changed": false
+ },
+ {
+  "sha": "dc616451399b22806fa6cd62ce7cf3ead426e1be",
+  "anchor": [
+   "main",
+   76
+  ],
+  "src": 76,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "9888fbd80f15db8656712c8ba4a836818c931294",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: pad a stripe's allocated sectors whose write is still to come",
+  "msg_changed": false
+ },
+ {
+  "sha": "c566752d5d46ffe55ee98871032c5f23856e8454",
+  "anchor": [
+   "main",
+   77
+  ],
+  "src": 77,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "7a08af1a9ee658a5fdace2ccbbb19c5ef78affa9",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: apply the property before tree-log replay",
+  "msg_changed": false
+ },
+ {
+  "sha": "7e578fc00b60938e79f9657f6975fb192b4dc9ef",
+  "anchor": [
+   "main",
+   78
+  ],
+  "src": 78,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "26845acfdff82f62243ec8076de9c868e7e4167c",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count refused rbio pins and track rbio cache high water",
+  "msg_changed": false
+ },
+ {
+  "sha": "7bfdd912d13eb56364c5b4fe6f8b7a28d9b9898b",
+  "anchor": [
+   "main",
+   79
+  ],
+  "src": 79,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "f14fe1e95b9a9f7fdffdc3a6ab4220ae268eb940",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: sweep stale rbio pins, and commit when live pins run low",
+  "msg_changed": false
+ },
+ {
+  "sha": "bd839f5223b53a4e22da41814ab8aaf06e15a024",
+  "anchor": [
+   "main",
+   82
+  ],
+  "src": 82,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "72d1843ff002526658c43246feea27c68df77495",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: don't make a parked rbio wait for sectors that will never be written",
+  "msg_changed": false
+ },
+ {
+  "sha": "0b54cc635fbabf89e0f0e5905d7543c93766cac3",
+  "anchor": [
+   "main",
+   84
+  ],
+  "src": 84,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "1658ad5ef6d66d48f6e05b449753b4342ffed9d5",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: let relocation allocate as many data chunks as its reservation needs",
+  "msg_changed": false
+ },
+ {
+  "sha": "70b9f361cb5ae639d2b777b751248f7d1cdf8c49",
+  "anchor": [
+   "main",
+   86
+  ],
+  "src": 86,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "8c864207ad95f828c0b7575d9b98537986cd3db9",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not treat an allocation error as a found extent",
+  "msg_changed": false
+ },
+ {
+  "sha": "23e54ac469ab6f58756bd33b8741fdc188164e00",
+  "anchor": [
+   "main",
+   87
+  ],
+  "src": 87,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "cde9fe68ac794be1dc99142f3ae250768a4cd37c",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: mark an ended ordered extent's sectors written",
+  "msg_changed": false
+ },
+ {
+  "sha": "335bb14838d6e6301b30df9f283fda86ffcf4a6e",
+  "anchor": [
+   "main",
+   89
+  ],
+  "src": 89,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "f65d167f4268f839553d5e5abe1f63fbb37fba3d",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: remove only the set bits of a bitmap when claiming a split run",
+  "msg_changed": false
+ },
+ {
+  "sha": "5f41b653ca05fc9233019283dfb3480365c4b64e",
+  "anchor": [
+   "main",
+   91
+  ],
+  "src": 91,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "22d07d08fb15800dfcfafde37a143fc392dde4c3",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: keep the stripe totals consistent with the groups during the commit scan",
+  "msg_changed": false
+ },
+ {
+  "sha": "fc344bba3eb3a063dcb2f870375b4b51558d4f36",
+  "anchor": [
+   "main",
+   92
+  ],
+  "src": 92,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "b86eb61d3a1cf00ffe134c6d8a15e7edf27aa33c",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not delete an unused block group that still has stripe runs",
+  "msg_changed": false
+ },
+ {
+  "sha": "d5865030dd5a35b51d72123ddeea668d7cc1574f",
+  "anchor": [
+   "main",
+   95
+  ],
+  "src": 95,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "ab64c3b14db145c85625eaf68f8436379529d153",
+  "overlaid": true,
+  "subject": "btrfs: raid56: stop the park timer before destroying the raid56 workqueue",
+  "msg_changed": false
+ },
+ {
+  "sha": "dfadf31986bbfe06ee37294ed38c5b6812de439a",
+  "anchor": [
+   "main",
+   96
+  ],
+  "src": 96,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "6ddb66abc429762238ef1e21901dbde0cd706df0",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: order the filesystem error before waking stripe drain waiters",
+  "msg_changed": false
+ },
+ {
+  "sha": "fade7419de5ab54ce66f9b5e26743755f27f8d26",
+  "anchor": [
+   "main",
+   97
+  ],
+  "src": 97,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "9ae6d347ba1643324eb677435963604444e917b8",
+  "overlaid": true,
+  "subject": "btrfs: raid56: set a padded rbio's data bitmap under bio_list_lock",
+  "msg_changed": false
+ },
+ {
+  "sha": "48b3059eda8a87dc5c5d3afff99374d5e54344ef",
+  "anchor": [
+   "main",
+   98
+  ],
+  "src": 98,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "96e9b4f49e9bd1eacb6a79ff45cf1af2002e088a",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: forget the failed-claim verdict when a cluster returns its space",
+  "msg_changed": false
+ },
+ {
+  "sha": "866595675c23ce423a736a999fd395ee88f1cc83",
+  "anchor": [
+   "main",
+   99
+  ],
+  "src": 99,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "676cc8b9b43092c9cb081a99f764f0324091e175",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not let a remount revert the stripe_alloc property",
+  "msg_changed": false
+ },
+ {
+  "sha": "0936e16ecd28b9eaef4f0b218254223a4691f159",
+  "anchor": [
+   "main",
+   101
+  ],
+  "src": 101,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "9f3e296f726c3ccb961f408a934600089fcee6c9",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: keep the head of a claimed free space entry under the lock",
+  "msg_changed": false
+ },
+ {
+  "sha": "45e6f92823c69ea218c91c509ca6eeb9e8320504",
+  "anchor": [
+   "part",
+   104,
+   1
+  ],
+  "src": 104,
+  "kind": "part",
+  "sub": 1,
+  "eng_sha": "f610d92945792bf7ac8f8ba067be5fcff451876b",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (base part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "dc754f4481dabd27d6962a370f4e92836c45cadd",
+  "anchor": [
+   "part",
+   105,
+   1
+  ],
+  "src": 105,
+  "kind": "part",
+  "sub": 1,
+  "eng_sha": "cbc8a43b3a232f1f0c23d2f348b2bb73049e9a95",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (base part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "3bc80b13dbb5e3779dddfe56022e0d1ae407b08d",
+  "anchor": [
+   "main",
+   109
+  ],
+  "src": 109,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "7879dd04c872c473a1dad3ba00845a8c4123841a",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3",
+  "msg_changed": false
+ },
+ {
+  "sha": "d24269da3167add56a580e5e3923f49920aba450",
+  "anchor": [
+   "main",
+   110
+  ],
+  "src": 110,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "16a89a6595fbfe141cff7d1ea803e2cf0025d1a0",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count single-data-stripe groups' free space in write admission",
+  "msg_changed": false
+ },
+ {
+  "sha": "eca751087b7cbb2e9c96644856590ad1f45b2f1f",
+  "anchor": [
+   "main",
+   18
+  ],
+  "src": 18,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "c39553dc11c95dde1f952be626ec6dd2216d6f5e",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: isolate nodatacow and preallocated extents by stripe",
+  "msg_changed": false
+ },
+ {
+  "sha": "91d4f8e210f5110e0ca22183e805daecd2124077",
+  "anchor": [
+   "part",
+   59,
+   1
+  ],
+  "src": 59,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "6df13ed994c2b3dff069ea484fd39b4d21ae0d31",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count nocow run lifecycles and stranded stripes in sysfs (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "9a921516ad1599524674a773185f83889a8cd92d",
+  "anchor": [
+   "part",
+   75,
+   1
+  ],
+  "src": 75,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "8a969dc01fb0d349b34dfd5fa33306a6a2caa5a4",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "4512e646316e59ce08959adb4152e745c4d486bf",
+  "anchor": [
+   "part",
+   76,
+   1
+  ],
+  "src": 76,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "849abc27cdd1cbdc409f510c9f42b803d160b4a8",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: pad a stripe's allocated sectors whose write is still to come (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "1f6451cd7396f96827c431f8fc1941e06a106461",
+  "anchor": [
+   "main",
+   19
+  ],
+  "src": 19,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "7772ab68e2755805d554e26179786d651a897048",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents",
+  "msg_changed": false
+ },
+ {
+  "sha": "b6d4137de35b155ca2f38e01b1392cc0f6ded305",
+  "anchor": [
+   "part",
+   33,
+   1
+  ],
+  "src": 33,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "e9d738f2f9921e7f4520f9057f3223de0014dd90",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: track per-sector liveness and pad from the map (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "278a6571825446f73c9ee4992f0cfabaf341543a",
+  "anchor": [
+   "part",
+   104,
+   2
+  ],
+  "src": 104,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "ddc40d8db98df0d7b01711d2068d8437df6cc92a",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "6bada689fb1c4958f72048674eab98b549d153d4",
+  "anchor": [
+   "main",
+   67
+  ],
+  "src": 67,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "c44c3bb41de75ca40c69e506e0a1acd9b2708ebb",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros",
+  "msg_changed": false
+ },
+ {
+  "sha": "31e16ed578670f4984a4e816d4148948e7ee25f8",
+  "anchor": [
+   "part",
+   104,
+   3
+  ],
+  "src": 104,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "7a61bd6452b133c4e954a40cd64b00a9d4c64a9c",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part 2)",
+  "msg_changed": false
+ },
+ {
+  "sha": "47e9505b6d89890b4144f73dd39a2a3268ce0162",
+  "anchor": [
+   "main",
+   20
+  ],
+  "src": 20,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "9460ef10099eaf35f8eb8dd49e3e774ffb2cb986",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: persist nocow runs across commits and remounts",
+  "msg_changed": false
+ },
+ {
+  "sha": "12ea6d04a32ba7de83295eef6bdb89b28b4566ca",
+  "anchor": [
+   "part",
+   24,
+   1
+  ],
+  "src": 24,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "b0dbdcf315caabe35c3531af45301d97d2af171a",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "8bf855883296b9e897624f765f86a0c10ba5f9e0",
+  "anchor": [
+   "part",
+   67,
+   1
+  ],
+  "src": 67,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "89f44a9e70fca3d90926585311a8ccd8340d7a3e",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros (allow_rmw part 2)",
+  "msg_changed": false
+ },
+ {
+  "sha": "71bbf3a95cb24be49bb288d74e3f49c56a089484",
+  "anchor": [
+   "main",
+   21
+  ],
+  "src": 21,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "21aa2c84b41e1cbac2c0da2bcd3a08e1634299a7",
+  "overlaid": true,
+  "subject": "btrfs: raid56: do not park sync writes into nocow runs",
+  "msg_changed": false
+ },
+ {
+  "sha": "7a648dd0147c79d47760b10e816fc510e379a22b",
+  "anchor": [
+   "part",
+   30,
+   1
+  ],
+  "src": 30,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "e03fc839b5f20260eca0417471a1fbdb59300725",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "33b2f0fd10ad0f79c050714b5910689556a3e848",
+  "anchor": [
+   "main",
+   56
+  ],
+  "src": 56,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "f787537a90e015083ff128f7a22b230ebc9f969a",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not read an inline backref off a keyed-ref extent item",
+  "msg_changed": false
+ },
+ {
+  "sha": "99b7fc262fc31f1cd81cacf30b3014583e7f9e86",
+  "anchor": [
+   "main",
+   58
+  ],
+  "src": 58,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "127df03d7a54ea1668db5b0c56750e038c4c9ee7",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: give nocow extents a private run only while they may be written in place",
+  "msg_changed": false
+ },
+ {
+  "sha": "c645e6f3722eb4fe3dc7fc1f03b06e1ec21025cf",
+  "anchor": [
+   "main",
+   66
+  ],
+  "src": 66,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "eb99d2c063d14dbeb97b7a75ff12cdefb50e8eaa",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: close dead nocow stripe runs at commit",
+  "msg_changed": false
+ },
+ {
+  "sha": "25bf8a7fbf78381abb2706e938d2c015890475e1",
+  "anchor": [
+   "main",
+   85
+  ],
+  "src": 85,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "06e05a0c35302fe12d995129adf45cdb80f3cd31",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode",
+  "msg_changed": false
+ },
+ {
+  "sha": "b8a014c169f579bb5323639cf67fc04b3649222b",
+  "anchor": [
+   "main",
+   90
+  ],
+  "src": 90,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "0bf08adba47e6668ce05bdcf742b0f825904c53e",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: claim a stripe tail in one free space lock section",
+  "msg_changed": false
+ },
+ {
+  "sha": "52d6e5f341ba86094f08327c7bbb1496add5372e",
+  "anchor": [
+   "main",
+   100
+  ],
+  "src": 100,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "5034bc58d7cb44e05c1a4ff3ed0d654af0dbe500",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not block a NOWAIT write in the nocow stripe check",
+  "msg_changed": false
+ },
+ {
+  "sha": "0765fb66a9f0c5185bc9f794654ccaa70361d5c3",
+  "anchor": [
+   "main",
+   103
+  ],
+  "src": 103,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "90e4af5e860ef185061416ad911f5f24d29e2528",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: remove the unused stripe_rmw_opt field",
+  "msg_changed": false
+ },
+ {
+  "sha": "4c2fee7c2add59231d49600c7cff75b3a4f78cff",
+  "anchor": [
+   "part",
+   104,
+   4
+  ],
+  "src": 104,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "66df3246d17825bc175a917a116b05d3490141de",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part 3)",
+  "msg_changed": false
+ },
+ {
+  "sha": "e2d9e382146ff961cb34abd3a7c4435f5fab2fbb",
+  "anchor": [
+   "part",
+   105,
+   2
+  ],
+  "src": 105,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "777923b7b1c4d31e799624d631660caa6ebbd700",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "ed3cd465e1536ded846a3be77280c782a634d903",
+  "anchor": [
+   "main",
+   42
+  ],
+  "src": 42,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "28676fd5c9b1492550443735977f5da188b37400",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: give a queued stripe group a chunk to relocate into when the supply is short",
+  "msg_changed": true
+ },
+ {
+  "sha": "308f903988eab3051ec21767585694040f0cc51e",
+  "anchor": [
+   "main",
+   46
+  ],
+  "src": 46,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "86f8a994c6b84096ee43396951673a0948fa7303",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: hand groups full of trapped free space to the reclaim worker",
+  "msg_changed": true
+ },
+ {
+  "sha": "8b897efd78c7cf91a51e098f6523aa0d2ef0b970",
+  "anchor": [
+   "part",
+   57,
+   1
+  ],
+  "src": 57,
+  "kind": "part",
+  "sub": 3,
+  "eng_sha": "551be878a41eb6b985495c45f2779e0d287f40d3",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped (reclaim part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "f2c3cfef2fa8ea305ded56e118a22f5920482f16",
+  "anchor": [
+   "main",
+   47
+  ],
+  "src": 47,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "3f6aa3e1e790245e0078ca1218490ba57430a76a",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: relocate a queued stripe group even while it has reserved or pinned bytes",
+  "msg_changed": true
+ },
+ {
+  "sha": "64fdc40d2a133bfed22ef33984476baa9db469f7",
+  "anchor": [
+   "main",
+   70
+  ],
+  "src": 70,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "e6c0d98bcc1a6bb9da9f5338262e068bd8714ecc",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: compact mostly live groups instead of skipping them",
+  "msg_changed": true
+ },
+ {
+  "sha": "2d14ab5322b19c514c67d7a99af929e91e83babb",
+  "anchor": [
+   "part",
+   73,
+   1
+  ],
+  "src": 73,
+  "kind": "part",
+  "sub": 3,
+  "eng_sha": "3a74a38d5dc54a90c2feeae6946e3d616d5ae389",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: keep relocation's stripe runs until relocation ends (reclaim part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "78645e062aad6e6174a3054839327b7ee53678dc",
+  "anchor": [
+   "part",
+   104,
+   5
+  ],
+  "src": 104,
+  "kind": "part",
+  "sub": 3,
+  "eng_sha": "ec8a4b2c2d0915f4fec5579083083b74ba5e6733",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (reclaim part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "3c6ca40e09410d0c0013f9087f55e7016491d996",
+  "anchor": [
+   "part",
+   105,
+   3
+  ],
+  "src": 105,
+  "kind": "part",
+  "sub": 3,
+  "eng_sha": "4ee5ba6f6e23b1bae22071f111482f9aedd3f4ba",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (reclaim part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "06cc630e7476fc3c72b5c973af4f705ae0d7560a",
+  "anchor": [
+   "main",
+   113
+  ],
+  "src": 113,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "518e5340922af58e0dec48728735410903dabda2",
+  "overlaid": true,
+  "subject": "btrfs: log block group reclaim at debug level",
+  "msg_changed": false
+ },
+ {
+  "sha": "1fa66ec046398b13a1ef20d64c3d74374a408562",
+  "anchor": [
+   "main",
+   114
+  ],
+  "src": 114,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "792f4ce95da9a810bf5c36c47608793932c93b09",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: add stripe_reclaim_now to reclaim stripes on demand",
+  "msg_changed": true
+ },
+ {
+  "sha": "682b796e103f6fa363b608a7cf26aecc1588420e",
+  "anchor": [
+   "main",
+   115
+  ],
+  "src": 115,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "67bc0cab13ebbcb3efe4e7d1b27049fc3016f9cf",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: back off block group reclaim after repeated ENOSPC",
+  "msg_changed": false
+ },
+ {
+  "sha": "82594bb4115299019da61cc85c75dde58ad8c456",
+  "anchor": [
+   "main",
+   116
+  ],
+  "src": 116,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "b293fbeb57180a83224b67cc87777d716cbc4f63",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: let queued exclusive operations in between reclaims",
+  "msg_changed": false
+ },
+ {
+  "sha": "5595e2908638afd1bf57b7b91cb611e40b2d128c",
+  "anchor": [
+   "main",
+   13
+  ],
+  "src": 13,
+  "kind": "main",
+  "sub": 4,
+  "eng_sha": "4e7c183937d1a0fa761d8a5d80641b926f257079",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: settle a logged extent's stripes at log commit",
+  "msg_changed": true
+ },
+ {
+  "sha": "6d1f13dfd749e37ed7896cd72a3fc497322f26a6",
+  "anchor": [
+   "part",
+   24,
+   2
+  ],
+  "src": 24,
+  "kind": "part",
+  "sub": 4,
+  "eng_sha": "dff17c8e98115e403d94b3bed6d80a53cf2478e9",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations (fsync part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "44256a808a6ee4794b5ccf49645633ec78c9e501",
+  "anchor": [
+   "part",
+   69,
+   1
+  ],
+  "src": 69,
+  "kind": "part",
+  "sub": 4,
+  "eng_sha": "fb8c8c9c54afee6713cd270dde9c3082235a9be4",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: end the commit-time and log drains on an errored filesystem too (fsync part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "d7198b14ef34f13613e88de5ec30d3dc24f1e3e0",
+  "anchor": [
+   "part",
+   19,
+   1
+  ],
+  "src": 19,
+  "kind": "part",
+  "sub": 4,
+  "eng_sha": "8c74fa6d5a43ca63948d8ccf817aa56c47aecde0",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (fsync part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "1175b160ea87e7c1c20f300457af684357e97843",
+  "anchor": [
+   "main",
+   15
+  ],
+  "src": 15,
+  "kind": "main",
+  "sub": 4,
+  "eng_sha": "c13b7ff6638f4bcb04a0f8f9ec57eb1f5ad68434",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: carry an inode's log tail forward at fsync",
+  "msg_changed": false
+ },
+ {
+  "sha": "bfc7b7c684433aac5bc31dded69cd87873f605cd",
+  "anchor": [
+   "part",
+   67,
+   2
+  ],
+  "src": 67,
+  "kind": "part",
+  "sub": 4,
+  "eng_sha": "cddd789c6403a435b246fcac4b653533d644ec32",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros (fsync part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "1643f70fdb4862cb8c0fb42c7bbe6989f0970c91",
+  "anchor": [
+   "part",
+   19,
+   2
+  ],
+  "src": 19,
+  "kind": "part",
+  "sub": 4,
+  "eng_sha": "ac09434fb807e3f5e55db71bd8539a338ddccb41",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (fsync part 2)",
+  "msg_changed": false
+ },
+ {
+  "sha": "14936b43feb7660c640f2d68cc90be2d94eb8f65",
+  "anchor": [
+   "main",
+   16
+  ],
+  "src": 16,
+  "kind": "main",
+  "sub": 4,
+  "eng_sha": "bc8aae42a8fc1bd457dd266ecb4b46296f5c490a",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: kick parked rbios before the fast fsync's writeback wait",
+  "msg_changed": false
+ },
+ {
+  "sha": "addfa92d36dfbff98b514bc41665e6e75260aea5",
+  "anchor": [
+   "main",
+   83
+  ],
+  "src": 83,
+  "kind": "main",
+  "sub": 4,
+  "eng_sha": "4ef5e908ec471e478e3c415190e0da74539ac52b",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: share LOG data runs per log transaction",
+  "msg_changed": false
+ },
+ {
+  "sha": "a7afa59748916f3afe3dce02d56ca7f35c7f9f70",
+  "anchor": [
+   "part",
+   85,
+   1
+  ],
+  "src": 85,
+  "kind": "part",
+  "sub": 4,
+  "eng_sha": "f93797a247372442c7f028575865bf08fe6bc3df",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode (fsync part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "6704886cf833d22b12453901517455aa6104a56d",
+  "anchor": [
+   "main",
+   88
+  ],
+  "src": 88,
+  "kind": "main",
+  "sub": 4,
+  "eng_sha": "a75303c4150af3b6e161d1dae4f6a7e3dbdafbe1",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: read the shared LOG run mode once per log settle",
+  "msg_changed": false
+ },
+ {
+  "sha": "e30e9544886e061298df0230309c2840c8d7e59a",
+  "anchor": [
+   "part",
+   104,
+   6
+  ],
+  "src": 104,
+  "kind": "part",
+  "sub": 4,
+  "eng_sha": "d1714c6aa1cb5ae92f64dbee7e3c9817532bf723",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (fsync part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "94228b0ee7e266f93045f892371767ebd4ed8ce7",
+  "anchor": [
+   "part",
+   105,
+   4
+  ],
+  "src": 105,
+  "kind": "part",
+  "sub": 4,
+  "eng_sha": "191fa286bc580e48a43f551103c87c6623e38d84",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (fsync part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "4b4dd0c9bef4e9b2d93cfb6575efa2df5306c848",
+  "anchor": [
+   "main",
+   7
+  ],
+  "src": 7,
+  "kind": "main",
+  "sub": 5,
+  "eng_sha": "cf62ab98df337d3e10684c30fbcfbc9f59c83d06",
+  "overlaid": true,
+  "subject": "btrfs: add a write-hole invariant checker to the raid56 write path",
+  "msg_changed": false
+ },
+ {
+  "sha": "e3519862d77d6025f9fc174dbb51ceb212e81d30",
+  "anchor": [
+   "part",
+   28,
+   1
+  ],
+  "src": 28,
+  "kind": "part",
+  "sub": 5,
+  "eng_sha": "1ddfabb1a6b26c5e6719cc753453b576061003de",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: report read-modify-write of uncovered stripes (debug part)",
+  "msg_changed": true
+ },
+ {
+  "sha": "f3b997a86f869945f56c99ee977a61c3e00b2d54",
+  "anchor": [
+   "part",
+   19,
+   3
+  ],
+  "src": 19,
+  "kind": "part",
+  "sub": 5,
+  "eng_sha": "b9f467af571155619f6ccfc0f6494b6c6b14f3b9",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (debug part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "a18636c7b7eb8a493340b866d10946c375c4ce7d",
+  "anchor": [
+   "main",
+   39
+  ],
+  "src": 39,
+  "kind": "main",
+  "sub": 5,
+  "eng_sha": "ba03444e1a42f21aaae77ecc2b2ed5c6deee3e50",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: drain the legacy allocator's writes before arming the write-hole check at a runtime enable",
+  "msg_changed": false
+ },
+ {
+  "sha": "8c51d81412b5a889488c2545df76fc32ee41ecc9",
+  "anchor": [
+   "part",
+   64,
+   1
+  ],
+  "src": 64,
+  "kind": "part",
+  "sub": 5,
+  "eng_sha": "e16d6213ef59e25abea13c55493139c23c9ffdc9",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: say at mount whether the policy is on (debug part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "e69b622a5805bedde45cda7f793210fb35c47aac",
+  "anchor": [
+   "part",
+   104,
+   7
+  ],
+  "src": 104,
+  "kind": "part",
+  "sub": 5,
+  "eng_sha": "74a54f7f4290d416f35c31c79c43c89ee57015c5",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (debug part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "f9ee64df6a3677732afb5c3c8bcc6ab0cf7077f7",
+  "anchor": [
+   "main",
+   71
+  ],
+  "src": 71,
+  "kind": "main",
+  "sub": 5,
+  "eng_sha": "67ef1e02e94a4ccfbfdfda80f716b0cef0552bcb",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: attribute each data read-modify-write to why padding declined",
+  "msg_changed": false
+ },
+ {
+  "sha": "b6140021353ace3305e4cda6cdb4407435326884",
+  "anchor": [
+   "main",
+   72
+  ],
+  "src": 72,
+  "kind": "main",
+  "sub": 5,
+  "eng_sha": "5ce8acb058301d6f4e4fa6d53b3f9bea94ccc446",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: optionally audit data read-modify-writes against the committed extent tree",
+  "msg_changed": false
+ },
+ {
+  "sha": "8b6792e5f7731004afa467f026968a15af52ae35",
+  "anchor": [
+   "main",
+   80
+  ],
+  "src": 80,
+  "kind": "main",
+  "sub": 5,
+  "eng_sha": "ca0a47641b7b511991ca1dd22118dccfa4e16146",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: break rbio pins and open stripe runs down by run class",
+  "msg_changed": false
+ },
+ {
+  "sha": "ca8cc55a23e18d2325893703e8b842c57ba4c52c",
+  "anchor": [
+   "part",
+   104,
+   8
+  ],
+  "src": 104,
+  "kind": "part",
+  "sub": 5,
+  "eng_sha": "f932b1110e3118e2430ad3520cef88fe0d717682",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (debug part 2)",
+  "msg_changed": false
+ },
+ {
+  "sha": "06951680cf0d2930252061b0d454d8b4eb1f4421",
+  "anchor": [
+   "part",
+   105,
+   5
+  ],
+  "src": 105,
+  "kind": "part",
+  "sub": 5,
+  "eng_sha": "58de566a8e56915e71af3c2ccb8315bd37497ed9",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (debug part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "629f454670c45b5cb6779d7261f6cc3a0c00a027",
+  "anchor": [
+   "main",
+   108
+  ],
+  "src": 108,
+  "kind": "main",
+  "sub": 5,
+  "eng_sha": "af05a982014ea1b259cfc1364c754df95831d138",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count and log ordered extents that end with sectors unwritten",
+  "msg_changed": false
+ },
+ {
+  "sha": "4029288b237b7fdf9c052016e7d17634ed5b7767",
+  "anchor": [
+   "main",
+   38
+  ],
+  "src": 38,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "0f22463d99728607438e33050c2c926c504adc64",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: allocate tree blocks by whole stripes",
+  "msg_changed": false
+ },
+ {
+  "sha": "c3eb09937d20a279588c5f029f1c3f5e8b18826d",
+  "anchor": [
+   "part",
+   109,
+   1
+  ],
+  "src": 109,
+  "kind": "part",
+  "sub": 6,
+  "eng_sha": "a21f277afd4181de8f2dc78b4144fd6017a9caec",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3 (stripe_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "9a8bbe5a53a504a89161fc82d820e209b05a780b",
+  "anchor": [
+   "new",
+   64.5
+  ],
+  "src": 64.5,
+  "kind": "new",
+  "sub": 6,
+  "eng_sha": "93ea86b2d4cec4576dfa2222c2c83b16bf969998",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: extend stripe reclaim to metadata block groups",
+  "msg_changed": false
+ },
+ {
+  "sha": "5e84832cf6d78e1bfcee68c7990cab049797b986",
+  "anchor": [
+   "main",
+   48
+  ],
+  "src": 48,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "104626da44cbce60460a235cc0cb9e8677348379",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: maintain trapped free space for metadata groups like data",
+  "msg_changed": false
+ },
+ {
+  "sha": "21008681a03a56ff48883dc4af97e57795acee29",
+  "anchor": [
+   "main",
+   49
+  ],
+  "src": 49,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "80a2a4bcd0307f3339bbe3c53ef99ab18e3d231c",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: back the global reserve with usable stripes, and say when a tree block finds none",
+  "msg_changed": false
+ },
+ {
+  "sha": "9d8922921a9d6970b3e98fa8a8a6eea15c14355a",
+  "anchor": [
+   "main",
+   50
+  ],
+  "src": 50,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "9dde816705152275721ce8ef2906f8d1c84c41b2",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: hold back whole stripes so tree blocks always land and trapped groups can be reclaimed",
+  "msg_changed": false
+ },
+ {
+  "sha": "9f53e5f7d9c2b5031bee25c8c021c08a707577d0",
+  "anchor": [
+   "part",
+   57,
+   2
+  ],
+  "src": 57,
+  "kind": "part",
+  "sub": 6,
+  "eng_sha": "15f9c04f76613b36359f35fefc9212076f1081ec",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped (stripe_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "d1e2db751d1fe8d8047d788dc70bf510759a5168",
+  "anchor": [
+   "part",
+   91,
+   1
+  ],
+  "src": 91,
+  "kind": "part",
+  "sub": 6,
+  "eng_sha": "ccdeea1af337a0b8a7dd23d8d0cc7cc9b88ec340",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: keep the stripe totals consistent with the groups during the commit scan (stripe_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "2c4dd884e2449b27f5cbe1571fbf587303bd39d0",
+  "anchor": [
+   "part",
+   110,
+   1
+  ],
+  "src": 110,
+  "kind": "part",
+  "sub": 6,
+  "eng_sha": "fafd6cee7e96caa4c4f06f9611bdb1dcebbe9839",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count single-data-stripe groups' free space in write admission (stripe_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "ff078dcd05c17f090e277cad03f6c3b738eacbb9",
+  "anchor": [
+   "main",
+   51
+  ],
+  "src": 51,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "110357f516d9b8b428b91425e29622c6efa28d6c",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: do not steal from the global reserve below the relocation reserve",
+  "msg_changed": false
+ },
+ {
+  "sha": "e6507b540abb39f08db3f7d76e9765eae30ab117",
+  "anchor": [
+   "main",
+   52
+  ],
+  "src": 52,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "43b0cb49028c319ff5e2a7104a7f711b475997d6",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: let the transaction machinery's own reservations draw on the reserve",
+  "msg_changed": false
+ },
+ {
+  "sha": "91a867e5ecd4c573ebb7c2784dd3925bef6f6d94",
+  "anchor": [
+   "main",
+   53
+  ],
+  "src": 53,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "48192148bdd084874df638ed81737dcd0dc48ddf",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: let a group go read-only for relocation against the reserve",
+  "msg_changed": false
+ },
+ {
+  "sha": "e1b4e20f900af9b45a04f266d99d303171db4660",
+  "anchor": [
+   "main",
+   61
+  ],
+  "src": 61,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "b293f5e30f8f9b29b5da731072441fff8a828bb0",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: carry raid56 metadata groups through a runtime enable or disable",
+  "msg_changed": false
+ },
+ {
+  "sha": "3e0b6f86edd06e0b81734cace4c709c3f48b5dd5",
+  "anchor": [
+   "main",
+   65
+  ],
+  "src": 65,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "0113dbe591ee8e9118944619780757b6cab4d55b",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: cover raid56 system chunks",
+  "msg_changed": false
+ },
+ {
+  "sha": "a6993fd2c0d013a6c155ec63c3adc535749c115c",
+  "anchor": [
+   "main",
+   81
+  ],
+  "src": 81,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "7df0160e7efd342460f8203fdbfb7ba3e022c4ab",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: give each log commit its own metadata stripe run",
+  "msg_changed": false
+ },
+ {
+  "sha": "bd2ec309fefa96ddaa7a4018614aca7e96bc116d",
+  "anchor": [
+   "part",
+   85,
+   2
+  ],
+  "src": 85,
+  "kind": "part",
+  "sub": 6,
+  "eng_sha": "0a6a85ef639f2e0ddeba9034b33a6b081db89ddb",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode (stripe_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "dae72bf627f17957cac95e26d0857484923ad769",
+  "anchor": [
+   "part",
+   83,
+   1
+  ],
+  "src": 83,
+  "kind": "part",
+  "sub": 6,
+  "eng_sha": "3a2c91f85d5a6e55135a366963f8ddc89183c4d8",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: share LOG data runs per log transaction (stripe_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "d6e2e36e49a646644b0eb77150be4c503cb7feaf",
+  "anchor": [
+   "main",
+   93
+  ],
+  "src": 93,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "308b5a121aa89e3f9f330c0856624541d07d4185",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: commit before waiting for metadata runs when making a group read-only",
+  "msg_changed": false
+ },
+ {
+  "sha": "21a3432053193fafd42d33a6c693686f6424a345",
+  "anchor": [
+   "main",
+   102
+  ],
+  "src": 102,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "1d3ae0cd95fdf26a1bbc9ee4c04907d2e14734af",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: check the block group lookup when freeing an unwritten tree block",
+  "msg_changed": false
+ },
+ {
+  "sha": "95f421837a6c255d238ff0f3315b8ebef6b9f6ea",
+  "anchor": [
+   "main",
+   104
+  ],
+  "src": 104,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "850533ec8156a345771d9c7f0ace221a5b4e95f7",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments",
+  "msg_changed": false
+ },
+ {
+  "sha": "7ff54559446b6e0cdfce111ff6b38d739a5c77b4",
+  "anchor": [
+   "main",
+   105
+  ],
+  "src": 105,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "13cee3a7f329550bea43f8ac8569f48ce6377aad",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code",
+  "msg_changed": false
+ },
+ {
+  "sha": "7be25fc24225921e6eed29fdf9031fef54e08785",
+  "anchor": [
+   "part",
+   109,
+   2
+  ],
+  "src": 109,
+  "kind": "part",
+  "sub": 6,
+  "eng_sha": "967fe161386f49ef7b28ca240d07bc9a1e5ae4b7",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3 (stripe_meta part 2)",
+  "msg_changed": false
+ },
+ {
+  "sha": "f9e5ad0b0a86b3e32d2d172f502d552eb472cacf",
+  "anchor": [
+   "main",
+   106
+  ],
+  "src": 106,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "e91f3a3fd2fe6b5e1d59c945b591295fbff82f10",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: keep waiting for metadata runs that do not drain at commit",
+  "msg_changed": false
+ },
+ {
+  "sha": "cacda53e79f2724b90c0b3f42b047ae74ae7ff74",
+  "anchor": [
+   "main",
+   111
+  ],
+  "src": 111,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "1ce02a2c0709ba4574bbbed976c976679ead85a3",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: account claimable stripes while a trim has them out",
+  "msg_changed": false
+ },
+ {
+  "sha": "34d3d865ed98c3dd104dcdf20760675750844411",
+  "anchor": [
+   "main",
+   112
+  ],
+  "src": 112,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "0d3c77b154a36cad0d87f98a2926de0670ecb642",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not miss bitmap free space when debiting a trim",
+  "msg_changed": false
+ },
+ {
+  "sha": "a4fc2ced1e4419e5df7189e0224f49f57e2c9898",
+  "anchor": [
+   "part",
+   108,
+   1
+  ],
+  "src": 108,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "f26d7fe7b52f1dfa204bbff0047ada6d1641f242",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count and log ordered extents that end with sectors unwritten (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "9826791e68430bc45e4a8bd19e7370d6e70e046c",
+  "anchor": [
+   "main",
+   29
+  ],
+  "src": 29,
+  "kind": "main",
+  "sub": 7,
+  "eng_sha": "31665a601e0accdf1f4f71c90e6120bd11eb4ed6",
+  "overlaid": true,
+  "subject": "btrfs: raid56: say whether a metadata read-modify-write is a write hole",
+  "msg_changed": false
+ },
+ {
+  "sha": "09e7ad262b5f5a7cbc15b96346e1e2c05361b87d",
+  "anchor": [
+   "part",
+   30,
+   2
+  ],
+  "src": 30,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "9f86cfbaac137d4df433f8b9778fa52af621c0d5",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "2f97b6fdaa4835515dee8810c57dcdbccc238340",
+  "anchor": [
+   "part",
+   31,
+   1
+  ],
+  "src": 31,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "c8edb392a5eefac3008a06cb41b3fbf577e0fa7d",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: trace why padding declined, at the moment it declined (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "0c2a0e7ce257fdea6c7985645853c8fa3d3dc4a2",
+  "anchor": [
+   "part",
+   71,
+   1
+  ],
+  "src": 71,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "32b0ba7b1e2b68a8c71e482f6182483f6f367abe",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: attribute each data read-modify-write to why padding declined (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "b004256facea96939f886341a81ac2464b3fe259",
+  "anchor": [
+   "part",
+   35,
+   1
+  ],
+  "src": 35,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "08bfa0c17ff00b1dc241d31fe9e1ebb4a40901e0",
+  "overlaid": true,
+  "subject": "btrfs: raid56: adaptive park deadline from the parked-rbio backlog (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "d0bb0c03ea09ab11e4482e5af28b025886aad4cd",
+  "anchor": [
+   "part",
+   75,
+   2
+  ],
+  "src": 75,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "06f23f4488c3d64a83c91df135312748b498e6c0",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "1bd4941ff6024b2fd2c755a97b3a608b61af9897",
+  "anchor": [
+   "part",
+   78,
+   1
+  ],
+  "src": 78,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "1e213d8eb7a6f277aee9b7f6e0b1734155b6357a",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count refused rbio pins and track rbio cache high water (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "03c8518913376cc04ac77c12ca02d218870b437c",
+  "anchor": [
+   "part",
+   79,
+   1
+  ],
+  "src": 79,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "b6d8e147eb9ad942bbe7a1379c3ec23bd493df7d",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: sweep stale rbio pins, and commit when live pins run low (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "efbe434e17a93abf7f60ad10af50db7afe900943",
+  "anchor": [
+   "main",
+   55
+  ],
+  "src": 55,
+  "kind": "main",
+  "sub": 7,
+  "eng_sha": "38cfd9f096ad453bd47a1f4613237da087a9625e",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: tell a dead tree block from a live one in the metadata RMW audit",
+  "msg_changed": false
+ },
+ {
+  "sha": "d15887ecef7122c87213cb4fbc51867c397dd691",
+  "anchor": [
+   "main",
+   94
+  ],
+  "src": 94,
+  "kind": "main",
+  "sub": 7,
+  "eng_sha": "0fc23632e1d93c9ab89a613ef9c8f0bfc1d64cd4",
+  "overlaid": true,
+  "subject": "btrfs: raid56: do not read tree blocks under the stripe lock in the metadata RMW audit",
+  "msg_changed": false
+ },
+ {
+  "sha": "f4cda5e74317c686d72035a8eadec36d547178c0",
+  "anchor": [
+   "part",
+   105,
+   6
+  ],
+  "src": 105,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "bafbe3e759a0c2aba3265ddcb3730553ac0a34a4",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "f4cfb9869a7d917772446aebc355d46571f1cac4",
+  "anchor": [
+   "main",
+   107
+  ],
+  "src": 107,
+  "kind": "main",
+  "sub": 7,
+  "eng_sha": "5b273677ccbcbf2b38363b20187a98812dc2a515",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: remove pad refusal reasons that no longer exist",
+  "msg_changed": false
+ }
+]
\ No newline at end of file
diff --git a/scripts/sa-reorder/wpost-p16.log b/scripts/sa-reorder/wpost-p16.log
new file mode 100644 (file)
index 0000000..2323780
--- /dev/null
@@ -0,0 +1,329 @@
+  1 ('main', 1) e23113f4ad7a (eng)
+  2 ('main', 2) 0b1f0887a21e (eng)
+  3 ('main', 3) 5931dc5f54e2 (eng)
+  4 ('main', 4) c4e0fd25ccb9 (eng)
+  5 ('main', 5) 693536d80232 (eng)
+  6 ('main', 6) ebc48a1813b9 (eng)
+  7 ('main', 8) bf2c838dd11b (eng)
+  8 ('main', 9) 5e8d3df74970 (eng)
+  9 ('main', 10) f2c70f777cb6 (eng)
+ 10 ('main', 11) 85e9c3a93e24 (eng)
+ 11 ('main', 12) fb57a2a8a832 (eng)
+ 12 ('main', 14) 6b4d107ce62b (eng)
+ 13 ('main', 17) 160e8e5b7d41 (eng)
+ 14 ('main', 22) dad142105b2f (eng)
+ 15 ('main', 23) 80bdd7cb0dd1 (eng)
+ 16 ('main', 24) a257343cf1f3 (eng)
+ 17 ('main', 25) 941755e25c9a (eng)
+ 18 ('main', 26) b505236ebf84 (eng)
+ 19 ('main', 27) 580b3c0bee2e (eng)
+ 20 ('main', 28) 94748fe2597b (eng)
+ 21 ('main', 30) 6bad62b21931 (eng)
+ 22 ('main', 31) 125fcbf783f9 (eng)
+ 23 ('main', 32) de2996ad44aa (eng)
+ 24 ('main', 33) 38a7a9e59654 (eng)
+ 25 ('main', 34) e410dd29ce38 (eng)
+ 26 ('main', 35) 3cf4ec13f996 (eng)
+ 27 ('main', 36) afdaa64ea8bc (eng)
+ 28 ('main', 37) aa0134f5fb37 (eng)
+ 29 ('main', 40) c2e5d152d811 (eng)
+ 30 ('main', 41) 5396ab6ffdd9 (eng)
+ 31 ('main', 43) 5f85d3a9e04a (eng)
+ 32 ('main', 44) 56a3b3bc8971 (eng)
+ 33 ('main', 45) 2bbcbfc10002 (eng)
+ 34 ('main', 54) c484faf3b523 (eng)
+ 35 ('main', 57) 12b6d4eb4bcb (eng)
+ 36 ('main', 59) 87a83a998676 (eng)
+ 37 ('main', 60) 9ed29ab2da2f (eng)
+ 38 ('main', 62) 7ae3ce41afe0 (eng)
+ 39 ('main', 63) c9d9d628e1b0 (eng)
+ 40 ('main', 64) bbb6d9a19b37 (eng)
+ 41 ('main', 68) 800301924ce8 (eng)
+ 42 ('main', 69) 2b68ec2b1483 (eng)
+ 43 ('main', 73) cf70d35b9855
+ 44 ('main', 74) 5a2a51199486
+ 45 ('main', 75) a6e05f55070f
+ 46 ('main', 76) 46963ee31299
+ 47 ('main', 77) ce284c8dfc5c
+ 48 ('main', 78) 88dce5883d68
+ 49 ('main', 79) 32a8aa02d40d
+ 50 ('main', 82) 1e17b737c30b
+ 51 ('main', 84) eed0f41ac776
+ 52 ('main', 86) 149a6c438555
+ 53 ('main', 87) 8e65ac048964
+ 54 ('main', 89) c324b75cfab8
+ 55 ('main', 91) fd2e62dd1566
+ 56 ('main', 92) fab3241e679d
+ 57 ('main', 95) 85029b83e167
+ 58 ('main', 96) ed12f0d17dec
+ 59 ('main', 97) 95a41b17024c
+ 60 ('main', 98) b9fb639e649f
+ 61 ('main', 99) f5787cc611eb
+ 62 ('main', 101) f7ff48d44819
+ 63 ('part', 104, 1) 830b17d648de
+ 64 ('part', 105, 1) 24f697cb8c44
+ 65 ('main', 109) a9e10f334cf5
+ 66 ('main', 110) aa85994a8b60
+ 67 ('main', 18) d52ea17b1b90
+ 68 ('part', 59, 1) de2ab7ef060e
+ 69 ('part', 75, 1) 8690a6238055
+ 70 ('part', 76, 1) 469072e13b35
+ 71 ('main', 19) fef19da5f74b
+ 72 ('part', 33, 1) f38aa6a3c6f2
+ 73 ('part', 104, 2) 709101f6fafd
+ 74 ('main', 67) d3480398cd59
+ 75 ('part', 104, 3) be037bf330d3
+ 76 ('main', 20) 2ce1b1523e62
+ 77 ('part', 24, 1) ce408846039a
+ 78 ('part', 67, 1) d85da6ed20da
+ 79 ('main', 21) 2607a77010d0
+ 80 ('part', 30, 1) 29f2893d7a7e
+ 81 ('main', 56) daed1e2a25e1
+ 82 ('main', 58) 34924a1ef3ee
+ 83 ('main', 66) 09856a2dbb2d
+ 84 ('main', 85) bf085d0c7dae
+ 85 ('main', 90) d0af47c425da
+ 86 ('main', 100) a381eb137f9b
+ 87 ('main', 103) 4c6906f7cb8f
+ 88 ('part', 104, 4) 81713f186913
+ 89 ('part', 105, 2) edbc35cb6344
+ 90 ('main', 42) 001839205827
+ 91 ('main', 46) 6d3bead12ef4
+ 92 ('part', 57, 1) ade75a72fce6
+ 93 ('main', 47) b766559e8abc
+ 94 ('main', 70) d787f43ab5f8
+ 95 ('part', 73, 1) e6622ee17526
+ 96 ('part', 104, 5) 6fe0a2cf2a87
+ 97 ('part', 105, 3) 42f8ba8baf8b
+ 98 ('main', 113) d816c5ae582e
+ 99 ('main', 114) f5f5ef5119d5
+100 ('main', 115) 283208631d0f
+101 ('main', 116) 926c61ef2f07
+102 ('main', 13) 109c8251f217
+103 ('part', 24, 2) 087f3c65bc86
+104 ('part', 69, 1) 10a6dab063a8
+105 ('part', 19, 1) b98868604a66
+106 ('main', 15) ec60b1560987
+107 ('part', 67, 2) bd545b2037a8
+108 ('part', 19, 2) f2a8b71810e7
+109 ('main', 16) d52bed2756e1
+110 ('main', 83) c6cb41396d6e
+111 ('part', 85, 1) 87236243fc7e
+112 ('main', 88) 896ef0633761
+113 ('part', 104, 6) 59e9d24a0fd2
+114 ('part', 105, 4) e02db7908314
+115 ('main', 7) 6f5344208630
+116 ('part', 28, 1) c5631f33120a
+117 ('part', 19, 3) de99f3b8ea13
+118 ('main', 39) 56d697cb5692
+119 ('part', 64, 1) 1d6b5c4bb78b
+120 ('part', 104, 7) d5937701d502
+121 ('main', 71) 813577e01d58
+122 ('main', 72) 3bfdf51e36fa
+123 ('main', 80) 36f800595f08
+124 ('part', 104, 8) 1c1773e4b50d
+125 ('part', 105, 5) 2e6f152f9aa6
+126 ('main', 108) f9e4431e8ab4
+127 ('main', 38) ad48a88cadd7
+128 ('part', 109, 1) dbf36122ece2
+129 ('new', 64.5) 5f7013266593
+130 ('main', 48) 1b496ef67e67
+131 ('main', 49) 752ffd8352a0
+132 ('main', 50) 8093c37a16bb
+133 ('part', 57, 2) feeb649e3be1
+134 ('part', 91, 1) d0a630c09c81
+135 ('part', 110, 1) 3c8969ef8de0
+136 ('main', 51) b4e0cb8cad71
+137 ('main', 52) 760f29ff7486
+138 ('main', 53) b4d43d59784c
+139 ('main', 61) 05f315bac47d
+140 ('main', 65) e2fc4bb4f005
+141 ('main', 81) 2f4fb74448a6
+142 ('part', 85, 2) dfdfdf88a369
+143 ('part', 83, 1) 383e95eab4b2
+144 ('main', 93) 3414e775713d
+145 ('main', 102) 3141f674ea7f
+146 ('main', 104) 6b93ce57ccdc
+147 ('main', 105) 9571324fe289
+148 ('part', 109, 2) 6613dcba3190
+149 ('main', 106) 9ec6a1bbdf70
+150 ('main', 111) 50418060e82d
+151 ('main', 112) 5992ee46927e
+152 ('part', 108, 1) 1be7dba5bebe
+153 ('main', 29) e7776855ec87
+154 ('part', 30, 2) d3f0150dbebc
+155 ('part', 31, 1) d7259e7a4d19
+156 ('part', 71, 1) 61a3dec4944e
+157 ('part', 35, 1) a2739bc2aa28
+158 ('part', 75, 2) 1d5cf69a51f1
+159 ('part', 78, 1) fb7d6b61be0c
+160 ('part', 79, 1) 0f6fd996cc6f
+161 ('main', 55) c6092428ba13
+162 ('main', 94) db412ba8e613
+163 ('part', 105, 6) de47f60d1c99
+164 ('main', 107) d6df042c87d4
+  1 S1 main ('main', 1) 53ba8a7913e5 btrfs: add btrfs_claim_free_stripe_run() for stripe-exclusive allocati
+  2 S1 main ('main', 2) 0e3b923d068f btrfs: add open stripe run tracking for stripe-exclusive allocation
+  3 S1 main ('main', 3) 91d82a62a9b8 btrfs: add the stripe_alloc allocation policy for raid56 data
+  4 S1 main ('main', 4) 9e5bb9d16e5a btrfs: stripe_alloc: control the policy with a filesystem property
+  5 S1 main ('main', 5) 57c75df42ff9 btrfs: report stripe run data IO through the ordered extent lifecycle
+  6 S1 main ('main', 6) bc8d48e1a097 btrfs: retire stripe runs at commit and gate stripe_alloc
+  7 S1 main ('main', 8) 93f9689a3547 btrfs: account stripe_alloc trapped free space for honest statfs
+  8 S1 main ('main', 9) da1e7414ea58 btrfs: stripe_alloc: keep an open run per size band to trap less
+  9 S1 main ('main', 10) 32de7e8592e2 btrfs: stripe_alloc: grow the frontier run instead of stranding its ta
+ 10 S1 main ('main', 11) 44f6b99d3a81 btrfs: raid56: batch stripe_alloc partial writes into full-stripe writ
+ 11 S1 main ('main', 12) 8b509d4d0471 btrfs: stripe_alloc: never claim stripes covered by a live run
+ 12 S1 main ('main', 14) 8047a827bf8d btrfs: stripe_alloc: private per-inode stripe runs for log-active inod
+ 13 S1 main ('main', 17) 7dd543fef4e4 btrfs: raid56: pad sub-stripe writes to full stripes in open runs
+ 14 S1 main ('main', 22) c5b1b8be45cb btrfs: raid56: expose parking statistics in sysfs
+ 15 S1 main ('main', 23) e63b201b2f43 btrfs: raid56: skip parking for sync rbios finished by their unplug ba
+ 16 S1 main ('main', 24) d63e5cb2699b btrfs: stripe_alloc: count open stripe run remainders against data res
+ 17 S1 main ('main', 25) 51b6740c9909 btrfs: stripe_alloc: pessimistic data reservation margin
+ 18 S1 main ('main', 26) 1a306de9f217 btrfs: stripe_alloc: claim fully-free stripes that span free space ent
+ 19 S1 main ('main', 27) f2fabdfbb66d btrfs: stripe_alloc: warn when raid56 metadata is not covered
+ 20 S1 main ('main', 28) 8e6f3bed5a5b btrfs: stripe_alloc: report read-modify-write of uncovered stripes
+ 21 S1 main ('main', 30) 5f97eae925d0 btrfs: stripe_alloc: tunable park deadlines, and say why padding decli
+ 22 S1 main ('main', 31) 7f6ac3e51a01 btrfs: stripe_alloc: trace why padding declined, at the moment it decl
+ 23 S1 main ('main', 32) a767739f1e99 btrfs: stripe_alloc: complete parked writes on allocation coverage, no
+ 24 S1 main ('main', 33) ac979e48c063 btrfs: stripe_alloc: track per-sector liveness and pad from the map
+ 25 S1 main ('main', 34) 2a42771b1ce0 btrfs: stripe_alloc: count claimable whole-stripe supply directly
+ 26 S1 main ('main', 35) 7db677b5a235 btrfs: raid56: adaptive park deadline from the parked-rbio backlog
+ 27 S1 main ('main', 36) 3de0f438b97b btrfs: stripe_alloc: gate data admission on claimable whole-stripe sup
+ 28 S1 main ('main', 37) 9b7b57554e07 btrfs: stripe_alloc: cache a failed stripe run scan per block group
+ 29 S1 main ('main', 40) dfe42d77601c btrfs: stripe_alloc: keep the admitted bytes placeable when a group go
+ 30 S1 main ('main', 41) 20fded529b71 btrfs: stripe_alloc: never let relocation wait on the whole-stripe gat
+ 31 S1 main ('main', 43) e81d6cd2dbc3 btrfs: stripe_alloc: charge relocation a margin per reservation, not p
+ 32 S1 main ('main', 44) e6f27d109fb5 btrfs: stripe_alloc: keep the relocation group's stripes out of the ad
+ 33 S1 main ('main', 45) 620d39cb6a34 btrfs: stripe_alloc: let a data write fall back to the relocation grou
+ 34 S1 main ('main', 54) b64ea46019c1 btrfs: stripe_alloc: show per-group trapped bytes in the space info du
+ 35 S1 main ('main', 57) c347e4a47328 btrfs: stripe_alloc: count whole stripes stranded behind live runs as 
+ 36 S1 main ('main', 59) 5816f99eecd9 btrfs: stripe_alloc: count nocow run lifecycles and stranded stripes i
+ 37 S1 main ('main', 60) aa2a16a87ce0 btrfs: stripe_alloc: hold a stripe of margin across a preallocation
+ 38 S1 main ('main', 62) af600ccf95f2 btrfs: stripe_alloc: return a group's allocation cluster before scanni
+ 39 S1 main ('main', 63) cc7f5012e68c btrfs: stripe_alloc: release open stripe runs when a mount fails or an
+ 40 S1 main ('main', 64) 8d55f6470ba0 btrfs: stripe_alloc: say at mount whether the policy is on
+ 41 S1 main ('main', 68) f7ae6f49b1dc btrfs: stripe_alloc: do not wait for stripe runs to drain on an errore
+ 42 S1 main ('main', 69) c5d893d04cd2 btrfs: stripe_alloc: end the commit-time and log drains on an errored 
+ 43 S1 main ('main', 73) 607b63bee553 btrfs: stripe_alloc: keep relocation's stripe runs until relocation en
+ 44 S1 main ('main', 74) 698d58a009b3 btrfs: stripe_alloc: let relocation allocate a data chunk before it fa
+ 45 S1 main ('main', 75) 237c76a34bbb btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has
+ 46 S1 main ('main', 76) dc616451399b btrfs: stripe_alloc: pad a stripe's allocated sectors whose write is s
+ 47 S1 main ('main', 77) c566752d5d46 btrfs: stripe_alloc: apply the property before tree-log replay
+ 48 S1 main ('main', 78) 7e578fc00b60 btrfs: stripe_alloc: count refused rbio pins and track rbio cache high
+ 49 S1 main ('main', 79) 7bfdd912d13e btrfs: stripe_alloc: sweep stale rbio pins, and commit when live pins 
+ 50 S1 main ('main', 82) bd839f5223b5 btrfs: stripe_alloc: don't make a parked rbio wait for sectors that wi
+ 51 S1 main ('main', 84) 0b54cc635fba btrfs: stripe_alloc: let relocation allocate as many data chunks as it
+ 52 S1 main ('main', 86) 70b9f361cb5a btrfs: stripe_alloc: do not treat an allocation error as a found exten
+ 53 S1 main ('main', 87) 23e54ac469ab btrfs: stripe_alloc: mark an ended ordered extent's sectors written
+ 54 S1 main ('main', 89) 335bb14838d6 btrfs: stripe_alloc: remove only the set bits of a bitmap when claimin
+ 55 S1 main ('main', 91) 5f41b653ca05 btrfs: stripe_alloc: keep the stripe totals consistent with the groups
+ 56 S1 main ('main', 92) fc344bba3eb3 btrfs: stripe_alloc: do not delete an unused block group that still ha
+ 57 S1 main ('main', 95) d5865030dd5a btrfs: raid56: stop the park timer before destroying the raid56 workqu
+ 58 S1 main ('main', 96) dfadf31986bb btrfs: stripe_alloc: order the filesystem error before waking stripe d
+ 59 S1 main ('main', 97) fade7419de5a btrfs: raid56: set a padded rbio's data bitmap under bio_list_lock
+ 60 S1 main ('main', 98) 48b3059eda8a btrfs: stripe_alloc: forget the failed-claim verdict when a cluster re
+ 61 S1 main ('main', 99) 866595675c23 btrfs: stripe_alloc: do not let a remount revert the stripe_alloc prop
+ 62 S1 main ('main', 101) 0936e16ecd28 btrfs: stripe_alloc: keep the head of a claimed free space entry under
+ 63 S1 part ('part', 104, 1) 45e6f92823c6 btrfs: stripe_alloc: correct and trim the block group comments (base p
+ 64 S1 part ('part', 105, 1) dc754f4481da btrfs: stripe_alloc: correct and trim the comments outside the block g
+ 65 S1 main ('main', 109) 3bc80b13dbb5 btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID
+ 66 S1 main ('main', 110) d24269da3167 btrfs: stripe_alloc: count single-data-stripe groups' free space in wr
+ 67 S2 main ('main', 18) eca751087b7c btrfs: stripe_alloc: isolate nodatacow and preallocated extents by str
+ 68 S2 part ('part', 59, 1) 91d4f8e210f5 btrfs: stripe_alloc: count nocow run lifecycles and stranded stripes i
+ 69 S2 part ('part', 75, 1) 9a921516ad15 btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has
+ 70 S2 part ('part', 76, 1) 4512e646316e btrfs: stripe_alloc: pad a stripe's allocated sectors whose write is s
+ 71 S2 main ('main', 19) 1f6451cd7396 btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated
+ 72 S2 part ('part', 33, 1) b6d4137de35b btrfs: stripe_alloc: track per-sector liveness and pad from the map (a
+ 73 S2 part ('part', 104, 2) 278a65718254 btrfs: stripe_alloc: correct and trim the block group comments (allow_
+ 74 S2 main ('main', 67) 6bada689fb1c btrfs: stripe_alloc: do not round a full stripe with power-of-two macr
+ 75 S2 part ('part', 104, 3) 31e16ed57867 btrfs: stripe_alloc: correct and trim the block group comments (allow_
+ 76 S2 main ('main', 20) 47e9505b6d89 btrfs: stripe_alloc: persist nocow runs across commits and remounts
+ 77 S2 part ('part', 24, 1) 12ea6d04a32b btrfs: stripe_alloc: count open stripe run remainders against data res
+ 78 S2 part ('part', 67, 1) 8bf855883296 btrfs: stripe_alloc: do not round a full stripe with power-of-two macr
+ 79 S2 main ('main', 21) 71bbf3a95cb2 btrfs: raid56: do not park sync writes into nocow runs
+ 80 S2 part ('part', 30, 1) 7a648dd0147c btrfs: stripe_alloc: tunable park deadlines, and say why padding decli
+ 81 S2 main ('main', 56) 33b2f0fd10ad btrfs: stripe_alloc: do not read an inline backref off a keyed-ref ext
+ 82 S2 main ('main', 58) 99b7fc262fc3 btrfs: stripe_alloc: give nocow extents a private run only while they 
+ 83 S2 main ('main', 66) c645e6f3722e btrfs: stripe_alloc: close dead nocow stripe runs at commit
+ 84 S2 main ('main', 85) 25bf8a7fbf78 btrfs: stripe_alloc: key private stripe runs by subvolume and inode
+ 85 S2 main ('main', 90) b8a014c169f5 btrfs: stripe_alloc: claim a stripe tail in one free space lock sectio
+ 86 S2 main ('main', 100) 52d6e5f341ba btrfs: stripe_alloc: do not block a NOWAIT write in the nocow stripe c
+ 87 S2 main ('main', 103) 0765fb66a9f0 btrfs: stripe_alloc: remove the unused stripe_rmw_opt field
+ 88 S2 part ('part', 104, 4) 4c2fee7c2add btrfs: stripe_alloc: correct and trim the block group comments (allow_
+ 89 S2 part ('part', 105, 2) e2d9e382146f btrfs: stripe_alloc: correct and trim the comments outside the block g
+ 90 S3 main ('main', 42) ed3cd465e153 btrfs: stripe_alloc: give a queued stripe group a chunk to relocate in
+ 91 S3 main ('main', 46) 308f903988ea btrfs: stripe_alloc: hand groups full of trapped free space to the rec
+ 92 S3 part ('part', 57, 1) 8b897efd78c7 btrfs: stripe_alloc: count whole stripes stranded behind live runs as 
+ 93 S3 main ('main', 47) f2c3cfef2fa8 btrfs: stripe_alloc: relocate a queued stripe group even while it has 
+ 94 S3 main ('main', 70) 64fdc40d2a13 btrfs: stripe_alloc: compact mostly live groups instead of skipping th
+ 95 S3 part ('part', 73, 1) 2d14ab5322b1 btrfs: stripe_alloc: keep relocation's stripe runs until relocation en
+ 96 S3 part ('part', 104, 5) 78645e062aad btrfs: stripe_alloc: correct and trim the block group comments (reclai
+ 97 S3 part ('part', 105, 3) 3c6ca40e0941 btrfs: stripe_alloc: correct and trim the comments outside the block g
+ 98 S3 main ('main', 113) 06cc630e7476 btrfs: log block group reclaim at debug level
+ 99 S3 main ('main', 114) 1fa66ec04639 btrfs: stripe_alloc: add stripe_reclaim_now to reclaim stripes on dema
+100 S3 main ('main', 115) 682b796e103f btrfs: stripe_alloc: back off block group reclaim after repeated ENOSP
+101 S3 main ('main', 116) 82594bb41152 btrfs: stripe_alloc: let queued exclusive operations in between reclai
+102 S4 main ('main', 13) 5595e2908638 btrfs: stripe_alloc: settle a logged extent's stripes at log commit
+103 S4 part ('part', 24, 2) 6d1f13dfd749 btrfs: stripe_alloc: count open stripe run remainders against data res
+104 S4 part ('part', 69, 1) 44256a808a6e btrfs: stripe_alloc: end the commit-time and log drains on an errored 
+105 S4 part ('part', 19, 1) d7198b14ef34 btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated
+106 S4 main ('main', 15) 1175b160ea87 btrfs: stripe_alloc: carry an inode's log tail forward at fsync
+107 S4 part ('part', 67, 2) bfc7b7c68443 btrfs: stripe_alloc: do not round a full stripe with power-of-two macr
+108 S4 part ('part', 19, 2) 1643f70fdb48 btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated
+109 S4 main ('main', 16) 14936b43feb7 btrfs: stripe_alloc: kick parked rbios before the fast fsync's writeba
+110 S4 main ('main', 83) addfa92d36df btrfs: stripe_alloc: share LOG data runs per log transaction
+111 S4 part ('part', 85, 1) a7afa5974891 btrfs: stripe_alloc: key private stripe runs by subvolume and inode (f
+112 S4 main ('main', 88) 6704886cf833 btrfs: stripe_alloc: read the shared LOG run mode once per log settle
+113 S4 part ('part', 104, 6) e30e9544886e btrfs: stripe_alloc: correct and trim the block group comments (fsync 
+114 S4 part ('part', 105, 4) 94228b0ee7e2 btrfs: stripe_alloc: correct and trim the comments outside the block g
+115 S5 main ('main', 7) 4b4dd0c9bef4 btrfs: add a write-hole invariant checker to the raid56 write path
+116 S5 part ('part', 28, 1) e3519862d77d btrfs: stripe_alloc: report read-modify-write of uncovered stripes (de
+117 S5 part ('part', 19, 3) f3b997a86f86 btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated
+118 S5 main ('main', 39) a18636c7b7eb btrfs: stripe_alloc: drain the legacy allocator's writes before arming
+119 S5 part ('part', 64, 1) 8c51d81412b5 btrfs: stripe_alloc: say at mount whether the policy is on (debug part
+120 S5 part ('part', 104, 7) e69b622a5805 btrfs: stripe_alloc: correct and trim the block group comments (debug 
+121 S5 main ('main', 71) f9ee64df6a36 btrfs: stripe_alloc: attribute each data read-modify-write to why padd
+122 S5 main ('main', 72) b6140021353a btrfs: stripe_alloc: optionally audit data read-modify-writes against 
+123 S5 main ('main', 80) 8b6792e5f773 btrfs: stripe_alloc: break rbio pins and open stripe runs down by run 
+124 S5 part ('part', 104, 8) ca8cc55a23e1 btrfs: stripe_alloc: correct and trim the block group comments (debug 
+125 S5 part ('part', 105, 5) 06951680cf0d btrfs: stripe_alloc: correct and trim the comments outside the block g
+126 S5 main ('main', 108) 629f454670c4 btrfs: stripe_alloc: count and log ordered extents that end with secto
+127 S6 main ('main', 38) 4029288b237b btrfs: stripe_meta: allocate tree blocks by whole stripes
+128 S6 part ('part', 109, 1) c3eb09937d20 btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID
+129 S6 new  ('new', 64.5) 9a8bbe5a53a5 btrfs: stripe_meta: extend stripe reclaim to metadata block groups
+130 S6 main ('main', 48) 5e84832cf6d7 btrfs: stripe_meta: maintain trapped free space for metadata groups li
+131 S6 main ('main', 49) 21008681a03a btrfs: stripe_meta: back the global reserve with usable stripes, and s
+132 S6 main ('main', 50) 9d8922921a9d btrfs: stripe_meta: hold back whole stripes so tree blocks always land
+133 S6 part ('part', 57, 2) 9f53e5f7d9c2 btrfs: stripe_alloc: count whole stripes stranded behind live runs as 
+134 S6 part ('part', 91, 1) d1e2db751d1f btrfs: stripe_alloc: keep the stripe totals consistent with the groups
+135 S6 part ('part', 110, 1) 2c4dd884e244 btrfs: stripe_alloc: count single-data-stripe groups' free space in wr
+136 S6 main ('main', 51) ff078dcd05c1 btrfs: stripe_meta: do not steal from the global reserve below the rel
+137 S6 main ('main', 52) e6507b540abb btrfs: stripe_meta: let the transaction machinery's own reservations d
+138 S6 main ('main', 53) 91a867e5ecd4 btrfs: stripe_meta: let a group go read-only for relocation against th
+139 S6 main ('main', 61) e1b4e20f900a btrfs: stripe_meta: carry raid56 metadata groups through a runtime ena
+140 S6 main ('main', 65) 3e0b6f86edd0 btrfs: stripe_meta: cover raid56 system chunks
+141 S6 main ('main', 81) a6993fd2c0d0 btrfs: stripe_alloc: give each log commit its own metadata stripe run
+142 S6 part ('part', 85, 2) bd2ec309fefa btrfs: stripe_alloc: key private stripe runs by subvolume and inode (s
+143 S6 part ('part', 83, 1) dae72bf627f1 btrfs: stripe_alloc: share LOG data runs per log transaction (stripe_m
+144 S6 main ('main', 93) d6e2e36e49a6 btrfs: stripe_meta: commit before waiting for metadata runs when makin
+145 S6 main ('main', 102) 21a343205319 btrfs: stripe_meta: check the block group lookup when freeing an unwri
+146 S6 main ('main', 104) 95f421837a6c btrfs: stripe_alloc: correct and trim the block group comments
+147 S6 main ('main', 105) 7ff54559446b btrfs: stripe_alloc: correct and trim the comments outside the block g
+148 S6 part ('part', 109, 2) 7be25fc24225 btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID
+149 S6 main ('main', 106) f9e5ad0b0a86 btrfs: stripe_meta: keep waiting for metadata runs that do not drain a
+150 S6 main ('main', 111) cacda53e79f2 btrfs: stripe_alloc: account claimable stripes while a trim has them o
+151 S6 main ('main', 112) 34d3d865ed98 btrfs: stripe_alloc: do not miss bitmap free space when debiting a tri
+152 S7 part ('part', 108, 1) a4fc2ced1e44 btrfs: stripe_alloc: count and log ordered extents that end with secto
+153 S7 main ('main', 29) 9826791e6843 btrfs: raid56: say whether a metadata read-modify-write is a write hol
+154 S7 part ('part', 30, 2) 09e7ad262b5f btrfs: stripe_alloc: tunable park deadlines, and say why padding decli
+155 S7 part ('part', 31, 1) 2f97b6fdaa48 btrfs: stripe_alloc: trace why padding declined, at the moment it decl
+156 S7 part ('part', 71, 1) 0c2a0e7ce257 btrfs: stripe_alloc: attribute each data read-modify-write to why padd
+157 S7 part ('part', 35, 1) b004256facea btrfs: raid56: adaptive park deadline from the parked-rbio backlog (de
+158 S7 part ('part', 75, 2) d0bb0c03ea09 btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has
+159 S7 part ('part', 78, 1) 1bd4941ff602 btrfs: stripe_alloc: count refused rbio pins and track rbio cache high
+160 S7 part ('part', 79, 1) 03c851891337 btrfs: stripe_alloc: sweep stale rbio pins, and commit when live pins 
+161 S7 main ('main', 55) efbe434e17a9 btrfs: stripe_alloc: tell a dead tree block from a live one in the met
+162 S7 main ('main', 94) d15887ecef71 btrfs: raid56: do not read tree blocks under the stripe lock in the me
+163 S7 part ('part', 105, 6) f4cda5e74317 btrfs: stripe_alloc: correct and trim the comments outside the block g
+164 S7 main ('main', 107) f4cfb9869a7d btrfs: stripe_alloc: remove pad refusal reasons that no longer exist
+DONE f4cfb9869a7d917772446aebc355d46571f1cac4 tree d6df042c87d47c23bfadf1bbc8ac8d5a764a32a7
diff --git a/scripts/sa-reorder/wpost-q16.json b/scripts/sa-reorder/wpost-q16.json
new file mode 100644 (file)
index 0000000..59b1729
--- /dev/null
@@ -0,0 +1,2569 @@
+[
+ {
+  "sha": "ada60a627390471187f1ed4ddd321b596f8081dc",
+  "anchor": [
+   "main",
+   1
+  ],
+  "src": 1,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "cafb9bcb65fc5d32dea16887a52f2304e9fad9f0",
+  "overlaid": false,
+  "subject": "btrfs: add btrfs_claim_free_stripe_run() for stripe-exclusive allocation",
+  "msg_changed": false
+ },
+ {
+  "sha": "dcab8cda924b6d2f7dcf95f8502d28e5ae1bb1f8",
+  "anchor": [
+   "main",
+   2
+  ],
+  "src": 2,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "ba7a11d90baa2dc4417c240e749d482d36f06ea7",
+  "overlaid": false,
+  "subject": "btrfs: add open stripe run tracking for stripe-exclusive allocation",
+  "msg_changed": false
+ },
+ {
+  "sha": "f79cc86c3f081dc3a06be3e04cd520961d6e6edf",
+  "anchor": [
+   "main",
+   3
+  ],
+  "src": 3,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "91a0d5fbb185cdca7f72a3b51235d2ec88cb61e3",
+  "overlaid": false,
+  "subject": "btrfs: add the stripe_alloc allocation policy for raid56 data",
+  "msg_changed": false
+ },
+ {
+  "sha": "4bc0a0c0a92e799ebe0e6418f1a1b5901e625dfa",
+  "anchor": [
+   "main",
+   4
+  ],
+  "src": 4,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "4160a0b745ffcc231164356a5a90e2e5c1602d88",
+  "overlaid": false,
+  "subject": "btrfs: report stripe run data IO through the ordered extent lifecycle",
+  "msg_changed": false
+ },
+ {
+  "sha": "d71b2b62a1d172b8f16530fb8507f24f53273ad5",
+  "anchor": [
+   "main",
+   5
+  ],
+  "src": 5,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "1b1019c4c78438d01fe1883450c205f9ca8da751",
+  "overlaid": false,
+  "subject": "btrfs: retire stripe runs at commit and gate stripe_alloc",
+  "msg_changed": true
+ },
+ {
+  "sha": "b9e5e0f6e6848b29badb6e055323aa748cbc7299",
+  "anchor": [
+   "main",
+   7
+  ],
+  "src": 7,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "e3d3fff7c4d31dcf5c69cf95bbed9e7c78ffcd42",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: refuse space_cache=v1",
+  "msg_changed": false
+ },
+ {
+  "sha": "1781c75b6b08b75ac13abccd764c0da3350b2155",
+  "anchor": [
+   "main",
+   8
+  ],
+  "src": 8,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "7525e3a5ca48c6c03c60e0d7908a5f2cbca7f2fc",
+  "overlaid": false,
+  "subject": "btrfs: account stripe_alloc trapped free space for honest statfs",
+  "msg_changed": false
+ },
+ {
+  "sha": "967931b23029885a4335718034af215b92869fe2",
+  "anchor": [
+   "main",
+   9
+  ],
+  "src": 9,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "a0765de28eb29cf1254895e4b972be08085740c0",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: keep an open run per size band to trap less",
+  "msg_changed": false
+ },
+ {
+  "sha": "b893f6f7db92c98176e7d125bb86aca7f65dc08f",
+  "anchor": [
+   "main",
+   10
+  ],
+  "src": 10,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "fb82fd869c7579369500e0bdd8a33c72d5cc5003",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: grow the frontier run instead of stranding its tail",
+  "msg_changed": false
+ },
+ {
+  "sha": "d53cb5cfc036795a6402064a4b8d6ce7b79f4cef",
+  "anchor": [
+   "main",
+   11
+  ],
+  "src": 11,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "2283f041d5b6508e9b75c2594c10b08734ace0fa",
+  "overlaid": false,
+  "subject": "btrfs: raid56: batch stripe_alloc partial writes into full-stripe writes",
+  "msg_changed": false
+ },
+ {
+  "sha": "24aa9de0044aa3f97dc7b32b040ef56248334fe3",
+  "anchor": [
+   "main",
+   12
+  ],
+  "src": 12,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "e69804de43b0235cebc7d7268bad2495790a73b9",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: never claim stripes covered by a live run",
+  "msg_changed": false
+ },
+ {
+  "sha": "816b89bb38153296e4a47dd222ef89f6abff7d7b",
+  "anchor": [
+   "main",
+   13
+  ],
+  "src": 13,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "dc3b2bfc9def12f33088b054bd12f0c5ee496daa",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: control the policy with a filesystem property",
+  "msg_changed": true
+ },
+ {
+  "sha": "6d4b4d3576a53d5960c88a61e7aaf7ed53305632",
+  "anchor": [
+   "main",
+   15
+  ],
+  "src": 15,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "ab73e027d08b946b7268b7ef13ed037710a97472",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: private per-inode stripe runs for log-active inodes",
+  "msg_changed": false
+ },
+ {
+  "sha": "dfc913859ddd35eabae345808028af9952721c1d",
+  "anchor": [
+   "main",
+   18
+  ],
+  "src": 18,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "ca493ee0f5147f6a99463d0be2a607b31d410ea8",
+  "overlaid": false,
+  "subject": "btrfs: raid56: pad sub-stripe writes to full stripes in open runs",
+  "msg_changed": false
+ },
+ {
+  "sha": "dd8324a8031092c0afc4928f5b08cc9db5eb589c",
+  "anchor": [
+   "main",
+   23
+  ],
+  "src": 23,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "8d8e5ea402920de13a662a64152bded7d0080f24",
+  "overlaid": false,
+  "subject": "btrfs: raid56: expose parking statistics in sysfs",
+  "msg_changed": false
+ },
+ {
+  "sha": "a560c15dbf07cce07db7e5e2d812812c8336a913",
+  "anchor": [
+   "main",
+   24
+  ],
+  "src": 24,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "7983e5f8f2643e78277c9d8651ea9887f31e9c44",
+  "overlaid": false,
+  "subject": "btrfs: raid56: skip parking for sync rbios finished by their unplug batch",
+  "msg_changed": false
+ },
+ {
+  "sha": "21d2fcf334218204c2fd1534d422083bbcc8225c",
+  "anchor": [
+   "main",
+   25
+  ],
+  "src": 25,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "3f52774611e7e0af68b5047da4f7a5dc105d368a",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations",
+  "msg_changed": false
+ },
+ {
+  "sha": "bd3340c9ce362991a4aa00cd88ea84dae573b525",
+  "anchor": [
+   "main",
+   26
+  ],
+  "src": 26,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "911bf629005ddb088c3782014c2a2b3cbb077ac3",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: pessimistic data reservation margin",
+  "msg_changed": false
+ },
+ {
+  "sha": "43fbad5b603350f4dfae45a0573346fac27d5e16",
+  "anchor": [
+   "main",
+   27
+  ],
+  "src": 27,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "a3a8aed553c6948a1cd5f0c449a7fd84265cc764",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: claim fully-free stripes that span free space entries",
+  "msg_changed": false
+ },
+ {
+  "sha": "675d0aba5573f1fbca3c1ec3c94878a37415900a",
+  "anchor": [
+   "main",
+   28
+  ],
+  "src": 28,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "46798a53a5a3f22d5f4cbee0817c251599dc9855",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: warn at mount when raid56 metadata is not covered",
+  "msg_changed": false
+ },
+ {
+  "sha": "e31591623bf17b4ee87c346ffe38a9f1ba4bac08",
+  "anchor": [
+   "main",
+   29
+  ],
+  "src": 29,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "e591400a1f0913fa4039070d2a81685bab2e3220",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: report read-modify-write of uncovered stripes",
+  "msg_changed": true
+ },
+ {
+  "sha": "a91464ecfd91212e2279013622b692e6d2aefeae",
+  "anchor": [
+   "main",
+   31
+  ],
+  "src": 31,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "bb27525adb1e9727ee0ac1652b39fcd8af973444",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined",
+  "msg_changed": false
+ },
+ {
+  "sha": "fc40c45f34a1af2016f53fb11ca455754959516b",
+  "anchor": [
+   "main",
+   32
+  ],
+  "src": 32,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "d3c47d97b3a962f9cdcba61bb5679b262f889cd5",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: trace why padding declined, at the moment it declined",
+  "msg_changed": false
+ },
+ {
+  "sha": "edd2f7bd5f7b34cb4504a7434b4e36d6f7d62f6f",
+  "anchor": [
+   "main",
+   33
+  ],
+  "src": 33,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "afbabf7c96bc741466ae2bc1c8cde2b2dab701ca",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: complete parked writes on allocation coverage, not clocks",
+  "msg_changed": false
+ },
+ {
+  "sha": "40675503699b2b90c4c70126b69805273e02be13",
+  "anchor": [
+   "main",
+   34
+  ],
+  "src": 34,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "2c937f1f391d684c1a61899ff8003d85271fcc4d",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: track per-sector liveness and pad from the map",
+  "msg_changed": false
+ },
+ {
+  "sha": "cc21c95cc4d65a1211e386f7974c5f7be8d858c7",
+  "anchor": [
+   "main",
+   35
+  ],
+  "src": 35,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "990b38d1c56372cf7f1ce57bd6307daf77a8fbdb",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: count claimable whole-stripe supply directly",
+  "msg_changed": false
+ },
+ {
+  "sha": "6283243b97ca7e2ea48cb4f1061eff1404919927",
+  "anchor": [
+   "main",
+   36
+  ],
+  "src": 36,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "1b651efb421f47ee90c33b872e3f120f339d8c2a",
+  "overlaid": false,
+  "subject": "btrfs: raid56: adaptive park deadline from the parked-rbio backlog",
+  "msg_changed": false
+ },
+ {
+  "sha": "86bffb89916bb3e2734dc93ef33f3f944b59bc67",
+  "anchor": [
+   "main",
+   37
+  ],
+  "src": 37,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "64cca995f34997d5389c3a910aa6c742e2b1c7eb",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: gate data admission on claimable whole-stripe supply",
+  "msg_changed": false
+ },
+ {
+  "sha": "f61792b3be35340bb71c248b1efb649ffc16f633",
+  "anchor": [
+   "main",
+   38
+  ],
+  "src": 38,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "687e7bd37eac6fc2496005699a8b24d4023fd174",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: cache a failed stripe run scan per block group",
+  "msg_changed": false
+ },
+ {
+  "sha": "a5756e4f442eec71bf964029e1b04970a4d4257a",
+  "anchor": [
+   "main",
+   41
+  ],
+  "src": 41,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "03a9e494ed6b8e5c867666ec408f229aa6f4ba8e",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: do not count trapped free space twice when making a block group read-only",
+  "msg_changed": false
+ },
+ {
+  "sha": "b178c2a51cc889b083de1ff7f9f99792f883544e",
+  "anchor": [
+   "main",
+   42
+  ],
+  "src": 42,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "7800828b9bc108a8fdf80c8e88b3c2178ba1425e",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: keep the admitted bytes placeable when a group goes read-only",
+  "msg_changed": false
+ },
+ {
+  "sha": "1b88dcaba4f708be4f081dfdbd15c47b53c51da2",
+  "anchor": [
+   "main",
+   43
+  ],
+  "src": 43,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "defefff7ee88728c7b7c29f0652a1a6d884ec7a2",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: never let relocation wait on the whole-stripe gate",
+  "msg_changed": false
+ },
+ {
+  "sha": "be4eb11ad365aa902c468736aad6149b0b6bae59",
+  "anchor": [
+   "main",
+   45
+  ],
+  "src": 45,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "15aa910f27b667b6279285a595fc67461060a420",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: charge relocation a margin per reservation, not per extent",
+  "msg_changed": false
+ },
+ {
+  "sha": "80e338dfa737a9db3c7ff5eb4ad1bf0c0a35fa4c",
+  "anchor": [
+   "main",
+   46
+  ],
+  "src": 46,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "e85b96f90afaeff8e3a84875835a116dbb8776f9",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: keep the relocation group's stripes out of the admission supply",
+  "msg_changed": false
+ },
+ {
+  "sha": "4bc52680eb37ff6e1c3e574d59b8b2258efd1320",
+  "anchor": [
+   "main",
+   47
+  ],
+  "src": 47,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "eb77ce16eadde89f1b8bd3e89dc258f02968731e",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: let a data write fall back to the relocation group rather than drop",
+  "msg_changed": false
+ },
+ {
+  "sha": "ce655565941251191dd8ab65d8163c1ec52e58ce",
+  "anchor": [
+   "main",
+   56
+  ],
+  "src": 56,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "3a148f81c3e3c3bef863404ed0ba95e9a09820f5",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: show per-group trapped bytes in the space info dump",
+  "msg_changed": false
+ },
+ {
+  "sha": "9b85bbd704a145d1453d3419bcc876d364cc32e6",
+  "anchor": [
+   "main",
+   59
+  ],
+  "src": 59,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "c75b6d1856bfdb51ff253edf36978b1da649bff1",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped",
+  "msg_changed": false
+ },
+ {
+  "sha": "7420e832875545099df69c4fcc147b8cbf66a124",
+  "anchor": [
+   "main",
+   61
+  ],
+  "src": 61,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "4c46b6c5201a94a9c2e2c5766678e8252ed2a5a1",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: count nocow run lifecycles and stranded stripes in sysfs",
+  "msg_changed": false
+ },
+ {
+  "sha": "db32c3e1b42fbd330a394fa3280435c03d2a4d94",
+  "anchor": [
+   "main",
+   62
+  ],
+  "src": 62,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "f15601fb56230fb044331e99f32f26b98e302e78",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: charge the held stripe margin against every admission",
+  "msg_changed": false
+ },
+ {
+  "sha": "d676483512c139a22f90fa930fe680c5a38388a3",
+  "anchor": [
+   "main",
+   63
+  ],
+  "src": 63,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "1ab2fc220fd73fca457ed69f0c03e8c0dcae59e6",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: admit data reservations by whole stripes",
+  "msg_changed": false
+ },
+ {
+  "sha": "ef4ebd4161058e808d0f1a29a8fa2fbd72ec1795",
+  "anchor": [
+   "main",
+   64
+  ],
+  "src": 64,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "4d52e2f4f0c2b2ee429bc1f185e6fa0420d82592",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: hold a stripe of margin across a preallocation",
+  "msg_changed": false
+ },
+ {
+  "sha": "f84bc71fcd075bb8464c500a49559ad2d1815ab8",
+  "anchor": [
+   "main",
+   65
+  ],
+  "src": 65,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "687b299965f5e81ff3f661c297e35ca694a02ce0",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: hold the probe margin until the metadata reservation charges it",
+  "msg_changed": false
+ },
+ {
+  "sha": "cfd4c7939a42c55b15b33cef1400a41cd2016488",
+  "anchor": [
+   "main",
+   66
+  ],
+  "src": 66,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "6546aafc69ef0e389d769431ecbd92785c82d2b4",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: saturate the read-only guard's claimable subtraction",
+  "msg_changed": false
+ },
+ {
+  "sha": "af432a1ad7379d9ed1b3cdb22ed311dcc19a4316",
+  "anchor": [
+   "main",
+   68
+  ],
+  "src": 68,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "7e9bbfd68e2cee76ff137dd626c2183ca1de0fe3",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: charge the preallocation's stripe hold under the reservation lock",
+  "msg_changed": false
+ },
+ {
+  "sha": "611995c7446a8106a13bf23ee467bfca33ca9b3d",
+  "anchor": [
+   "main",
+   69
+  ],
+  "src": 69,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "a223554eb2b013f175e3326fe16956f0ed2664f6",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: return a group's allocation cluster before scanning its stripes",
+  "msg_changed": false
+ },
+ {
+  "sha": "94941a7665a84a25ca4565a34dd7678ceddee7e4",
+  "anchor": [
+   "main",
+   72
+  ],
+  "src": 72,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "230ac02c2f2abbe00c1b80b7e87dbf09968c7fef",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: release open stripe runs when a mount fails or an aborted filesystem unmounts",
+  "msg_changed": false
+ },
+ {
+  "sha": "659efaa577cb5e7b0cab7d633511a49c4a70673a",
+  "anchor": [
+   "main",
+   73
+  ],
+  "src": 73,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "9432e750bc459ec02401e759ff8b41252b89930e",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: let the property accept a cache-less filesystem like the mount option does",
+  "msg_changed": false
+ },
+ {
+  "sha": "0fa169926545259188f5c08a028bb8c37411fb43",
+  "anchor": [
+   "main",
+   74
+  ],
+  "src": 74,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "4ad4ecf6fc6075562bd7c2205424160aaf663e2a",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: say at mount whether the policy is on",
+  "msg_changed": false
+ },
+ {
+  "sha": "886e5380230b680c6b144ae5bd804fd05871a5a2",
+  "anchor": [
+   "main",
+   75
+  ],
+  "src": 75,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "8c8da935331192124d21b3a23df7d763e39496bc",
+  "overlaid": false,
+  "subject": "btrfs: stripe_alloc: hold a reference on the rbio being parked",
+  "msg_changed": false
+ },
+ {
+  "sha": "0c1f0732d028ad86a012c85eaacd65d405e9f372",
+  "anchor": [
+   "main",
+   76
+  ],
+  "src": 76,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "df7ad260cf1b9869fe2d2af0867919a216056074",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: drop the mount options, the property is the interface",
+  "msg_changed": true
+ },
+ {
+  "sha": "b6f85e21c45c2416c008f36c509f35a1a84aa9ed",
+  "anchor": [
+   "main",
+   80
+  ],
+  "src": 80,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "b8acca738af499ba268c06ca70463af917726222",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not wait for stripe runs to drain on an errored filesystem",
+  "msg_changed": false
+ },
+ {
+  "sha": "8de5c2c5c83cc68f000f00d17ee2759d998d6557",
+  "anchor": [
+   "main",
+   81
+  ],
+  "src": 81,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "611b1c2553df2304957896a7cafe30af1cc821ac",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: end the commit-time and log drains on an errored filesystem too",
+  "msg_changed": false
+ },
+ {
+  "sha": "599e32fcc943ec9ea3fe0f6db3e00b1121ee3834",
+  "anchor": [
+   "main",
+   88
+  ],
+  "src": 88,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "88a005364239f102f644caa8b04b79eb892e3d25",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: keep relocation's stripe runs until relocation ends",
+  "msg_changed": false
+ },
+ {
+  "sha": "b6e38dc9ec9d0ab9ca4f9fad8f35a76366392c5d",
+  "anchor": [
+   "main",
+   89
+  ],
+  "src": 89,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "e21e94c1968e5ee0376be88b1aafac31fda7b228",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: let relocation allocate a data chunk before it fails",
+  "msg_changed": false
+ },
+ {
+  "sha": "e6e606760c9db1c9ca6494ac5b4794f0d3143bf8",
+  "anchor": [
+   "main",
+   90
+  ],
+  "src": 90,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "87291ad42095270a38ef54643d66afd278c4126c",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it",
+  "msg_changed": false
+ },
+ {
+  "sha": "6f6dd994cc64c25313b54478c75f80e63a472e08",
+  "anchor": [
+   "main",
+   91
+  ],
+  "src": 91,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "9fc0ea54c25528cd34f8fa6c8df2758ddb2dac20",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: pad a stripe's allocated sectors whose write is still to come",
+  "msg_changed": false
+ },
+ {
+  "sha": "6c894897959bc752819fbe6e06fa0fb8376878b0",
+  "anchor": [
+   "main",
+   92
+  ],
+  "src": 92,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "3f7ae53bc4a000bfb6dd2fd59325bd75c433e236",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: apply the property before tree-log replay",
+  "msg_changed": false
+ },
+ {
+  "sha": "b0666acbe47338d6825e84269b364cd8447adf74",
+  "anchor": [
+   "main",
+   93
+  ],
+  "src": 93,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "ab13c3242038bbcb7b5ce1e90b864577984d89c1",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count refused rbio pins and track rbio cache high water",
+  "msg_changed": false
+ },
+ {
+  "sha": "16906917d4bb5d15a9064186a008b5bd5869b5b5",
+  "anchor": [
+   "main",
+   94
+  ],
+  "src": 94,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "01c8b3a5af0c0ae671931f1cb3194486160cd823",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: sweep stale rbio pins, and commit when live pins run low",
+  "msg_changed": false
+ },
+ {
+  "sha": "ce05cc820d4d5b3a953b6c6598f814ade67ef403",
+  "anchor": [
+   "main",
+   97
+  ],
+  "src": 97,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "edcc40fffc4887d3236542d5d77123bc1a2e8bae",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: don't make a parked rbio wait for sectors that will never be written",
+  "msg_changed": false
+ },
+ {
+  "sha": "5be7c29739a22392cfc71568059d1652c2eb5259",
+  "anchor": [
+   "main",
+   99
+  ],
+  "src": 99,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "b68eaf63639cc5f3883431ecf22316fde935ab58",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: let relocation allocate as many data chunks as its reservation needs",
+  "msg_changed": false
+ },
+ {
+  "sha": "433b2b875c456cf5dcaf6159cf94a07ff33f54df",
+  "anchor": [
+   "main",
+   101
+  ],
+  "src": 101,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "2401451d4be7453a4df7ac25bdbee26c441c0e0c",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not treat an allocation error as a found extent",
+  "msg_changed": false
+ },
+ {
+  "sha": "8d1347b94d2b01e1e4fe0d1b2c2d2dab0510f1f1",
+  "anchor": [
+   "main",
+   102
+  ],
+  "src": 102,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "cacb873d82601f061d9eda0800d2d7b93629599e",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: mark an ended ordered extent's sectors written",
+  "msg_changed": false
+ },
+ {
+  "sha": "e2228f87bd379096b80db5a013d7fc8ce470af98",
+  "anchor": [
+   "main",
+   104
+  ],
+  "src": 104,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "61ff93a92f4bfce1cf8ac966f39916e256fd48ba",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: remove only the set bits of a bitmap when claiming a split run",
+  "msg_changed": false
+ },
+ {
+  "sha": "6c81b4b8423cc8cc28a2a36cc54927461753b68c",
+  "anchor": [
+   "main",
+   106
+  ],
+  "src": 106,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "3333de9bd3bc077eba130d115efe02315494427b",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: keep the stripe totals consistent with the groups during the commit scan",
+  "msg_changed": false
+ },
+ {
+  "sha": "6d7c7f5cb424f79805b9e29dd3e745e405407286",
+  "anchor": [
+   "main",
+   107
+  ],
+  "src": 107,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "3ee585a55b32b2265aa7b4640fe69f6c1b6c3397",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not delete an unused block group that still has stripe runs",
+  "msg_changed": false
+ },
+ {
+  "sha": "4a78714773d5368ae3b046e82a292b71ecd8dd7f",
+  "anchor": [
+   "main",
+   110
+  ],
+  "src": 110,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "b9e5c4eeface0db893e935fa0a1c7ca086e8b710",
+  "overlaid": true,
+  "subject": "btrfs: raid56: stop the park timer before destroying the raid56 workqueue",
+  "msg_changed": false
+ },
+ {
+  "sha": "da8d0c8feb457528efbcff676c46b41572be7b6e",
+  "anchor": [
+   "main",
+   111
+  ],
+  "src": 111,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "c1f37b0ffc5f015c33781ae0c3f2cc574c75c5a1",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: order the filesystem error before waking stripe drain waiters",
+  "msg_changed": false
+ },
+ {
+  "sha": "8a90278a8f828b33688066399520680cbbddf545",
+  "anchor": [
+   "main",
+   112
+  ],
+  "src": 112,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "1827827be4fbde53597752b8c43a433a74e559e8",
+  "overlaid": true,
+  "subject": "btrfs: raid56: set a padded rbio's data bitmap under bio_list_lock",
+  "msg_changed": false
+ },
+ {
+  "sha": "e4a7c166bbdfaabf83b1423b099ba377cc881164",
+  "anchor": [
+   "main",
+   113
+  ],
+  "src": 113,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "a83bd479062f90c2cc7b8e8fa46c34b17fce1fb4",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: forget the failed-claim verdict when a cluster returns its space",
+  "msg_changed": false
+ },
+ {
+  "sha": "581ceac7e4201f86848d52f0dad80b12b1a27acd",
+  "anchor": [
+   "main",
+   114
+  ],
+  "src": 114,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "5a93a979d6a732b29d507a2c7fdcefec4db7bb10",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not let a remount revert the stripe_alloc property",
+  "msg_changed": false
+ },
+ {
+  "sha": "2f36bb4dd308bb11c5d5fb12a972bc9e95efa0d6",
+  "anchor": [
+   "main",
+   116
+  ],
+  "src": 116,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "16933b1c39893ca3b7739bc13e61e1801461efce",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: keep the head of a claimed free space entry under the lock",
+  "msg_changed": false
+ },
+ {
+  "sha": "4af3107e0ce54333a19165cd87e33a21eb62bc51",
+  "anchor": [
+   "part",
+   119,
+   1
+  ],
+  "src": 119,
+  "kind": "part",
+  "sub": 1,
+  "eng_sha": "16f62afbbf3358dbea5b6bf98597cbe67d0080d1",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (base part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "23dba7b2f3679c6e7f02f7253dd3ef16f13b6941",
+  "anchor": [
+   "part",
+   120,
+   1
+  ],
+  "src": 120,
+  "kind": "part",
+  "sub": 1,
+  "eng_sha": "b92a80103ca4922b691bbc4de102f7dfb4a3a12e",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (base part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "3a7c9c7fc912249f772494b475af716a1f028d85",
+  "anchor": [
+   "main",
+   124
+  ],
+  "src": 124,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "df6a11be2683138509ae8208440a288fff80f28a",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3",
+  "msg_changed": false
+ },
+ {
+  "sha": "613817ed6569990bc3b07630acf5344bc3dd7339",
+  "anchor": [
+   "main",
+   125
+  ],
+  "src": 125,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "46bbf0fdc6837b42d565c4b9f01e338243746b43",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count single-data-stripe groups' free space in write admission",
+  "msg_changed": false
+ },
+ {
+  "sha": "dce806a394277130eac5c91a40cc8710d75c575e",
+  "anchor": [
+   "main",
+   127
+  ],
+  "src": 127,
+  "kind": "main",
+  "sub": 1,
+  "eng_sha": "43d66fd16683571ec27d4feadcd58b023b4317e1",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not refuse leftover v1 space cache inodes",
+  "msg_changed": false
+ },
+ {
+  "sha": "39c81aec088dabeb2108e41a3657b23a9c2847f3",
+  "anchor": [
+   "main",
+   19
+  ],
+  "src": 19,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "c49b36ab01bc217bf8730be09f5b731a567e2138",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: isolate nodatacow and preallocated extents by stripe",
+  "msg_changed": false
+ },
+ {
+  "sha": "b203727655ae709c33305bf0bc1cc2b82971899f",
+  "anchor": [
+   "part",
+   61,
+   1
+  ],
+  "src": 61,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "85dabd17a9f81880ef6084e252b949cf0b35864c",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count nocow run lifecycles and stranded stripes in sysfs (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "977fef16d1280596854c2e89c58633bd39b398a0",
+  "anchor": [
+   "part",
+   90,
+   1
+  ],
+  "src": 90,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "cac5a94a07b07515b6498f7773e5c3a5efb34525",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "467ad0cd9de55cc5f2d244d8d2aa56c1dec6aea4",
+  "anchor": [
+   "part",
+   91,
+   1
+  ],
+  "src": 91,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "46af137e99fa02859b2121e7f8980405990d0327",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: pad a stripe's allocated sectors whose write is still to come (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "822a3b83afca42bb329da51563cb896d099790a0",
+  "anchor": [
+   "main",
+   20
+  ],
+  "src": 20,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "07f323bc6dec8e72e03c14d609f6086528b2b2f6",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents",
+  "msg_changed": false
+ },
+ {
+  "sha": "70c6aec4b82cfc8a70e9f83a7a34123ca46add20",
+  "anchor": [
+   "part",
+   34,
+   1
+  ],
+  "src": 34,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "4770c743fd169290e427f6caf1b6cabea6d54a7d",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: track per-sector liveness and pad from the map (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "9b1006cb4e4ebdc3889529b1ec83a0defc819521",
+  "anchor": [
+   "part",
+   119,
+   2
+  ],
+  "src": 119,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "b8b2b290cae3491800e8985822fb7504363fd79a",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "eeff67cc09d4707cba523098bc1e7e1f14a81b85",
+  "anchor": [
+   "part",
+   76,
+   1
+  ],
+  "src": 76,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "5f39d581705aa54e9d8750fa63c95ddc52c349a9",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: drop the mount options, the property is the interface (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "110d14d02b8ccb49c04286d0cc80142201555579",
+  "anchor": [
+   "main",
+   79
+  ],
+  "src": 79,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "d9ebc6c0147fa78ba661442429f3a4a8155219a7",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros",
+  "msg_changed": false
+ },
+ {
+  "sha": "c367fdbdb7810f2d2182ea89cd3bf8428687253c",
+  "anchor": [
+   "part",
+   119,
+   3
+  ],
+  "src": 119,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "89ad0bfd76765aa8ac2736cca42f23b4bb47664e",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part 2)",
+  "msg_changed": false
+ },
+ {
+  "sha": "59f65c17111e7a43dd3ef1da17f5cfaae5b2692c",
+  "anchor": [
+   "main",
+   21
+  ],
+  "src": 21,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "c8412f42f542edd3d1cc56bc1018cad9609dbd7c",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: persist nocow runs across commits and remounts",
+  "msg_changed": false
+ },
+ {
+  "sha": "77db22426a4a81f90be4fbbbbd35a093e2d76307",
+  "anchor": [
+   "part",
+   25,
+   1
+  ],
+  "src": 25,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "6f6ee679355d89a5800b48b9c84595eb34e13f06",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "bd0e7389455c68073ef722510ac65208c1405f14",
+  "anchor": [
+   "part",
+   79,
+   1
+  ],
+  "src": 79,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "394e8dc4c7ff4c69c8e980e6a1b490eabbb5f13d",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros (allow_rmw part 2)",
+  "msg_changed": false
+ },
+ {
+  "sha": "3ea5f57b840076662416d404dafb469e8f81e0bf",
+  "anchor": [
+   "main",
+   22
+  ],
+  "src": 22,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "a1adaaac8a70c3020ac694b5a44ddcf030c9f838",
+  "overlaid": true,
+  "subject": "btrfs: raid56: do not park sync writes into nocow runs",
+  "msg_changed": false
+ },
+ {
+  "sha": "225f941b05be236917258a6a1a78014a0171cf6e",
+  "anchor": [
+   "part",
+   31,
+   1
+  ],
+  "src": 31,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "a843abd337fbf769fc45c1136727af5e3cc56cc4",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "474d8c02b35f0718efcd503d5d5f969849b2e693",
+  "anchor": [
+   "main",
+   58
+  ],
+  "src": 58,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "0d19ad88e9d2cc6cc67dd38ce2c8694c2ac2727b",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not read an inline backref off a keyed-ref extent item",
+  "msg_changed": false
+ },
+ {
+  "sha": "9acc5e4d9817a3a0353b8d9c98b26bed2a277a4a",
+  "anchor": [
+   "main",
+   60
+  ],
+  "src": 60,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "199420a36f15a7462dae881e2645382d015967ce",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: give nocow extents a private run only while they may be written in place",
+  "msg_changed": false
+ },
+ {
+  "sha": "47bca69dd077ec98f8bbcffafe02395f40277ece",
+  "anchor": [
+   "main",
+   78
+  ],
+  "src": 78,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "0ab77c218666df626230960441f9d8362acf16f0",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: close dead nocow stripe runs at commit",
+  "msg_changed": false
+ },
+ {
+  "sha": "95acd425f55c93f14f361e34cb9923e82da0c422",
+  "anchor": [
+   "main",
+   100
+  ],
+  "src": 100,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "48c6ab8c7c5d655dcfd613027fc1b8187f0ba60a",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode",
+  "msg_changed": false
+ },
+ {
+  "sha": "0c7ae8213eb9a436cabbb44bf0c649f226e0e994",
+  "anchor": [
+   "main",
+   105
+  ],
+  "src": 105,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "840af84d36fbf6033be3888563598aa8dc1617e8",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: claim a stripe tail in one free space lock section",
+  "msg_changed": false
+ },
+ {
+  "sha": "603726d9cd66a784aa3419cbf1989b62ccd7f3da",
+  "anchor": [
+   "main",
+   115
+  ],
+  "src": 115,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "1507483df45704c702d3e8df0f6fd7775f8da0da",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not block a NOWAIT write in the nocow stripe check",
+  "msg_changed": false
+ },
+ {
+  "sha": "75e0b51107cb1374c113e6c25b93e749c7812165",
+  "anchor": [
+   "main",
+   118
+  ],
+  "src": 118,
+  "kind": "main",
+  "sub": 2,
+  "eng_sha": "ecfb2b365bf992b76b0f3f9e78c963e3e49041d8",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: remove the unused stripe_rmw_opt field",
+  "msg_changed": false
+ },
+ {
+  "sha": "3c099882de7fc417394260fe872deac33d2d0263",
+  "anchor": [
+   "part",
+   119,
+   4
+  ],
+  "src": 119,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "0b09a9d421f3753e867447929887afdf66f9a08e",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part 3)",
+  "msg_changed": false
+ },
+ {
+  "sha": "494c81b90d4e98a399b1107378c42088f853d034",
+  "anchor": [
+   "part",
+   120,
+   2
+  ],
+  "src": 120,
+  "kind": "part",
+  "sub": 2,
+  "eng_sha": "c7c60d5e1983a6c11f9d997b5c4c51cccd2ab878",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (allow_rmw part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "8c8cc8bd77eb66707765d56fd2f64844410c6c2a",
+  "anchor": [
+   "main",
+   44
+  ],
+  "src": 44,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "535dc594db94935074674cdb4691137019f0356e",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: give a queued stripe group a chunk to relocate into when the supply is short",
+  "msg_changed": true
+ },
+ {
+  "sha": "7de4102a4d8f9871aa3fe23f6e1b5653fcb15dad",
+  "anchor": [
+   "main",
+   48
+  ],
+  "src": 48,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "fa0871abcca9f022b7c0f594dc057d277affc541",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: hand groups full of trapped free space to the reclaim worker",
+  "msg_changed": true
+ },
+ {
+  "sha": "bf1cd446c46ba34f0cb0553a6685209f2ee5add1",
+  "anchor": [
+   "part",
+   59,
+   1
+  ],
+  "src": 59,
+  "kind": "part",
+  "sub": 3,
+  "eng_sha": "ec72f899fa5a7477a4c277a7604b7bbbe80ceeae",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped (reclaim part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "21a842d9fe11240e13e8f4dd043a63840a7b990b",
+  "anchor": [
+   "main",
+   49
+  ],
+  "src": 49,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "c5772a3c2b5548f0c9dab698a39d8a9170d97ac7",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: relocate a queued stripe group even while it has reserved or pinned bytes",
+  "msg_changed": true
+ },
+ {
+  "sha": "6f9e455136fc6e0fccb064a722294871fc23e142",
+  "anchor": [
+   "main",
+   84
+  ],
+  "src": 84,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "a8c0236ab2d7053cdec1fd2d84a1ddccab244543",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: compact mostly live groups instead of skipping them",
+  "msg_changed": true
+ },
+ {
+  "sha": "bf91f0d4a1387af0fd99373c66dff8ed1dea56c4",
+  "anchor": [
+   "part",
+   88,
+   1
+  ],
+  "src": 88,
+  "kind": "part",
+  "sub": 3,
+  "eng_sha": "400467f937bfbd3cc2c22782b65b1cb161308c1d",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: keep relocation's stripe runs until relocation ends (reclaim part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "e4a60a3ec5b3b93b7fdcb7946e3f741fdd9ee058",
+  "anchor": [
+   "main",
+   85
+  ],
+  "src": 85,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "976cd78b55bc2d866e39b5c163fc47f63ab3ac25",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: compact a mostly live group by its trapped share of the group",
+  "msg_changed": false
+ },
+ {
+  "sha": "122c58c3e5ff479d99ebe807f2732bfcf6e71f9d",
+  "anchor": [
+   "part",
+   120,
+   3
+  ],
+  "src": 120,
+  "kind": "part",
+  "sub": 3,
+  "eng_sha": "44a7ddcf7f8c1abf2e70a835bdb38b59b8499191",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (reclaim part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "7acf0f28e9bc1eceb5cb52935892dfdaca8b5f99",
+  "anchor": [
+   "main",
+   129
+  ],
+  "src": 129,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "6ef83b6a827f7a836d318f5507ccc9d2b0185805",
+  "overlaid": true,
+  "subject": "btrfs: log block group reclaim at debug level",
+  "msg_changed": false
+ },
+ {
+  "sha": "d5115b2e98c108af035f98dcc310c08c72cba028",
+  "anchor": [
+   "main",
+   130
+  ],
+  "src": 130,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "1024a01c2571edb690fa362f62dca974b40f5d5d",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: add stripe_reclaim_now to reclaim stripes on demand",
+  "msg_changed": true
+ },
+ {
+  "sha": "19ad662c33dcf1d86d53bb16e20bb4e7f534f8bc",
+  "anchor": [
+   "main",
+   131
+  ],
+  "src": 131,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "8c2a02d1d937a3f094dfccf546f7c1c2dc60cb0f",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: back off block group reclaim after repeated ENOSPC",
+  "msg_changed": false
+ },
+ {
+  "sha": "2d2d7926b5ebb9e80fa3fc5ac388acf4dd6de1e0",
+  "anchor": [
+   "main",
+   132
+  ],
+  "src": 132,
+  "kind": "main",
+  "sub": 3,
+  "eng_sha": "5534996f541c55cb5a3b114888b8e08edf374464",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: let queued exclusive operations in between reclaims",
+  "msg_changed": false
+ },
+ {
+  "sha": "375a0fdd6e05fdfe9c09d665434d2c7abc185b73",
+  "anchor": [
+   "main",
+   14
+  ],
+  "src": 14,
+  "kind": "main",
+  "sub": 4,
+  "eng_sha": "4c272644f4706cb873d042e258249d9e86598d66",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: settle a logged extent's stripes at log commit",
+  "msg_changed": true
+ },
+ {
+  "sha": "a0ab721d623e76e74317a1b40ff75200db66fbc7",
+  "anchor": [
+   "part",
+   25,
+   2
+  ],
+  "src": 25,
+  "kind": "part",
+  "sub": 4,
+  "eng_sha": "8214af6628d31c964a1a3443251f1935de3edcc4",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations (fsync part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "b80eeb9816d3f3c9127da0ced570fda65bfc2131",
+  "anchor": [
+   "part",
+   81,
+   1
+  ],
+  "src": 81,
+  "kind": "part",
+  "sub": 4,
+  "eng_sha": "21b5abc1f5dde23b6581a505aa14f93156e59627",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: end the commit-time and log drains on an errored filesystem too (fsync part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "3c76c61a7ad1a1972dbf7b0850f068cc0aeac4fc",
+  "anchor": [
+   "part",
+   20,
+   1
+  ],
+  "src": 20,
+  "kind": "part",
+  "sub": 4,
+  "eng_sha": "c69b11b80b2c3bfee9e5045259bc8b74ae5ee65d",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (fsync part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "1e235415b1eb9e3ca262259f2cfb3167aae47fb4",
+  "anchor": [
+   "main",
+   16
+  ],
+  "src": 16,
+  "kind": "main",
+  "sub": 4,
+  "eng_sha": "b88d9ffce79aa54f33a4862d120eb1764e1f62a3",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: carry an inode's log tail forward at fsync",
+  "msg_changed": false
+ },
+ {
+  "sha": "9a5f0708dd31a3b37a53da8e6a87c63f0c5eb5c6",
+  "anchor": [
+   "part",
+   79,
+   2
+  ],
+  "src": 79,
+  "kind": "part",
+  "sub": 4,
+  "eng_sha": "9fd4f251fece52ad239b9d525a73522b002685c0",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros (fsync part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "9e4f9baa6964acd44f59d694d41dbc4bb14e479e",
+  "anchor": [
+   "part",
+   20,
+   2
+  ],
+  "src": 20,
+  "kind": "part",
+  "sub": 4,
+  "eng_sha": "279c4f3e8b140e6154a4f0312301e38be8b687f7",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (fsync part 2)",
+  "msg_changed": false
+ },
+ {
+  "sha": "979598fbe1cf6f466ef5ec63ada06527dc74f8fd",
+  "anchor": [
+   "main",
+   17
+  ],
+  "src": 17,
+  "kind": "main",
+  "sub": 4,
+  "eng_sha": "2cf66d0889ae9d509b0717e38589aada3ac8c5f3",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: kick parked rbios before the fast fsync's writeback wait",
+  "msg_changed": false
+ },
+ {
+  "sha": "0289d6def8e93fe2dbb89b560731ad245969ead9",
+  "anchor": [
+   "main",
+   98
+  ],
+  "src": 98,
+  "kind": "main",
+  "sub": 4,
+  "eng_sha": "2eb9e09278911c1d42cd04a2acd41af4d5a5ba3b",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: share LOG data runs per log transaction",
+  "msg_changed": false
+ },
+ {
+  "sha": "209a022c2937deef915a5e2d0abe5865474e7cd2",
+  "anchor": [
+   "part",
+   100,
+   1
+  ],
+  "src": 100,
+  "kind": "part",
+  "sub": 4,
+  "eng_sha": "96e28638bdb4d5f37f3b80264c637e6fbb159e54",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode (fsync part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "e87fcd378507d2a5ac28d71bd5cc8732bd5c398a",
+  "anchor": [
+   "main",
+   103
+  ],
+  "src": 103,
+  "kind": "main",
+  "sub": 4,
+  "eng_sha": "cfa6f4889fdd62e7633c02b7714e11c6dc64882a",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: read the shared LOG run mode once per log settle",
+  "msg_changed": false
+ },
+ {
+  "sha": "9fd4b80485f4858d22f3e5c9e31fd99453189d4e",
+  "anchor": [
+   "part",
+   119,
+   5
+  ],
+  "src": 119,
+  "kind": "part",
+  "sub": 4,
+  "eng_sha": "eb666a2bfd3fb98d7868780c9d73c07dfc3c20b3",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (fsync part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "938994da00db11e97f89662cbef68e620c13e2ae",
+  "anchor": [
+   "part",
+   120,
+   4
+  ],
+  "src": 120,
+  "kind": "part",
+  "sub": 4,
+  "eng_sha": "8be8f633ba7df90b4f3971ba91cc793b915e3fae",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (fsync part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "4ac75b8a4bb1ea9fc9f8fa2a9910a581bfe39960",
+  "anchor": [
+   "main",
+   6
+  ],
+  "src": 6,
+  "kind": "main",
+  "sub": 5,
+  "eng_sha": "045d603bb8e6e402cf6d6cd859bce4df2c46a093",
+  "overlaid": true,
+  "subject": "btrfs: add a write-hole invariant checker to the raid56 write path",
+  "msg_changed": false
+ },
+ {
+  "sha": "170943f5e9e5fb0fa605ea6c467b6361282a7446",
+  "anchor": [
+   "part",
+   29,
+   1
+  ],
+  "src": 29,
+  "kind": "part",
+  "sub": 5,
+  "eng_sha": "6ce0164e2c5a06a5097d3452f1ea30602e570c8c",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: report read-modify-write of uncovered stripes (debug part)",
+  "msg_changed": true
+ },
+ {
+  "sha": "5689a5a06af0d50b6c90d22d22b7274fd72c818b",
+  "anchor": [
+   "part",
+   20,
+   3
+  ],
+  "src": 20,
+  "kind": "part",
+  "sub": 5,
+  "eng_sha": "47d273e586f62831949344bbf18b08c6e732bb49",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (debug part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "f86e194e55dc7e11d0e20ac04d7fc83e472a427e",
+  "anchor": [
+   "main",
+   40
+  ],
+  "src": 40,
+  "kind": "main",
+  "sub": 5,
+  "eng_sha": "27521ca4a8601c09ab441d8145914db0ef38d11e",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: drain the legacy allocator's writes before arming the write-hole check at a runtime enable",
+  "msg_changed": false
+ },
+ {
+  "sha": "9bcba79cdc75278a0febf39e4d45e56ada2aec6d",
+  "anchor": [
+   "part",
+   74,
+   1
+  ],
+  "src": 74,
+  "kind": "part",
+  "sub": 5,
+  "eng_sha": "042aeeb21cb29ef91b3b101b57e694b5113bce1d",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: say at mount whether the policy is on (debug part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "df6f2b0b8349f32a00d6e1e82d4e94319134c20e",
+  "anchor": [
+   "part",
+   119,
+   6
+  ],
+  "src": 119,
+  "kind": "part",
+  "sub": 5,
+  "eng_sha": "d0ee1e8e692ddf95bb88cb76144b60cdc2aa9bac",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (debug part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "a3ee3341192eefdfb5ca6bf500e848b75da49b1f",
+  "anchor": [
+   "main",
+   86
+  ],
+  "src": 86,
+  "kind": "main",
+  "sub": 5,
+  "eng_sha": "9601e30f0d1ef3441319bbe3a2348af2170792a1",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: attribute each data read-modify-write to why padding declined",
+  "msg_changed": false
+ },
+ {
+  "sha": "e9643b4023afc16d098e106107840f88eeef2471",
+  "anchor": [
+   "main",
+   87
+  ],
+  "src": 87,
+  "kind": "main",
+  "sub": 5,
+  "eng_sha": "7a17f8e398ab34190e66c9a0c881fde33de32d60",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: optionally audit data read-modify-writes against the committed extent tree",
+  "msg_changed": false
+ },
+ {
+  "sha": "89ab74409c0548d35f2e0195b85daca9c48dc1bb",
+  "anchor": [
+   "main",
+   95
+  ],
+  "src": 95,
+  "kind": "main",
+  "sub": 5,
+  "eng_sha": "2b1ef385d2eead23f67c51326832855ecb728126",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: break rbio pins and open stripe runs down by run class",
+  "msg_changed": false
+ },
+ {
+  "sha": "fc20fffc822564066eedcf386151c4981308393a",
+  "anchor": [
+   "part",
+   119,
+   7
+  ],
+  "src": 119,
+  "kind": "part",
+  "sub": 5,
+  "eng_sha": "3ed6e6f3d1b05099bcbd42c085e9c98961b9ce02",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (debug part 2)",
+  "msg_changed": false
+ },
+ {
+  "sha": "e7a3141fea24c9797d3c18607476c8897af8a0f6",
+  "anchor": [
+   "part",
+   120,
+   5
+  ],
+  "src": 120,
+  "kind": "part",
+  "sub": 5,
+  "eng_sha": "8e7ae70a79d7b47d691033d122968af939e86388",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (debug part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "7be4b9cd97433470f1f5bdcca1af0dee98aa8e9b",
+  "anchor": [
+   "main",
+   123
+  ],
+  "src": 123,
+  "kind": "main",
+  "sub": 5,
+  "eng_sha": "03576b1f8537e77ce3da7cd24cb800a2e6ee06da",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count and log ordered extents that end with sectors unwritten",
+  "msg_changed": false
+ },
+ {
+  "sha": "1cc34cf3af9f86778a796bab009fa2dcbf5a9fb4",
+  "anchor": [
+   "main",
+   39
+  ],
+  "src": 39,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "5a6aeba2e32b9f8008dae5dc87c30002b138a29d",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: allocate tree blocks by whole stripes",
+  "msg_changed": false
+ },
+ {
+  "sha": "0d50b600e7d6b02e908e373d1cc1d000999c72db",
+  "anchor": [
+   "part",
+   124,
+   1
+  ],
+  "src": 124,
+  "kind": "part",
+  "sub": 6,
+  "eng_sha": "77980c99aae5984f984c538f0cfb861a86166ef7",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3 (stripe_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "dd54cf6f46ae5cbd7f46e8378a1f536f5ed394b8",
+  "anchor": [
+   "new",
+   49.5
+  ],
+  "src": 49.5,
+  "kind": "new",
+  "sub": 6,
+  "eng_sha": "eb1786b5c5b1d6ebe4efc19d7a2fe22ae70ceadb",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: extend stripe reclaim to metadata block groups",
+  "msg_changed": false
+ },
+ {
+  "sha": "44ebf7dec6f7d2466d68712c26f563416514778b",
+  "anchor": [
+   "main",
+   50
+  ],
+  "src": 50,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "061f51cbcccb71a9a4775756bd6cd65d03676623",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: maintain trapped free space for metadata groups like data",
+  "msg_changed": false
+ },
+ {
+  "sha": "16e5e268cd2aaf9d3b5d878000fd5751c43cab80",
+  "anchor": [
+   "main",
+   51
+  ],
+  "src": 51,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "03b61a9077fe5e9f1d5b3ff7a807d668f4285e7c",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: back the global reserve with usable stripes, and say when a tree block finds none",
+  "msg_changed": false
+ },
+ {
+  "sha": "444a71ee9ce91f290a69effb786b13705a4c3be3",
+  "anchor": [
+   "main",
+   52
+  ],
+  "src": 52,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "df82d94f7b4bc08d4b9c08a626d29537d35d34a7",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: hold back whole stripes so tree blocks always land and trapped groups can be reclaimed",
+  "msg_changed": false
+ },
+ {
+  "sha": "a9e1cfa23b72c3b0af2fd51196451ec15bfbb845",
+  "anchor": [
+   "part",
+   59,
+   2
+  ],
+  "src": 59,
+  "kind": "part",
+  "sub": 6,
+  "eng_sha": "96140be66107b68e1aa29eed16c4466afd4ddeab",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped (stripe_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "623c09bc14f9f2b146deddd13cc3935f61f3e122",
+  "anchor": [
+   "part",
+   106,
+   1
+  ],
+  "src": 106,
+  "kind": "part",
+  "sub": 6,
+  "eng_sha": "f5b1b6eb854376e924e0a1666c2392140947c6de",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: keep the stripe totals consistent with the groups during the commit scan (stripe_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "5612ec23afce4477dcb01e83adc95712796230cc",
+  "anchor": [
+   "part",
+   125,
+   1
+  ],
+  "src": 125,
+  "kind": "part",
+  "sub": 6,
+  "eng_sha": "fa00481614d568e6843eea708335179fce297368",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count single-data-stripe groups' free space in write admission (stripe_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "6adeeacb35b69860e786afa0bbf2f76bbfacdb7d",
+  "anchor": [
+   "main",
+   53
+  ],
+  "src": 53,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "579b06b5e4b328bb6ee4c0d18204f5a802b5c9f5",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: do not steal from the global reserve below the relocation reserve",
+  "msg_changed": false
+ },
+ {
+  "sha": "ed5673468a810a8129f610f677710c4cb29971e9",
+  "anchor": [
+   "main",
+   54
+  ],
+  "src": 54,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "633522ae90c4ee29ed08aa2d7783e768f4c899fe",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: let the transaction machinery's own reservations draw on the reserve",
+  "msg_changed": false
+ },
+ {
+  "sha": "cc86d4c8d6cf76f23dbad59065e3a0efb033063d",
+  "anchor": [
+   "main",
+   55
+  ],
+  "src": 55,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "a478ae36eeaaf37fdc62ea0ca41ad00ec43e0178",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: let a group go read-only for relocation against the reserve",
+  "msg_changed": false
+ },
+ {
+  "sha": "ce263088ef8db681b3fea5c5c6981d0c4b0a9b29",
+  "anchor": [
+   "main",
+   67
+  ],
+  "src": 67,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "cfbf9b350fd8b6e8195a8f184d699eab6311bc5c",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: carry raid56 metadata groups through a runtime enable or disable",
+  "msg_changed": false
+ },
+ {
+  "sha": "7623ca1f48eabae81ba1ebbbee5a814bf6a7dee2",
+  "anchor": [
+   "main",
+   70
+  ],
+  "src": 70,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "f0c6a1a11e40a256680e6cfe31fb05a90ef63b9a",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: sync the open-run remainder when the commit retires metadata runs",
+  "msg_changed": false
+ },
+ {
+  "sha": "25cb59f604409fd26398bf357edf22e6f087c010",
+  "anchor": [
+   "main",
+   71
+  ],
+  "src": 71,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "25919b2306b347cfebd77025424e60cc7bd44aeb",
+  "overlaid": true,
+  "subject": "btrfs: raid56: do not call a covered stripe_meta group uncovered",
+  "msg_changed": false
+ },
+ {
+  "sha": "fd3e540dba7c0025e3e2ef263ce85094f5e4661b",
+  "anchor": [
+   "main",
+   77
+  ],
+  "src": 77,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "4d0fe90f3d8ae3bd105d7fc77952d926e2c81409",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: cover raid56 system chunks",
+  "msg_changed": false
+ },
+ {
+  "sha": "8324ff22034336be7de4706409f1fb6f030d88bf",
+  "anchor": [
+   "main",
+   82
+  ],
+  "src": 82,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "46ab516d31a80c3068b00ec0ef1f2526ff8b39a4",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: grant the stripe_meta reserve to all of a relocation",
+  "msg_changed": false
+ },
+ {
+  "sha": "d81c1bdb829ccb32347a91e095f20153cd4a6c23",
+  "anchor": [
+   "main",
+   83
+  ],
+  "src": 83,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "39b5c3c058b3b22183cf283575f7072d26506024",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: let mount-time orphan cleanup steal from the global reserve",
+  "msg_changed": false
+ },
+ {
+  "sha": "c48e7116950cce768bee7677f3ceb39a2f5d0caa",
+  "anchor": [
+   "main",
+   96
+  ],
+  "src": 96,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "f8f4135cbda1fdc07805e070051084964880e3e4",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: give each log commit its own metadata stripe run",
+  "msg_changed": false
+ },
+ {
+  "sha": "4190affcd407a80afed333f985744e8ebf8fd98d",
+  "anchor": [
+   "part",
+   100,
+   2
+  ],
+  "src": 100,
+  "kind": "part",
+  "sub": 6,
+  "eng_sha": "315a9d3f50c0b347bbfa3e9ffa161827b922aba3",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode (stripe_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "08d404717b8fb02eac97fab34e5be1b4be4a54d0",
+  "anchor": [
+   "part",
+   98,
+   1
+  ],
+  "src": 98,
+  "kind": "part",
+  "sub": 6,
+  "eng_sha": "ce6eca6126cba8e8adbcd72087bbf24e0d67c56c",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: share LOG data runs per log transaction (stripe_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "a692a2f5f920826ec85de487500108bc5a025421",
+  "anchor": [
+   "main",
+   108
+  ],
+  "src": 108,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "b53eccf0e929430e2acd95ded4c1239dc1442dfc",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: commit before waiting for metadata runs when making a group read-only",
+  "msg_changed": false
+ },
+ {
+  "sha": "7a84aef78691b375e7fc232768d7718d1ec57655",
+  "anchor": [
+   "main",
+   117
+  ],
+  "src": 117,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "3f5e022bfc507b1b4cdcc859fabe8778761e5def",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: check the block group lookup when freeing an unwritten tree block",
+  "msg_changed": false
+ },
+ {
+  "sha": "b06bdbcf748ada32241d823c0d27ff60ec46a163",
+  "anchor": [
+   "main",
+   119
+  ],
+  "src": 119,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "681a7dd25cc97ecabc29a011a5f5d7e1f19aa872",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments",
+  "msg_changed": false
+ },
+ {
+  "sha": "0cd7ee714ea01669842d106eeed86f195146e86a",
+  "anchor": [
+   "main",
+   120
+  ],
+  "src": 120,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "d047c20346152f1e455c5302a9301c17475299a6",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code",
+  "msg_changed": false
+ },
+ {
+  "sha": "2d9c221de3f05c23b3396d2ec2d417ef3f1edc9e",
+  "anchor": [
+   "part",
+   124,
+   2
+  ],
+  "src": 124,
+  "kind": "part",
+  "sub": 6,
+  "eng_sha": "4c0e7af1dac2fe5612ae9d46ffc93effb54d8123",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3 (stripe_meta part 2)",
+  "msg_changed": false
+ },
+ {
+  "sha": "5df0cab05912197ccde3c0bf32abad5e3f4397ce",
+  "anchor": [
+   "main",
+   121
+  ],
+  "src": 121,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "57406320b7088066062304534ac0ba157c177779",
+  "overlaid": true,
+  "subject": "btrfs: stripe_meta: keep waiting for metadata runs that do not drain at commit",
+  "msg_changed": false
+ },
+ {
+  "sha": "4d3e6d1681d4252a6fd0957d04403690bfdf26e6",
+  "anchor": [
+   "main",
+   126
+  ],
+  "src": 126,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "2a0c74e6042b37ef99ff12192a5685e477662629",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: account claimable stripes while a trim has them out",
+  "msg_changed": false
+ },
+ {
+  "sha": "15c75f2a0cb75e469d469d86b2d8efc06a34f2da",
+  "anchor": [
+   "main",
+   128
+  ],
+  "src": 128,
+  "kind": "main",
+  "sub": 6,
+  "eng_sha": "066e39b07e64f44f27dcf07bc6663df9087b8d73",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: do not miss bitmap free space when debiting a trim",
+  "msg_changed": false
+ },
+ {
+  "sha": "51dbc17006efa40008bd2d735cb6573fe6eeb3fa",
+  "anchor": [
+   "part",
+   123,
+   1
+  ],
+  "src": 123,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "60b5d4dd238919ddec767a4fb0d3f84c2eac42f2",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count and log ordered extents that end with sectors unwritten (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "ed411b979a4acd78c7791418c1a8c7e571e5e3ee",
+  "anchor": [
+   "main",
+   30
+  ],
+  "src": 30,
+  "kind": "main",
+  "sub": 7,
+  "eng_sha": "22f3ecd8fe5421adf068ee7fac3f976a12eff444",
+  "overlaid": true,
+  "subject": "btrfs: raid56: say whether a metadata read-modify-write is a write hole",
+  "msg_changed": false
+ },
+ {
+  "sha": "1e6a49e40c812640d131034f568be8f62bafbed6",
+  "anchor": [
+   "part",
+   31,
+   2
+  ],
+  "src": 31,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "4e154926ff3704d43340876f65c92d37985ed88f",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "730786660a0cdba45dec800a17df4050c38b3344",
+  "anchor": [
+   "part",
+   32,
+   1
+  ],
+  "src": 32,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "d2679761bd7b5ddb8728d2e3bcce32eca7b910bb",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: trace why padding declined, at the moment it declined (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "651d73824cf71d9c0a63af5d16c926492f44ed7d",
+  "anchor": [
+   "part",
+   86,
+   1
+  ],
+  "src": 86,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "28cbb07e1ee1b32b324b6c94434f088cfc54eab9",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: attribute each data read-modify-write to why padding declined (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "c7f164a43a72420ab4d10d092f1380068e01b67f",
+  "anchor": [
+   "part",
+   36,
+   1
+  ],
+  "src": 36,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "26d435ee23b8a2f3dc08bd294ddd5ddfcb945fc8",
+  "overlaid": true,
+  "subject": "btrfs: raid56: adaptive park deadline from the parked-rbio backlog (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "8e9589ccd4e6e2bfd4908f383235c0ebdee273e9",
+  "anchor": [
+   "part",
+   90,
+   2
+  ],
+  "src": 90,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "75b65df00fe682cc26c26868f264044a2b056f3b",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "bda1dfa8d437957d8b8661fd952104771bde7aa1",
+  "anchor": [
+   "part",
+   93,
+   1
+  ],
+  "src": 93,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "fe12f5d1407bbf66fecff7a324a660adc7242029",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: count refused rbio pins and track rbio cache high water (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "e017434f9f067efcffc0c67e1be6c859db4a07fc",
+  "anchor": [
+   "part",
+   94,
+   1
+  ],
+  "src": 94,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "cd8b0ca3413b1c604ba07f2c3c4adfcfb40d34f4",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: sweep stale rbio pins, and commit when live pins run low (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "41fccbb41511ec8c03fd2cb67e1d9381b1e2dff7",
+  "anchor": [
+   "main",
+   57
+  ],
+  "src": 57,
+  "kind": "main",
+  "sub": 7,
+  "eng_sha": "860239e8e39b3121c7153ab690c4c7f3682fe6c5",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: tell a dead tree block from a live one in the metadata RMW audit",
+  "msg_changed": false
+ },
+ {
+  "sha": "b5f9614d6cc04bd03c01c38a44a9abdeb1809952",
+  "anchor": [
+   "main",
+   109
+  ],
+  "src": 109,
+  "kind": "main",
+  "sub": 7,
+  "eng_sha": "13d98e81c8dded7c8fe5e39880c632084d2781af",
+  "overlaid": true,
+  "subject": "btrfs: raid56: do not read tree blocks under the stripe lock in the metadata RMW audit",
+  "msg_changed": false
+ },
+ {
+  "sha": "afe79157dc5de239d9f1207d628573bdfdc41f92",
+  "anchor": [
+   "part",
+   120,
+   6
+  ],
+  "src": 120,
+  "kind": "part",
+  "sub": 7,
+  "eng_sha": "965d4c406681549df10bde46863f423abe87cabe",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (debug_meta part)",
+  "msg_changed": false
+ },
+ {
+  "sha": "0d329b02edc84fcc0f9418472785427998094631",
+  "anchor": [
+   "main",
+   122
+  ],
+  "src": 122,
+  "kind": "main",
+  "sub": 7,
+  "eng_sha": "1c579504322a7e4d51cf76d9d1449660fa711635",
+  "overlaid": true,
+  "subject": "btrfs: stripe_alloc: remove pad refusal reasons that no longer exist",
+  "msg_changed": false
+ }
+]
\ No newline at end of file
diff --git a/scripts/sa-reorder/wpost-q16.log b/scripts/sa-reorder/wpost-q16.log
new file mode 100644 (file)
index 0000000..99d307f
--- /dev/null
@@ -0,0 +1,363 @@
+  1 ('main', 1) b27506ce5058 (eng)
+  2 ('main', 2) a434477e9373 (eng)
+  3 ('main', 3) 5b99cf7992dc (eng)
+  4 ('main', 4) b07423c97e2f (eng)
+  5 ('main', 5) 5537f6f3a63f (eng)
+  6 ('main', 7) a26e071bef9c (eng)
+  7 ('main', 8) 0cf2fa5dea5f (eng)
+  8 ('main', 9) bef7b1b7b7d9 (eng)
+  9 ('main', 10) e3af9531a3d5 (eng)
+ 10 ('main', 11) e63578f8e47a (eng)
+ 11 ('main', 12) 7366e004dab3 (eng)
+ 12 ('main', 13) 17a088006315 (eng)
+ 13 ('main', 15) b954ad7e8a93 (eng)
+ 14 ('main', 18) d97b095b2f95 (eng)
+ 15 ('main', 23) 8b3189f0b4c5 (eng)
+ 16 ('main', 24) ee2e162f9752 (eng)
+ 17 ('main', 25) fe517d802570 (eng)
+ 18 ('main', 26) e2e5a7b4de28 (eng)
+ 19 ('main', 27) cdaa599aac8e (eng)
+ 20 ('main', 28) a871f05f3f17 (eng)
+ 21 ('main', 29) 4bcdce36da3a (eng)
+ 22 ('main', 31) e9b7e6478844 (eng)
+ 23 ('main', 32) 099bd5d9f0ad (eng)
+ 24 ('main', 33) 1e92287f2ebb (eng)
+ 25 ('main', 34) c618a01c389a (eng)
+ 26 ('main', 35) 34c1ec99517d (eng)
+ 27 ('main', 36) 20ba6fcce815 (eng)
+ 28 ('main', 37) 915f84322bee (eng)
+ 29 ('main', 38) f27d0b87bac0 (eng)
+ 30 ('main', 41) d57cf8b605be (eng)
+ 31 ('main', 42) 7808b5825280 (eng)
+ 32 ('main', 43) 2d48a2913cab (eng)
+ 33 ('main', 45) a7b21162a442 (eng)
+ 34 ('main', 46) 5d85295ebe17 (eng)
+ 35 ('main', 47) 67b9a9d665ec (eng)
+ 36 ('main', 56) e5c1891678d9 (eng)
+ 37 ('main', 59) ecdcf6cfdbe2 (eng)
+ 38 ('main', 61) 5524d6c2804d (eng)
+ 39 ('main', 62) f5a9422c4fd7 (eng)
+ 40 ('main', 63) 4b233383a897 (eng)
+ 41 ('main', 64) 244b0be1d6af (eng)
+ 42 ('main', 65) 17767e566544 (eng)
+ 43 ('main', 66) 8e1bbbdd6707 (eng)
+ 44 ('main', 68) c4443d0e42d8 (eng)
+ 45 ('main', 69) 42d7d1e3bacb (eng)
+ 46 ('main', 72) 88421d1c63c2 (eng)
+ 47 ('main', 73) 42a149819b5a (eng)
+ 48 ('main', 74) c7afd3986340 (eng)
+ 49 ('main', 75) f3f07290cd65 (eng)
+ 50 ('main', 76) 404d713bc627
+ 51 ('main', 80) aa143b873b3e
+ 52 ('main', 81) d9c9e2a34237
+ 53 ('main', 88) da33af89286e
+ 54 ('main', 89) 2bc69128391b
+ 55 ('main', 90) 93fdd94751dd
+ 56 ('main', 91) 5d3f0b568b38
+ 57 ('main', 92) bee925b2695e
+ 58 ('main', 93) eca47db85253
+ 59 ('main', 94) 60564040c971
+ 60 ('main', 97) a097c0794cfd
+ 61 ('main', 99) b0686185d4e2
+ 62 ('main', 101) 91e55120b5b6
+ 63 ('main', 102) 2dacb5066484
+ 64 ('main', 104) d3209b737d10
+ 65 ('main', 106) 264f61abed14
+ 66 ('main', 107) c9e896128c73
+ 67 ('main', 110) a3097754b4ce
+ 68 ('main', 111) 4c5ad922b2ad
+ 69 ('main', 112) 3094c7ef1a03
+ 70 ('main', 113) a1271a61e767
+ 71 ('main', 114) 607390ae539d
+ 72 ('main', 116) ca3cb673139a
+ 73 ('part', 119, 1) 2b6b9c9b5185
+ 74 ('part', 120, 1) f4179a7a8789
+ 75 ('main', 124) 91dac74c36f3
+ 76 ('main', 125) dc293d96e888
+ 77 ('main', 127) e114929fad3c
+ 78 ('main', 19) c735d233f135
+ 79 ('part', 61, 1) 388ad668eb00
+ 80 ('part', 90, 1) 70a736f97c9d
+ 81 ('part', 91, 1) 9fcf8631eb8e
+ 82 ('main', 20) 6d3eeac5016f
+ 83 ('part', 34, 1) 03f26d0a1701
+ 84 ('part', 119, 2) a0bc87598c9d
+ 85 ('part', 76, 1) ce1b335f64d2
+ 86 ('main', 79) 5f616536a7be
+ 87 ('part', 119, 3) 3242719f6c12
+ 88 ('main', 21) f416bf1b65ec
+ 89 ('part', 25, 1) 7fe89d1fd3bb
+ 90 ('part', 79, 1) cb6fb711f5d2
+ 91 ('main', 22) d93d7b5a3ee9
+ 92 ('part', 31, 1) 8cf912dc546f
+ 93 ('main', 58) 1519d814e0d4
+ 94 ('main', 60) 744763ff52d0
+ 95 ('main', 78) 36ded31c6f42
+ 96 ('main', 100) 5fd94f7f1580
+ 97 ('main', 105) 7f4190fae8f9
+ 98 ('main', 115) 178aaaa02e80
+ 99 ('main', 118) 0fe03dd07464
+100 ('part', 119, 4) 7971de144562
+101 ('part', 120, 2) bf9f5f93318b
+102 ('main', 44) cec0eac8766f
+103 ('main', 48) d5a9aa24e1eb
+104 ('part', 59, 1) bea87a8e400e
+105 ('main', 49) 4e3d51695651
+106 ('main', 84) 26f5729f0aab
+107 ('part', 88, 1) 3a640d2a7bde
+108 ('main', 85) 5234cc6cc61e
+109 ('part', 120, 3) f0dbf27e18b8
+110 ('main', 129) 23810a6e098e
+111 ('main', 130) 8e0e6b7baa3f
+112 ('main', 131) 10e385b0d04d
+113 ('main', 132) 48deb18bd432
+114 ('main', 14) bcc0e44c29b2
+115 ('part', 25, 2) 8c614feab814
+116 ('part', 81, 1) 4edf95d05150
+117 ('part', 20, 1) 6e61d4d98470
+118 ('main', 16) 4a51d56607ab
+119 ('part', 79, 2) b2796cc2ba61
+120 ('part', 20, 2) 3e351ffcdc5f
+121 ('main', 17) 29137508ecee
+122 ('main', 98) 2f66d4ed8f6a
+123 ('part', 100, 1) c1a1d5fb29b7
+124 ('main', 103) 5db39870018b
+125 ('part', 119, 5) 9105b624c70e
+126 ('part', 120, 4) 8c4db94fe920
+127 ('main', 6) dd4bcd32a8da
+128 ('part', 29, 1) 8468e5fd97d2
+129 ('part', 20, 3) a06d3bcdb69d
+130 ('main', 40) 02c9c181af70
+131 ('part', 74, 1) 22ed43898a9d
+132 ('part', 119, 6) 142bd293166a
+133 ('main', 86) b0e8167aa388
+134 ('main', 87) 760f70646569
+135 ('main', 95) af5da9a24f49
+136 ('part', 119, 7) 112509e9e6d6
+137 ('part', 120, 5) caa38b36adfb
+138 ('main', 123) 8fa39ccd9791
+139 ('main', 39) 000d05ae95fd
+140 ('part', 76, 2) 000d05ae95fd
+141 ('part', 124, 1) 7a6fd379e103
+142 ('new', 49.5) 432c7d385bbd
+143 ('main', 50) abacc034166a
+144 ('main', 51) 3c6da79b4502
+145 ('main', 52) ecdfb8f2c132
+146 ('part', 59, 2) 255ccdf230a4
+147 ('part', 106, 1) 6cfb51b392ee
+148 ('part', 125, 1) 9a64f9ad6273
+149 ('main', 53) 1c7399f5f452
+150 ('main', 54) c902821e513a
+151 ('main', 55) 5eca66a70ebd
+152 ('main', 67) 029132b5d1aa
+153 ('main', 70) 8629ce90d934
+154 ('main', 71) fc5613cb6815
+155 ('main', 77) bd7b85b4ab8b
+156 ('main', 82) 1577be9f6d99
+157 ('main', 83) b993539e8f36
+158 ('main', 96) a9eb7b25379b
+159 ('part', 100, 2) 0a45fa8fb291
+160 ('part', 98, 1) 6e5f6548d5c7
+161 ('main', 108) 8a2f79349d0f
+162 ('main', 117) 03d1a47f8f00
+163 ('main', 119) 9841f3017469
+164 ('main', 120) 9c2995b0b187
+165 ('part', 124, 2) d69d5704751f
+166 ('main', 121) 826d329a48bc
+167 ('main', 126) 15c68ba018d8
+168 ('main', 128) 33ef33d4ee6d
+169 ('part', 123, 1) d30275ba66dd
+170 ('main', 30) bfea260108ad
+171 ('part', 31, 2) 9f876f04f822
+172 ('part', 32, 1) 484f3bbcc7c4
+173 ('part', 86, 1) 037f6276e298
+174 ('part', 36, 1) 2501fec097a4
+175 ('part', 90, 2) 72863fbe88ab
+176 ('part', 93, 1) 087e6e7fe5b1
+177 ('part', 94, 1) bea1edd84e33
+178 ('main', 57) 9e40a8ba91d9
+179 ('main', 109) 62c4bd4f0b85
+180 ('part', 120, 6) b8b81b14d3fb
+181 ('main', 122) c821ac92ab6e
+  1 S1 main ('main', 1) ada60a627390 btrfs: add btrfs_claim_free_stripe_run() for stripe-exclusive allocati
+  2 S1 main ('main', 2) dcab8cda924b btrfs: add open stripe run tracking for stripe-exclusive allocation
+  3 S1 main ('main', 3) f79cc86c3f08 btrfs: add the stripe_alloc allocation policy for raid56 data
+  4 S1 main ('main', 4) 4bc0a0c0a92e btrfs: report stripe run data IO through the ordered extent lifecycle
+  5 S1 main ('main', 5) d71b2b62a1d1 btrfs: retire stripe runs at commit and gate stripe_alloc
+  6 S1 main ('main', 7) b9e5e0f6e684 btrfs: stripe_alloc: refuse space_cache=v1
+  7 S1 main ('main', 8) 1781c75b6b08 btrfs: account stripe_alloc trapped free space for honest statfs
+  8 S1 main ('main', 9) 967931b23029 btrfs: stripe_alloc: keep an open run per size band to trap less
+  9 S1 main ('main', 10) b893f6f7db92 btrfs: stripe_alloc: grow the frontier run instead of stranding its ta
+ 10 S1 main ('main', 11) d53cb5cfc036 btrfs: raid56: batch stripe_alloc partial writes into full-stripe writ
+ 11 S1 main ('main', 12) 24aa9de0044a btrfs: stripe_alloc: never claim stripes covered by a live run
+ 12 S1 main ('main', 13) 816b89bb3815 btrfs: stripe_alloc: control the policy with a filesystem property
+ 13 S1 main ('main', 15) 6d4b4d3576a5 btrfs: stripe_alloc: private per-inode stripe runs for log-active inod
+ 14 S1 main ('main', 18) dfc913859ddd btrfs: raid56: pad sub-stripe writes to full stripes in open runs
+ 15 S1 main ('main', 23) dd8324a80310 btrfs: raid56: expose parking statistics in sysfs
+ 16 S1 main ('main', 24) a560c15dbf07 btrfs: raid56: skip parking for sync rbios finished by their unplug ba
+ 17 S1 main ('main', 25) 21d2fcf33421 btrfs: stripe_alloc: count open stripe run remainders against data res
+ 18 S1 main ('main', 26) bd3340c9ce36 btrfs: stripe_alloc: pessimistic data reservation margin
+ 19 S1 main ('main', 27) 43fbad5b6033 btrfs: stripe_alloc: claim fully-free stripes that span free space ent
+ 20 S1 main ('main', 28) 675d0aba5573 btrfs: stripe_alloc: warn at mount when raid56 metadata is not covered
+ 21 S1 main ('main', 29) e31591623bf1 btrfs: stripe_alloc: report read-modify-write of uncovered stripes
+ 22 S1 main ('main', 31) a91464ecfd91 btrfs: stripe_alloc: tunable park deadlines, and say why padding decli
+ 23 S1 main ('main', 32) fc40c45f34a1 btrfs: stripe_alloc: trace why padding declined, at the moment it decl
+ 24 S1 main ('main', 33) edd2f7bd5f7b btrfs: stripe_alloc: complete parked writes on allocation coverage, no
+ 25 S1 main ('main', 34) 40675503699b btrfs: stripe_alloc: track per-sector liveness and pad from the map
+ 26 S1 main ('main', 35) cc21c95cc4d6 btrfs: stripe_alloc: count claimable whole-stripe supply directly
+ 27 S1 main ('main', 36) 6283243b97ca btrfs: raid56: adaptive park deadline from the parked-rbio backlog
+ 28 S1 main ('main', 37) 86bffb89916b btrfs: stripe_alloc: gate data admission on claimable whole-stripe sup
+ 29 S1 main ('main', 38) f61792b3be35 btrfs: stripe_alloc: cache a failed stripe run scan per block group
+ 30 S1 main ('main', 41) a5756e4f442e btrfs: stripe_alloc: do not count trapped free space twice when making
+ 31 S1 main ('main', 42) b178c2a51cc8 btrfs: stripe_alloc: keep the admitted bytes placeable when a group go
+ 32 S1 main ('main', 43) 1b88dcaba4f7 btrfs: stripe_alloc: never let relocation wait on the whole-stripe gat
+ 33 S1 main ('main', 45) be4eb11ad365 btrfs: stripe_alloc: charge relocation a margin per reservation, not p
+ 34 S1 main ('main', 46) 80e338dfa737 btrfs: stripe_alloc: keep the relocation group's stripes out of the ad
+ 35 S1 main ('main', 47) 4bc52680eb37 btrfs: stripe_alloc: let a data write fall back to the relocation grou
+ 36 S1 main ('main', 56) ce6555659412 btrfs: stripe_alloc: show per-group trapped bytes in the space info du
+ 37 S1 main ('main', 59) 9b85bbd704a1 btrfs: stripe_alloc: count whole stripes stranded behind live runs as 
+ 38 S1 main ('main', 61) 7420e8328755 btrfs: stripe_alloc: count nocow run lifecycles and stranded stripes i
+ 39 S1 main ('main', 62) db32c3e1b42f btrfs: stripe_alloc: charge the held stripe margin against every admis
+ 40 S1 main ('main', 63) d676483512c1 btrfs: stripe_alloc: admit data reservations by whole stripes
+ 41 S1 main ('main', 64) ef4ebd416105 btrfs: stripe_alloc: hold a stripe of margin across a preallocation
+ 42 S1 main ('main', 65) f84bc71fcd07 btrfs: stripe_alloc: hold the probe margin until the metadata reservat
+ 43 S1 main ('main', 66) cfd4c7939a42 btrfs: stripe_alloc: saturate the read-only guard's claimable subtract
+ 44 S1 main ('main', 68) af432a1ad737 btrfs: stripe_alloc: charge the preallocation's stripe hold under the 
+ 45 S1 main ('main', 69) 611995c7446a btrfs: stripe_alloc: return a group's allocation cluster before scanni
+ 46 S1 main ('main', 72) 94941a7665a8 btrfs: stripe_alloc: release open stripe runs when a mount fails or an
+ 47 S1 main ('main', 73) 659efaa577cb btrfs: stripe_alloc: let the property accept a cache-less filesystem l
+ 48 S1 main ('main', 74) 0fa169926545 btrfs: stripe_alloc: say at mount whether the policy is on
+ 49 S1 main ('main', 75) 886e5380230b btrfs: stripe_alloc: hold a reference on the rbio being parked
+ 50 S1 main ('main', 76) 0c1f0732d028 btrfs: stripe_alloc: drop the mount options, the property is the inter
+ 51 S1 main ('main', 80) b6f85e21c45c btrfs: stripe_alloc: do not wait for stripe runs to drain on an errore
+ 52 S1 main ('main', 81) 8de5c2c5c83c btrfs: stripe_alloc: end the commit-time and log drains on an errored 
+ 53 S1 main ('main', 88) 599e32fcc943 btrfs: stripe_alloc: keep relocation's stripe runs until relocation en
+ 54 S1 main ('main', 89) b6e38dc9ec9d btrfs: stripe_alloc: let relocation allocate a data chunk before it fa
+ 55 S1 main ('main', 90) e6e606760c9d btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has
+ 56 S1 main ('main', 91) 6f6dd994cc64 btrfs: stripe_alloc: pad a stripe's allocated sectors whose write is s
+ 57 S1 main ('main', 92) 6c894897959b btrfs: stripe_alloc: apply the property before tree-log replay
+ 58 S1 main ('main', 93) b0666acbe473 btrfs: stripe_alloc: count refused rbio pins and track rbio cache high
+ 59 S1 main ('main', 94) 16906917d4bb btrfs: stripe_alloc: sweep stale rbio pins, and commit when live pins 
+ 60 S1 main ('main', 97) ce05cc820d4d btrfs: stripe_alloc: don't make a parked rbio wait for sectors that wi
+ 61 S1 main ('main', 99) 5be7c29739a2 btrfs: stripe_alloc: let relocation allocate as many data chunks as it
+ 62 S1 main ('main', 101) 433b2b875c45 btrfs: stripe_alloc: do not treat an allocation error as a found exten
+ 63 S1 main ('main', 102) 8d1347b94d2b btrfs: stripe_alloc: mark an ended ordered extent's sectors written
+ 64 S1 main ('main', 104) e2228f87bd37 btrfs: stripe_alloc: remove only the set bits of a bitmap when claimin
+ 65 S1 main ('main', 106) 6c81b4b8423c btrfs: stripe_alloc: keep the stripe totals consistent with the groups
+ 66 S1 main ('main', 107) 6d7c7f5cb424 btrfs: stripe_alloc: do not delete an unused block group that still ha
+ 67 S1 main ('main', 110) 4a78714773d5 btrfs: raid56: stop the park timer before destroying the raid56 workqu
+ 68 S1 main ('main', 111) da8d0c8feb45 btrfs: stripe_alloc: order the filesystem error before waking stripe d
+ 69 S1 main ('main', 112) 8a90278a8f82 btrfs: raid56: set a padded rbio's data bitmap under bio_list_lock
+ 70 S1 main ('main', 113) e4a7c166bbdf btrfs: stripe_alloc: forget the failed-claim verdict when a cluster re
+ 71 S1 main ('main', 114) 581ceac7e420 btrfs: stripe_alloc: do not let a remount revert the stripe_alloc prop
+ 72 S1 main ('main', 116) 2f36bb4dd308 btrfs: stripe_alloc: keep the head of a claimed free space entry under
+ 73 S1 part ('part', 119, 1) 4af3107e0ce5 btrfs: stripe_alloc: correct and trim the block group comments (base p
+ 74 S1 part ('part', 120, 1) 23dba7b2f367 btrfs: stripe_alloc: correct and trim the comments outside the block g
+ 75 S1 main ('main', 124) 3a7c9c7fc912 btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID
+ 76 S1 main ('main', 125) 613817ed6569 btrfs: stripe_alloc: count single-data-stripe groups' free space in wr
+ 77 S1 main ('main', 127) dce806a39427 btrfs: stripe_alloc: do not refuse leftover v1 space cache inodes
+ 78 S2 main ('main', 19) 39c81aec088d btrfs: stripe_alloc: isolate nodatacow and preallocated extents by str
+ 79 S2 part ('part', 61, 1) b203727655ae btrfs: stripe_alloc: count nocow run lifecycles and stranded stripes i
+ 80 S2 part ('part', 90, 1) 977fef16d128 btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has
+ 81 S2 part ('part', 91, 1) 467ad0cd9de5 btrfs: stripe_alloc: pad a stripe's allocated sectors whose write is s
+ 82 S2 main ('main', 20) 822a3b83afca btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated
+ 83 S2 part ('part', 34, 1) 70c6aec4b82c btrfs: stripe_alloc: track per-sector liveness and pad from the map (a
+ 84 S2 part ('part', 119, 2) 9b1006cb4e4e btrfs: stripe_alloc: correct and trim the block group comments (allow_
+ 85 S2 part ('part', 76, 1) eeff67cc09d4 btrfs: stripe_alloc: drop the mount options, the property is the inter
+ 86 S2 main ('main', 79) 110d14d02b8c btrfs: stripe_alloc: do not round a full stripe with power-of-two macr
+ 87 S2 part ('part', 119, 3) c367fdbdb781 btrfs: stripe_alloc: correct and trim the block group comments (allow_
+ 88 S2 main ('main', 21) 59f65c17111e btrfs: stripe_alloc: persist nocow runs across commits and remounts
+ 89 S2 part ('part', 25, 1) 77db22426a4a btrfs: stripe_alloc: count open stripe run remainders against data res
+ 90 S2 part ('part', 79, 1) bd0e7389455c btrfs: stripe_alloc: do not round a full stripe with power-of-two macr
+ 91 S2 main ('main', 22) 3ea5f57b8400 btrfs: raid56: do not park sync writes into nocow runs
+ 92 S2 part ('part', 31, 1) 225f941b05be btrfs: stripe_alloc: tunable park deadlines, and say why padding decli
+ 93 S2 main ('main', 58) 474d8c02b35f btrfs: stripe_alloc: do not read an inline backref off a keyed-ref ext
+ 94 S2 main ('main', 60) 9acc5e4d9817 btrfs: stripe_alloc: give nocow extents a private run only while they 
+ 95 S2 main ('main', 78) 47bca69dd077 btrfs: stripe_alloc: close dead nocow stripe runs at commit
+ 96 S2 main ('main', 100) 95acd425f55c btrfs: stripe_alloc: key private stripe runs by subvolume and inode
+ 97 S2 main ('main', 105) 0c7ae8213eb9 btrfs: stripe_alloc: claim a stripe tail in one free space lock sectio
+ 98 S2 main ('main', 115) 603726d9cd66 btrfs: stripe_alloc: do not block a NOWAIT write in the nocow stripe c
+ 99 S2 main ('main', 118) 75e0b51107cb btrfs: stripe_alloc: remove the unused stripe_rmw_opt field
+100 S2 part ('part', 119, 4) 3c099882de7f btrfs: stripe_alloc: correct and trim the block group comments (allow_
+101 S2 part ('part', 120, 2) 494c81b90d4e btrfs: stripe_alloc: correct and trim the comments outside the block g
+102 S3 main ('main', 44) 8c8cc8bd77eb btrfs: stripe_alloc: give a queued stripe group a chunk to relocate in
+103 S3 main ('main', 48) 7de4102a4d8f btrfs: stripe_alloc: hand groups full of trapped free space to the rec
+104 S3 part ('part', 59, 1) bf1cd446c46b btrfs: stripe_alloc: count whole stripes stranded behind live runs as 
+105 S3 main ('main', 49) 21a842d9fe11 btrfs: stripe_alloc: relocate a queued stripe group even while it has 
+106 S3 main ('main', 84) 6f9e455136fc btrfs: stripe_alloc: compact mostly live groups instead of skipping th
+107 S3 part ('part', 88, 1) bf91f0d4a138 btrfs: stripe_alloc: keep relocation's stripe runs until relocation en
+108 S3 main ('main', 85) e4a60a3ec5b3 btrfs: stripe_alloc: compact a mostly live group by its trapped share 
+109 S3 part ('part', 120, 3) 122c58c3e5ff btrfs: stripe_alloc: correct and trim the comments outside the block g
+110 S3 main ('main', 129) 7acf0f28e9bc btrfs: log block group reclaim at debug level
+111 S3 main ('main', 130) d5115b2e98c1 btrfs: stripe_alloc: add stripe_reclaim_now to reclaim stripes on dema
+112 S3 main ('main', 131) 19ad662c33dc btrfs: stripe_alloc: back off block group reclaim after repeated ENOSP
+113 S3 main ('main', 132) 2d2d7926b5eb btrfs: stripe_alloc: let queued exclusive operations in between reclai
+114 S4 main ('main', 14) 375a0fdd6e05 btrfs: stripe_alloc: settle a logged extent's stripes at log commit
+115 S4 part ('part', 25, 2) a0ab721d623e btrfs: stripe_alloc: count open stripe run remainders against data res
+116 S4 part ('part', 81, 1) b80eeb9816d3 btrfs: stripe_alloc: end the commit-time and log drains on an errored 
+117 S4 part ('part', 20, 1) 3c76c61a7ad1 btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated
+118 S4 main ('main', 16) 1e235415b1eb btrfs: stripe_alloc: carry an inode's log tail forward at fsync
+119 S4 part ('part', 79, 2) 9a5f0708dd31 btrfs: stripe_alloc: do not round a full stripe with power-of-two macr
+120 S4 part ('part', 20, 2) 9e4f9baa6964 btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated
+121 S4 main ('main', 17) 979598fbe1cf btrfs: stripe_alloc: kick parked rbios before the fast fsync's writeba
+122 S4 main ('main', 98) 0289d6def8e9 btrfs: stripe_alloc: share LOG data runs per log transaction
+123 S4 part ('part', 100, 1) 209a022c2937 btrfs: stripe_alloc: key private stripe runs by subvolume and inode (f
+124 S4 main ('main', 103) e87fcd378507 btrfs: stripe_alloc: read the shared LOG run mode once per log settle
+125 S4 part ('part', 119, 5) 9fd4b80485f4 btrfs: stripe_alloc: correct and trim the block group comments (fsync 
+126 S4 part ('part', 120, 4) 938994da00db btrfs: stripe_alloc: correct and trim the comments outside the block g
+127 S5 main ('main', 6) 4ac75b8a4bb1 btrfs: add a write-hole invariant checker to the raid56 write path
+128 S5 part ('part', 29, 1) 170943f5e9e5 btrfs: stripe_alloc: report read-modify-write of uncovered stripes (de
+129 S5 part ('part', 20, 3) 5689a5a06af0 btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated
+130 S5 main ('main', 40) f86e194e55dc btrfs: stripe_alloc: drain the legacy allocator's writes before arming
+131 S5 part ('part', 74, 1) 9bcba79cdc75 btrfs: stripe_alloc: say at mount whether the policy is on (debug part
+132 S5 part ('part', 119, 6) df6f2b0b8349 btrfs: stripe_alloc: correct and trim the block group comments (debug 
+133 S5 main ('main', 86) a3ee3341192e btrfs: stripe_alloc: attribute each data read-modify-write to why padd
+134 S5 main ('main', 87) e9643b4023af btrfs: stripe_alloc: optionally audit data read-modify-writes against 
+135 S5 main ('main', 95) 89ab74409c05 btrfs: stripe_alloc: break rbio pins and open stripe runs down by run 
+136 S5 part ('part', 119, 7) fc20fffc8225 btrfs: stripe_alloc: correct and trim the block group comments (debug 
+137 S5 part ('part', 120, 5) e7a3141fea24 btrfs: stripe_alloc: correct and trim the comments outside the block g
+138 S5 main ('main', 123) 7be4b9cd9743 btrfs: stripe_alloc: count and log ordered extents that end with secto
+139 S6 main ('main', 39) 1cc34cf3af9f btrfs: stripe_meta: allocate tree blocks by whole stripes
+drop ('part', 76, 2)
+140 S6 part ('part', 124, 1) 0d50b600e7d6 btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID
+141 S6 new  ('new', 49.5) dd54cf6f46ae btrfs: stripe_meta: extend stripe reclaim to metadata block groups
+142 S6 main ('main', 50) 44ebf7dec6f7 btrfs: stripe_meta: maintain trapped free space for metadata groups li
+143 S6 main ('main', 51) 16e5e268cd2a btrfs: stripe_meta: back the global reserve with usable stripes, and s
+144 S6 main ('main', 52) 444a71ee9ce9 btrfs: stripe_meta: hold back whole stripes so tree blocks always land
+145 S6 part ('part', 59, 2) a9e1cfa23b72 btrfs: stripe_alloc: count whole stripes stranded behind live runs as 
+146 S6 part ('part', 106, 1) 623c09bc14f9 btrfs: stripe_alloc: keep the stripe totals consistent with the groups
+147 S6 part ('part', 125, 1) 5612ec23afce btrfs: stripe_alloc: count single-data-stripe groups' free space in wr
+148 S6 main ('main', 53) 6adeeacb35b6 btrfs: stripe_meta: do not steal from the global reserve below the rel
+149 S6 main ('main', 54) ed5673468a81 btrfs: stripe_meta: let the transaction machinery's own reservations d
+150 S6 main ('main', 55) cc86d4c8d6cf btrfs: stripe_meta: let a group go read-only for relocation against th
+151 S6 main ('main', 67) ce263088ef8d btrfs: stripe_meta: carry raid56 metadata groups through a runtime ena
+152 S6 main ('main', 70) 7623ca1f48ea btrfs: stripe_meta: sync the open-run remainder when the commit retire
+153 S6 main ('main', 71) 25cb59f60440 btrfs: raid56: do not call a covered stripe_meta group uncovered
+154 S6 main ('main', 77) fd3e540dba7c btrfs: stripe_meta: cover raid56 system chunks
+155 S6 main ('main', 82) 8324ff220343 btrfs: stripe_alloc: grant the stripe_meta reserve to all of a relocat
+156 S6 main ('main', 83) d81c1bdb829c btrfs: stripe_meta: let mount-time orphan cleanup steal from the globa
+157 S6 main ('main', 96) c48e7116950c btrfs: stripe_alloc: give each log commit its own metadata stripe run
+158 S6 part ('part', 100, 2) 4190affcd407 btrfs: stripe_alloc: key private stripe runs by subvolume and inode (s
+159 S6 part ('part', 98, 1) 08d404717b8f btrfs: stripe_alloc: share LOG data runs per log transaction (stripe_m
+160 S6 main ('main', 108) a692a2f5f920 btrfs: stripe_meta: commit before waiting for metadata runs when makin
+161 S6 main ('main', 117) 7a84aef78691 btrfs: stripe_meta: check the block group lookup when freeing an unwri
+162 S6 main ('main', 119) b06bdbcf748a btrfs: stripe_alloc: correct and trim the block group comments
+163 S6 main ('main', 120) 0cd7ee714ea0 btrfs: stripe_alloc: correct and trim the comments outside the block g
+164 S6 part ('part', 124, 2) 2d9c221de3f0 btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID
+165 S6 main ('main', 121) 5df0cab05912 btrfs: stripe_meta: keep waiting for metadata runs that do not drain a
+166 S6 main ('main', 126) 4d3e6d1681d4 btrfs: stripe_alloc: account claimable stripes while a trim has them o
+167 S6 main ('main', 128) 15c75f2a0cb7 btrfs: stripe_alloc: do not miss bitmap free space when debiting a tri
+168 S7 part ('part', 123, 1) 51dbc17006ef btrfs: stripe_alloc: count and log ordered extents that end with secto
+169 S7 main ('main', 30) ed411b979a4a btrfs: raid56: say whether a metadata read-modify-write is a write hol
+170 S7 part ('part', 31, 2) 1e6a49e40c81 btrfs: stripe_alloc: tunable park deadlines, and say why padding decli
+171 S7 part ('part', 32, 1) 730786660a0c btrfs: stripe_alloc: trace why padding declined, at the moment it decl
+172 S7 part ('part', 86, 1) 651d73824cf7 btrfs: stripe_alloc: attribute each data read-modify-write to why padd
+173 S7 part ('part', 36, 1) c7f164a43a72 btrfs: raid56: adaptive park deadline from the parked-rbio backlog (de
+174 S7 part ('part', 90, 2) 8e9589ccd4e6 btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has
+175 S7 part ('part', 93, 1) bda1dfa8d437 btrfs: stripe_alloc: count refused rbio pins and track rbio cache high
+176 S7 part ('part', 94, 1) e017434f9f06 btrfs: stripe_alloc: sweep stale rbio pins, and commit when live pins 
+177 S7 main ('main', 57) 41fccbb41511 btrfs: stripe_alloc: tell a dead tree block from a live one in the met
+178 S7 main ('main', 109) b5f9614d6cc0 btrfs: raid56: do not read tree blocks under the stripe lock in the me
+179 S7 part ('part', 120, 6) afe79157dc5d btrfs: stripe_alloc: correct and trim the comments outside the block g
+180 S7 main ('main', 122) 0d329b02edc8 btrfs: stripe_alloc: remove pad refusal reasons that no longer exist
+DONE 0d329b02edc84fcc0f9418472785427998094631 tree c821ac92ab6e4e5e5436b1fda1d6490df59dadfe
diff --git a/scripts/sa-reorder/wreplay-618e.log b/scripts/sa-reorder/wreplay-618e.log
new file mode 100644 (file)
index 0000000..e1fa868
--- /dev/null
@@ -0,0 +1,218 @@
+nomatch: old20 fs/btrfs/block-group.c bool btrfs_stripe_in_open_run(struct btrfs_fs_info *fs_info, u64 logical)
+weave: 42 files
+hunks: 1319
+transfer: old6 fs/btrfs/raid56.c #include "block-group.h" -> old11
+transfer: old39 fs/btrfs/transaction.c #include "raid56.h" -> old94
+transfer: old98 fs/btrfs/disk-io.c fs_info->stripe_log_data_shared = true; -> old98
+force: old76 fs/btrfs/block-group.c hunk with /^static void warn_stripe_alloc_uncovered\(/ -> after old39
+force: old76 fs/btrfs/block-group.c hunk with /^static void warn_stripe_alloc_uncovered\(/ -> after old39
+force: old76 fs/btrfs/block-group.c hunk with /^\twarn_stripe_alloc_uncovered\((fs_)?info\);/ -> after old39
+force: old76 fs/btrfs/block-group.c hunk with /^\twarn_stripe_alloc_uncovered\((fs_)?info\);/ -> after old39
+name split: old90 fs/btrfs/block-group.c 2l: if (run->class == BTRFS_STRIPE_RUN_NOCOW)
+name split: old91 fs/btrfs/block-group.c 1l: run->class != BTRFS_STRIPE_RUN_NOCOW &&
+names: 521 new to the tree, 2 statements split out
+static function definitions tracked: 119
+def move: old131 reclaim_note_result (118, 0) -> (131, 0, 1, 118) (user old131)
+def move: old79 stripe_is_aligned (49, 0) -> (91, 0, 1, 49) (user old79)
+def move: old79 stripe_round_down (49, 0) -> (76, 0, 1, 49) (user old79)
+fixpoint rounds: 4
+  1 S1 old1   main 2e827fd1ae6b h=6 l=376 
+  2 S1 old2   main c187903ef14e h=15 l=519 
+  3 S1 old3   main a6b46c2c7d84 h=42 l=434 
+  4 S1 old4   main 20dc58a67409 h=18 l=173 
+  5 S1 old5   main 861383be216a h=27 l=290 
+  6 S1 old7   main d2da74d91272 h=6 l=105 
+  7 S1 old8   main 1bcfa4509ef9 h=31 l=419 
+  8 S1 old9   main 92913dbc6c94 h=24 l=243 
+  9 S1 old10  main 54d3cc087d76 h=9 l=105 
+ 10 S1 old11  main 96cbfc1207d1 h=23 l=316 transfer into old 11
+ 11 S1 old12  main 7f6eccd7dc7f h=4 l=43 
+ 12 S1 old13  main 3d48b5cf6ab1 h=11 l=202 
+ 13 S1 old15  main e19a741e7eb0 h=24 l=265 
+ 14 S1 old18  main b5cc5976f1ee h=6 l=141 
+ 15 S1 old23  main f92bd75bd1e4 h=12 l=54 
+ 16 S1 old24  main 9dfde5e4f5bb h=4 l=25 
+ 17 S1 old25  main ab18e6391fab h=16 l=70 
+ 18 S1 old26  main e6dc37fb4b74 h=19 l=204 
+ 19 S1 old27  main 49de7831660b h=6 l=217 
+ 20 S1 old28  main 13aba5ab51bd h=2 l=21 
+ 21 S1 old31  main 73462047e56b h=15 l=128 
+ 22 S1 old32  main 346374b7bb0e h=11 l=133 
+ 23 S1 old33  main 61edfbd0933f h=21 l=164 
+ 24 S1 old34  main 2fcdd2ef6d1a h=42 l=477 
+ 25 S1 old35  main 023d8decaa61 h=24 l=144 
+ 26 S1 old36  main 3f959702dc3f h=7 l=32 
+ 27 S1 old37  main 6a32a2e6d6ab h=3 l=39 
+ 28 S1 old38  main 4554c7df8756 h=5 l=50 
+ 29 S1 old41  main 5ec3292d7919 h=2 l=16 
+ 30 S1 old42  main cc6e2ae2ebf0 h=1 l=13 
+ 31 S1 old43  main 1b98b9261d5e h=6 l=28 
+ 32 S1 old45  main 937f0b513521 h=4 l=25 
+ 33 S1 old46  main aa4efe8b1ae2 h=12 l=71 
+ 34 S1 old47  main e4b38e90a7b0 h=1 l=19 
+ 35 S1 old56  main 9ebdac965c84 h=1 l=6 
+ 36 S1 old59  main e305c17ba779 h=11 l=77 
+ 37 S1 old61  main 0cc43a283ba9 h=7 l=43 
+ 38 S1 old62  main 5db8efea1c83 h=1 l=17 
+ 39 S1 old63  main 48b2ccd9c672 h=1 l=14 
+ 40 S1 old64  main 9cb2803f3dca h=17 l=58 
+ 41 S1 old65  main 4b43fce3f767 h=20 l=60 
+ 42 S1 old66  main 456d88dfa646 h=1 l=20 
+ 43 S1 old68  main 7185d3d28ee0 h=18 l=106 
+ 44 S1 old69  main 6278c7b7a114 h=3 l=27 
+ 45 S1 old72  main f5c43d82acad h=4 l=47 
+ 46 S1 old73  main f8e614abdba1 h=1 l=19 
+ 47 S1 old74  main 7cff4d010127 h=5 l=46 
+ 48 S1 old75  main ca7ef903ad3e h=3 l=23 
+ 49 S1 old76  main e06fe11034e8 h=6 l=74 
+ 50 S1 old80  main ad3f2896e3ce h=5 l=44 
+ 51 S1 old81  main 309e25b51c9d h=1 l=13 
+ 52 S1 old88  main 73ec458a10ae h=10 l=62 
+ 53 S1 old89  main acf36554616b h=2 l=32 
+ 54 S1 old90  main 317a40602789 h=23 l=296 
+ 55 S1 old91  main 1dfd7053efea h=13 l=66 
+ 56 S1 old92  main 574baa60c0be h=6 l=65 
+ 57 S1 old93  main 5b1c814ee8d8 h=9 l=69 
+ 58 S1 old94  main 2cb51147e76e h=10 l=94 transfer into old 94
+ 59 S1 old97  main e2d924d30833 h=2 l=26 
+ 60 S1 old99  main cd39d1ef3e0c h=1 l=10 
+ 61 S1 old101 main 40110c9bbfd9 h=4 l=16 
+ 62 S1 old102 main 87d5241d09e2 h=4 l=22 
+ 63 S1 old104 main 72c55dcef8e2 h=2 l=42 
+ 64 S1 old106 main 511c501ef47a h=9 l=108 
+ 65 S1 old107 main bbc0e5b6a789 h=3 l=27 
+ 66 S1 old110 main f5c96773fa2a h=4 l=24 
+ 67 S1 old111 main 967506e6110f h=1 l=7 
+ 68 S1 old112 main b1f59804271b h=1 l=8 
+ 69 S1 old113 main 2f91bdf1aa1c h=1 l=2 
+ 70 S1 old114 main 582f4395c72c h=1 l=10 
+ 71 S1 old116 main 00485b545a2b h=3 l=29 
+ 72 S1 old119 part 4377bf658124 h=29 l=363 subtopic base
+ 73 S1 old120 part 224f6e6d3e9d h=50 l=598 subtopic base
+ 74 S1 old124 main ed9225f02f53 h=6 l=36 
+ 75 S1 old125 main 346cf84ca8de h=18 l=113 
+ 76 S1 old127 main 95496b98d2ae h=5 l=72 
+ 77 S2 old19  main 74baf168fee3 h=17 l=104 
+ 78 S2 old61  part c074161886fa h=1 l=2 uses BTRFS_STRIPE_RUN_NOCOW from old 19
+ 79 S2 old90  part 5d83d98ff4d3 h=1 l=2 uses BTRFS_STRIPE_RUN_NOCOW from old 19
+ 80 S2 old91  part f9781313cc90 h=1 l=1 uses BTRFS_STRIPE_RUN_NOCOW from old 19
+ 81 S2 old20  main bd9e8676c83a h=23 l=371 
+ 82 S2 old34  part 6fcafaeacccb h=1 l=26 deletes a line of old 20
+ 83 S2 old119 part deb5e7cecd74 h=1 l=16 deletes a line of old 34
+ 84 S2 old76  part e908afab4058 h=6 l=29 deletes a line of old 20
+ 85 S2 old79  main 8d3ced1b847b h=2 l=18 defines stripe_round_down for its first user, old 79;deletes a line of old 20
+ 86 S2 old119 part 30727c5ea004 h=1 l=10 deletes a line of old 79
+ 87 S2 old21  main 3241271e9145 h=18 l=299 
+ 88 S2 old25  part 7bed05e78fdd h=1 l=1 sits inside a block of old 21
+ 89 S2 old79  part feade6567840 h=1 l=2 deletes a line of old 21
+ 90 S2 old22  main 825eb3a21fe1 h=2 l=16 
+ 91 S2 old31  part 1f5d33679343 h=1 l=2 deletes a line of old 22
+ 92 S2 old58  main 94934858587b h=1 l=15 
+ 93 S2 old60  main 3afa42e78453 h=6 l=49 
+ 94 S2 old78  main 48f9fcc8ba46 h=8 l=96 
+ 95 S2 old100 main 970b2fab77a5 h=9 l=28 
+ 96 S2 old105 main ba83029c60b5 h=4 l=70 
+ 97 S2 old115 main 632693f70b68 h=4 l=13 
+ 98 S2 old118 main 11b53113a9fc h=2 l=4 
+ 99 S2 old119 part 6b875ab51226 h=9 l=136 subtopic allow_rmw
+100 S2 old120 part 0502b6ca3275 h=6 l=82 subtopic allow_rmw
+101 S3 old48  main 16f30d4dda26 h=9 l=129 
+102 S3 old59  part 238201878c07 h=1 l=8 deletes a line of old 48
+103 S3 old84  main dd4ab7e809cb h=39 l=526 
+104 S3 old88  part 16f5a57416f1 h=2 l=4 sits inside an argument list of old 84
+105 S3 old85  main 73cd430e8aa0 h=5 l=36 
+106 S3 old120 part a5640fba301a h=4 l=55 subtopic reclaim
+107 S3 old132 main 98c6069745b2 h=10 l=86 
+108 S4 old14  main 54b564119d9b h=6 l=113 folded into old 14: deletes a line of old 14
+109 S4 old25  part 6950d502dca9 h=1 l=4 deletes a line of old 14
+110 S4 old81  part 3f5a01689d19 h=1 l=3 deletes a line of old 14
+111 S4 old20  part 74a1044073a7 h=2 l=15 sits inside a block of old 14
+112 S4 old16  main ebc7ca2cf486 h=21 l=308 folded into old 16: deletes a line of old 16;folded into old 16: sits inside a block of old 16
+113 S4 old79  part 9369d4025735 h=2 l=9 defines stripe_is_aligned for its first user, old 79;deletes a line of old 16
+114 S4 old20  part 769d3972d6ec h=1 l=3 sits inside a block of old 16
+115 S4 old17  main 2fe975badcd0 h=3 l=26 folded into old 17: deletes a line of old 17
+116 S4 old98  main 2251c92178fc h=22 l=223 transfer into old 98
+117 S4 old100 part 7ce11d62644b h=2 l=7 deletes a line of old 98
+118 S4 old103 main 1860307c437b h=5 l=12 
+119 S4 old119 part 7c6a8b903efa h=3 l=68 subtopic fsync
+120 S4 old120 part daeeae3e0944 h=7 l=72 subtopic fsync
+121 S5 old39  main be00db80db36 h=34 l=463 
+122 S5 old76  part fb84839711ba h=4 l=54 forced after old 39
+123 S5 old88  part 549f99a2193b h=1 l=13 deletes a line of old 39
+124 S5 old124 part 838c13e76f3e h=1 l=3 deletes a line of old 39
+125 S5 old44  main bfb76c542e0d h=1 l=29 
+126 S5 old84  part c98d0ae7d1b4 h=1 l=6 deletes a line of old 44
+127 S5 old49  main 573abfb10adc h=2 l=11 
+128 S5 old50  main 8dc3da61ac18 h=4 l=21 
+129 S5 old51  main 273df2dc60e3 h=2 l=33 
+130 S5 old52  main 635932ca16e2 h=22 l=118 
+131 S5 old59  part 2ef6b04fa95d h=1 l=5 deletes a line of old 52
+132 S5 old106 part 0a49e04ae019 h=1 l=8 deletes a line of old 52
+133 S5 old125 part 87e506d39f9d h=2 l=5 deletes a line of old 52;joined with its other hunks in fs/btrfs/space-info.c
+134 S5 old53  main 8e9044f56e80 h=1 l=17 
+135 S5 old54  main 679af25602b6 h=1 l=14 
+136 S5 old55  main 782b54a62ff5 h=1 l=9 
+137 S5 old67  main ad117e047dd8 h=3 l=46 
+138 S5 old70  main cb656f23419b h=1 l=8 
+139 S5 old77  main 40427a681b2d h=10 l=86 
+140 S5 old82  main 4167f6c821ec h=4 l=11 
+141 S5 old83  main a82255bbfe77 h=6 l=27 
+142 S5 old96  main 39085f5e3061 h=24 l=283 
+143 S5 old100 part 2c745df313cc h=1 l=1 sits inside a block of old 96
+144 S5 old98  part 93f0670b4f11 h=3 l=19 deletes a line of old 96;sits inside a block of old 96
+145 S5 old108 main 5766c53f685b h=6 l=61 
+146 S5 old117 main 9ae4aec8ef78 h=1 l=10 
+147 S5 old119 main efb0af6e228d h=10 l=173 
+148 S5 old120 main 21cf0b1b9385 h=8 l=130 
+149 S5 old124 part 341889cc6f93 h=1 l=4 deletes a line of old 120
+150 S5 old121 main b3d6b755fb83 h=2 l=21 
+151 S5 old126 main 59cf207ef673 h=13 l=160 
+152 S5 old128 main fc945c82ab7b h=1 l=9 
+153 S5 old130 main 3f1dc4fbc00b h=17 l=265 
+154 S5 old131 main 97d47426f019 h=13 l=111 
+155 S6 old6   main 4d41a9893bd5 h=5 l=80 
+156 S6 old20  part 9548bee47cd6 h=1 l=3 deletes a line of old 6
+157 S6 old39  part 9e214ac4dbb1 h=1 l=9 deletes a line of old 6
+158 S6 old29  main b87a4aa6a0bc h=5 l=48 
+159 S6 old30  main 78521ee1469c h=6 l=144 
+160 S6 old31  part f088cb6e2a0d h=2 l=8 sits inside an argument list of old 30
+161 S6 old32  part ea44a0a86afc h=2 l=2 sits inside an argument list of old 31
+162 S6 old36  part a3351037ae09 h=2 l=8 deletes a line of old 30
+163 S6 old90  part bf4df3cdcc21 h=2 l=4 sits inside an argument list of old 36
+164 S6 old93  part 5b326fc69776 h=2 l=14 sits inside an argument list of old 90
+165 S6 old94  part 1e29640e8eb8 h=2 l=4 sits inside an argument list of old 93
+166 S6 old40  main 168e15d6da40 h=10 l=49 
+167 S6 old74  part 8c6f3d778bee h=1 l=12 deletes a line of old 40
+168 S6 old119 part a8ed8b66efdd h=1 l=6 deletes a line of old 74
+169 S6 old67  part d2d5ac41ba10 h=1 l=9 sits inside a block of old 40
+170 S6 old119 part 7f93aacc35e0 h=1 l=10 deletes a line of old 67
+171 S6 old57  main 9e6ad07c0eb1 h=5 l=98 
+172 S6 old71  main defabdfc069a h=2 l=17 
+173 S6 old77  part 9792c7a18a17 h=1 l=6 deletes a line of old 71
+174 S6 old86  main a4d33651d129 h=21 l=155 
+175 S6 old87  main 9d349fdda876 h=16 l=402 
+176 S6 old95  main f13a0dd63a64 h=11 l=100 folded into old 95: deletes a line of old 95
+177 S6 old109 main f035b02ba196 h=8 l=42 
+178 S6 old119 part 32337aef9f47 h=6 l=63 subtopic debug
+179 S6 old120 part 4d5ca6ac168c h=10 l=106 subtopic debug
+180 S6 old122 main a3df3a6913a6 h=9 l=47 
+181 S6 old123 main 396351d3fe23 h=10 l=58 
+182 S6 old129 main 4b730cea6660 h=3 l=15 
+183 S6 old131 part dd63b3b1b6d3 h=2 l=41 defines reclaim_note_result for its first user, old 131;deletes a line of old 129
+DONE dd63b3b1b6d303ae9d3500d4efdf1d5d04e5bb1c tree a87304c553d7c9c45bec62a44c17a01aba024afa
+torn blocks: 15
+TORN old84 fs/btrfs/block-group.c [{] S3:36l | S5:6l
+TORN old91 fs/btrfs/block-group.c [{] S1:13l | S2:1l
+TORN old106 fs/btrfs/block-group.c [{] S1:38l | S5:8l
+TORN old131 fs/btrfs/block-group.c [{] S5:13l | S6:10l
+TORN old119 fs/btrfs/block-group.h [enum btrfs_stripe_run_class {] S1:9l | S5:23l
+TORN old120 fs/btrfs/btrfs_inode.h [struct btrfs_inode {] S1:11l | S4:9l
+TORN old120 fs/btrfs/extent-tree.c [{] S1:15l | S2:15l
+TORN old120 fs/btrfs/extent-tree.c [{] S2:20l | S5:10l
+TORN old120 fs/btrfs/file.c [{] S1:4l | S4:11l
+TORN old120 fs/btrfs/free-space-cache.c [{] S1:12l | S3:8l
+TORN old120 fs/btrfs/fs.h [struct btrfs_fs_info {] S1:33l | S4:6l | S5:5l | S6:9l
+TORN old31 fs/btrfs/raid56.c [{] S1:12l | S2:2l
+TORN old120 fs/btrfs/raid56.c [{] S1:31l | S2:8l
+TORN old120 fs/btrfs/space-info.h [struct btrfs_space_info {] S1:14l | S5:39l
+TORN old93 fs/btrfs/sysfs.c [{] S1:2l | S6:14l
diff --git a/scripts/sa-reorder/wreplay-618f.log b/scripts/sa-reorder/wreplay-618f.log
new file mode 100644 (file)
index 0000000..ef36c02
--- /dev/null
@@ -0,0 +1,215 @@
+nomatch: old20 fs/btrfs/block-group.c bool btrfs_stripe_in_open_run(struct btrfs_fs_info *fs_info, u64 logical)
+weave: 42 files
+hunks: 1319
+transfer: old6 fs/btrfs/raid56.c #include "block-group.h" -> old11
+transfer: old39 fs/btrfs/transaction.c #include "raid56.h" -> old94
+transfer: old98 fs/btrfs/disk-io.c fs_info->stripe_log_data_shared = true; -> old98
+force: old76 fs/btrfs/block-group.c hunk with /^static void warn_stripe_alloc_uncovered\(/ -> after old39
+force: old76 fs/btrfs/block-group.c hunk with /^static void warn_stripe_alloc_uncovered\(/ -> after old39
+force: old76 fs/btrfs/block-group.c hunk with /^\twarn_stripe_alloc_uncovered\((fs_)?info\);/ -> after old39
+force: old76 fs/btrfs/block-group.c hunk with /^\twarn_stripe_alloc_uncovered\((fs_)?info\);/ -> after old39
+name split: old90 fs/btrfs/block-group.c 2l: if (run->class == BTRFS_STRIPE_RUN_NOCOW)
+name split: old91 fs/btrfs/block-group.c 1l: run->class != BTRFS_STRIPE_RUN_NOCOW &&
+names: 521 new to the tree, 2 statements split out
+static function definitions tracked: 119
+def move: old79 stripe_is_aligned (49, 0) -> (92, 0, 1, 49) (user old79)
+def move: old79 stripe_round_down (49, 0) -> (76, 0, 1, 49) (user old79)
+fixpoint rounds: 4
+  1 S1 old1   main f1fb6b24e09a h=6 l=376 
+  2 S1 old2   main e8edc15396ec h=15 l=519 
+  3 S1 old3   main 43bcc4fd2cfc h=42 l=434 
+  4 S1 old4   main 42aa3d7dcbcf h=18 l=173 
+  5 S1 old5   main 3f0c4f34687e h=27 l=290 
+  6 S1 old7   main f476d6cb9134 h=6 l=105 
+  7 S1 old8   main a408f257db5c h=31 l=419 
+  8 S1 old9   main e978017c95ec h=24 l=243 
+  9 S1 old10  main 32d6e5b21862 h=9 l=105 
+ 10 S1 old11  main 8db07acae63b h=23 l=316 transfer into old 11
+ 11 S1 old12  main 15b0ba61ae7c h=4 l=43 
+ 12 S1 old13  main 94589d3da393 h=11 l=202 
+ 13 S1 old15  main f872665f6d88 h=24 l=265 
+ 14 S1 old18  main ed0e56b3fed4 h=6 l=141 
+ 15 S1 old23  main 3ac38070b042 h=12 l=54 
+ 16 S1 old24  main b9c8c59430b8 h=4 l=25 
+ 17 S1 old25  main a9f15a5d5a5c h=16 l=70 
+ 18 S1 old26  main 2a61af9b8a98 h=19 l=204 
+ 19 S1 old27  main cca8307c1ed9 h=6 l=217 
+ 20 S1 old28  main 21d0b8e6e3c1 h=2 l=21 
+ 21 S1 old31  main 51abe557fe4d h=15 l=128 
+ 22 S1 old32  main d66a042f458a h=11 l=133 
+ 23 S1 old33  main 5e092e369b8b h=21 l=164 
+ 24 S1 old34  main c8480440249c h=42 l=477 
+ 25 S1 old35  main 68179fca8ddc h=24 l=144 
+ 26 S1 old36  main 8f3f0fb36e58 h=7 l=32 
+ 27 S1 old37  main dd54eb269d06 h=3 l=39 
+ 28 S1 old38  main 23e29b0f7c28 h=5 l=50 
+ 29 S1 old41  main 81155b01727f h=2 l=16 
+ 30 S1 old42  main 56525034f953 h=1 l=13 
+ 31 S1 old43  main 7faa104cb1d7 h=6 l=28 
+ 32 S1 old45  main ead738654c1d h=4 l=25 
+ 33 S1 old46  main 9ba19d1a101e h=12 l=71 
+ 34 S1 old47  main 5e8e09150c16 h=1 l=19 
+ 35 S1 old56  main 89c313361981 h=1 l=6 
+ 36 S1 old59  main 1cb7c63e130c h=11 l=77 
+ 37 S1 old61  main b1c3977b7a52 h=7 l=43 
+ 38 S1 old62  main defa122742e1 h=1 l=17 
+ 39 S1 old63  main 51f4b6e934a6 h=1 l=14 
+ 40 S1 old64  main a4ee31981fb2 h=17 l=58 
+ 41 S1 old65  main 5d132954727b h=20 l=60 
+ 42 S1 old66  main a98d0ac753cb h=1 l=20 
+ 43 S1 old68  main 2e5a1c128206 h=18 l=106 
+ 44 S1 old69  main cf1f93208349 h=3 l=27 
+ 45 S1 old72  main 77207ca44b87 h=4 l=47 
+ 46 S1 old73  main 70455c2eea35 h=1 l=19 
+ 47 S1 old74  main cbb340169782 h=5 l=46 
+ 48 S1 old75  main ba9caf5c9100 h=3 l=23 
+ 49 S1 old76  main 992ca76f8e8d h=6 l=74 
+ 50 S1 old80  main 9c9575d40798 h=5 l=44 
+ 51 S1 old81  main 2b4c20a9f550 h=1 l=13 
+ 52 S1 old88  main 49b58086a7ec h=10 l=62 
+ 53 S1 old89  main cfc10c8b2675 h=2 l=32 
+ 54 S1 old90  main 086e61d2ce3d h=23 l=296 
+ 55 S1 old91  main 1f80123eecd4 h=13 l=66 
+ 56 S1 old92  main a427ed913ba9 h=6 l=65 
+ 57 S1 old93  main 57b40d746797 h=9 l=69 
+ 58 S1 old94  main 395e1c4128ba h=10 l=94 transfer into old 94
+ 59 S1 old97  main beb845645ead h=2 l=26 
+ 60 S1 old99  main 2b244bba63ae h=1 l=10 
+ 61 S1 old101 main 8fa0fd2c64d8 h=4 l=16 
+ 62 S1 old102 main ce5bdc6b3461 h=4 l=22 
+ 63 S1 old104 main 3a367110fac2 h=2 l=42 
+ 64 S1 old106 main 0dc67fe3f9ad h=9 l=108 
+ 65 S1 old107 main 853043816fd6 h=3 l=27 
+ 66 S1 old110 main 5d50c9ce4e0e h=4 l=24 
+ 67 S1 old111 main 95296c3e6e24 h=1 l=7 
+ 68 S1 old112 main 7e797daa0269 h=1 l=8 
+ 69 S1 old113 main 3bac12c68f45 h=1 l=2 
+ 70 S1 old114 main 76f3242b6013 h=1 l=10 
+ 71 S1 old116 main 2622d066515f h=3 l=29 
+ 72 S1 old119 part 3d580a3ed4b2 h=29 l=363 subtopic base
+ 73 S1 old120 part 1563229a91c9 h=50 l=598 subtopic base
+ 74 S1 old124 main 06fbe08b5f94 h=6 l=36 
+ 75 S1 old125 main 1a38fdcbb98c h=18 l=113 
+ 76 S1 old127 main b88aceadd456 h=5 l=72 
+ 77 S2 old19  main 1ed5f9188567 h=17 l=104 
+ 78 S2 old61  part 2b6b41d5fac4 h=1 l=2 uses BTRFS_STRIPE_RUN_NOCOW from old 19
+ 79 S2 old90  part 25484b635796 h=1 l=2 uses BTRFS_STRIPE_RUN_NOCOW from old 19
+ 80 S2 old91  part f130f883c849 h=1 l=1 uses BTRFS_STRIPE_RUN_NOCOW from old 19
+ 81 S2 old20  main 651f434f85a0 h=23 l=371 
+ 82 S2 old34  part 2da9f095847d h=1 l=26 deletes a line of old 20
+ 83 S2 old119 part de2da73e5740 h=1 l=16 deletes a line of old 34
+ 84 S2 old76  part 5c2d72d2fc7d h=6 l=29 deletes a line of old 20
+ 85 S2 old79  main 72018f6cba02 h=2 l=18 defines stripe_round_down for its first user, old 79;deletes a line of old 20
+ 86 S2 old119 part 141e19c2219f h=1 l=10 deletes a line of old 79
+ 87 S2 old21  main a9d5bf4fb56e h=18 l=299 
+ 88 S2 old25  part 66b484e8ea45 h=1 l=1 sits inside a block of old 21
+ 89 S2 old79  part 826383514b3c h=1 l=2 deletes a line of old 21
+ 90 S2 old22  main 495f4ca863a8 h=2 l=16 
+ 91 S2 old31  part fb25c06ab280 h=1 l=2 deletes a line of old 22
+ 92 S2 old58  main f3cbf06e0fa7 h=1 l=15 
+ 93 S2 old60  main fdfb78ac6fbb h=6 l=49 
+ 94 S2 old78  main 534eb8bda587 h=8 l=96 
+ 95 S2 old100 main bcf11d2f4e92 h=9 l=28 
+ 96 S2 old105 main cfe63f36276c h=4 l=70 
+ 97 S2 old115 main eaa2f221670b h=4 l=13 
+ 98 S2 old118 main 0a9f46b4ed84 h=2 l=4 
+ 99 S2 old119 part 327234052027 h=9 l=136 subtopic allow_rmw
+100 S2 old120 part 2164967ebada h=6 l=82 subtopic allow_rmw
+101 S3 old48  main 501134bea3be h=9 l=129 
+102 S3 old59  part e4c55f45a0d2 h=1 l=8 deletes a line of old 48
+103 S3 old84  main 53f4c090fce7 h=39 l=526 
+104 S3 old88  part 9ab92aa43aed h=2 l=4 sits inside an argument list of old 84
+105 S3 old85  main 3314c209f1c0 h=5 l=36 
+106 S3 old120 part 826248ea8561 h=4 l=55 subtopic reclaim
+107 S3 old129 main 5c6c82ba1d6d h=3 l=15 
+108 S3 old132 main 2291eab5e9ef h=10 l=86 
+109 S4 old14  main c5947e3adba8 h=6 l=113 folded into old 14: deletes a line of old 14
+110 S4 old25  part 9c8c0685632b h=1 l=4 deletes a line of old 14
+111 S4 old81  part bf6b61f658f1 h=1 l=3 deletes a line of old 14
+112 S4 old20  part e085000420eb h=2 l=15 sits inside a block of old 14
+113 S4 old16  main ce44610a9a4c h=21 l=308 folded into old 16: deletes a line of old 16;folded into old 16: sits inside a block of old 16
+114 S4 old79  part 116f70a0f84d h=2 l=9 defines stripe_is_aligned for its first user, old 79;deletes a line of old 16
+115 S4 old20  part ddd7726dcd6e h=1 l=3 sits inside a block of old 16
+116 S4 old17  main 5e3eeb6cac67 h=3 l=26 folded into old 17: deletes a line of old 17
+117 S4 old98  main 57401c592a8f h=22 l=223 transfer into old 98
+118 S4 old100 part 50bde5c0043b h=2 l=7 deletes a line of old 98
+119 S4 old103 main 106e3411c025 h=5 l=12 
+120 S4 old119 part 019f608a875a h=3 l=68 subtopic fsync
+121 S4 old120 part 6a53563108b5 h=7 l=72 subtopic fsync
+122 S5 old39  main 58ddcdadd43e h=34 l=463 
+123 S5 old76  part 8668713be103 h=4 l=54 forced after old 39
+124 S5 old88  part dbed3efc5cfb h=1 l=13 deletes a line of old 39
+125 S5 old124 part 7f0477323083 h=1 l=3 deletes a line of old 39
+126 S5 old44  main a11357056994 h=1 l=29 
+127 S5 old84  part 47fa38dff494 h=1 l=6 deletes a line of old 44
+128 S5 old49  main 6ea59528adf5 h=2 l=11 
+129 S5 old50  main 8d3f3a0714c8 h=4 l=21 
+130 S5 old51  main 34b417cd9d08 h=2 l=33 
+131 S5 old52  main 7ec0362d18a8 h=22 l=118 
+132 S5 old59  part a17bf79dd02b h=1 l=5 deletes a line of old 52
+133 S5 old106 part 0c09e6a8a1e1 h=1 l=8 deletes a line of old 52
+134 S5 old125 part c26bbe28783a h=2 l=5 deletes a line of old 52;joined with its other hunks in fs/btrfs/space-info.c
+135 S5 old53  main 54b9b848114d h=1 l=17 
+136 S5 old54  main ad84683e4d28 h=1 l=14 
+137 S5 old55  main 2abe5a651bad h=1 l=9 
+138 S5 old67  main e90d568b1157 h=3 l=46 
+139 S5 old70  main 9ce23d959124 h=1 l=8 
+140 S5 old77  main 814344b5424e h=10 l=86 
+141 S5 old82  main 6647214f0444 h=4 l=11 
+142 S5 old83  main 81c2dff3bbff h=6 l=27 
+143 S5 old96  main 65d08d83977a h=24 l=283 
+144 S5 old100 part d292cdeffa64 h=1 l=1 sits inside a block of old 96
+145 S5 old98  part b613eee6f883 h=3 l=19 deletes a line of old 96;sits inside a block of old 96
+146 S5 old108 main 94b25d75aa5a h=6 l=61 
+147 S5 old117 main a0175b256e2a h=1 l=10 
+148 S5 old119 main 0c27b7a889f2 h=10 l=173 
+149 S5 old120 main f947b7ed3d7e h=8 l=130 
+150 S5 old124 part aca8ddef0fd2 h=1 l=4 deletes a line of old 120
+151 S5 old121 main ec76fcc56e34 h=2 l=21 
+152 S5 old126 main 9d05d1192146 h=13 l=160 
+153 S5 old128 main a4a84f08e6f3 h=1 l=9 
+154 S5 old130 main 3f6059c7cc63 h=17 l=265 
+155 S5 old131 main d85fbf21399a h=15 l=152 
+156 S6 old6   main 0518356e544c h=5 l=80 
+157 S6 old20  part 422cedc99b02 h=1 l=3 deletes a line of old 6
+158 S6 old39  part 1fbdccad69b9 h=1 l=9 deletes a line of old 6
+159 S6 old29  main 8dc607ef23ce h=5 l=48 
+160 S6 old30  main f253f5c00e87 h=6 l=144 
+161 S6 old31  part ad9be1104e2e h=2 l=8 sits inside an argument list of old 30
+162 S6 old32  part 7f763b100904 h=2 l=2 sits inside an argument list of old 31
+163 S6 old36  part 57bebf2dd645 h=2 l=8 deletes a line of old 30
+164 S6 old90  part 3ea4575cb0dc h=2 l=4 sits inside an argument list of old 36
+165 S6 old93  part 7181be2dcab0 h=2 l=14 sits inside an argument list of old 90
+166 S6 old94  part aa048f316562 h=2 l=4 sits inside an argument list of old 93
+167 S6 old40  main 256144be5e69 h=10 l=49 
+168 S6 old74  part 61c6a22f0eab h=1 l=12 deletes a line of old 40
+169 S6 old119 part d64499261d18 h=1 l=6 deletes a line of old 74
+170 S6 old67  part fe26bdb953a5 h=1 l=9 sits inside a block of old 40
+171 S6 old119 part 4a0ea32785be h=1 l=10 deletes a line of old 67
+172 S6 old57  main f4ddad3d204c h=5 l=98 
+173 S6 old71  main 7d56c80da0c1 h=2 l=17 
+174 S6 old77  part 40adff4e5dbb h=1 l=6 deletes a line of old 71
+175 S6 old86  main ec045c4c311e h=21 l=155 
+176 S6 old87  main 9b2e4787e557 h=16 l=402 
+177 S6 old95  main 575a3eff1a38 h=11 l=100 folded into old 95: deletes a line of old 95
+178 S6 old109 main d38abf9933fa h=8 l=42 
+179 S6 old119 part f5b4f6210a72 h=6 l=63 subtopic debug
+180 S6 old120 part a7c878fa2110 h=10 l=106 subtopic debug
+181 S6 old122 main 293cd5206003 h=9 l=47 
+182 S6 old123 main 487ff1c5a439 h=10 l=58 
+DONE 487ff1c5a43904f423dcfdbe52da4a5f8dcc1054 tree a87304c553d7c9c45bec62a44c17a01aba024afa
+torn blocks: 14
+TORN old84 fs/btrfs/block-group.c [{] S3:36l | S5:6l
+TORN old91 fs/btrfs/block-group.c [{] S1:13l | S2:1l
+TORN old106 fs/btrfs/block-group.c [{] S1:38l | S5:8l
+TORN old119 fs/btrfs/block-group.h [enum btrfs_stripe_run_class {] S1:9l | S5:23l
+TORN old120 fs/btrfs/btrfs_inode.h [struct btrfs_inode {] S1:11l | S4:9l
+TORN old120 fs/btrfs/extent-tree.c [{] S1:15l | S2:15l
+TORN old120 fs/btrfs/extent-tree.c [{] S2:20l | S5:10l
+TORN old120 fs/btrfs/file.c [{] S1:4l | S4:11l
+TORN old120 fs/btrfs/free-space-cache.c [{] S1:12l | S3:8l
+TORN old120 fs/btrfs/fs.h [struct btrfs_fs_info {] S1:33l | S4:6l | S5:5l | S6:9l
+TORN old31 fs/btrfs/raid56.c [{] S1:12l | S2:2l
+TORN old120 fs/btrfs/raid56.c [{] S1:31l | S2:8l
+TORN old120 fs/btrfs/space-info.h [struct btrfs_space_info {] S1:14l | S5:39l
+TORN old93 fs/btrfs/sysfs.c [{] S1:2l | S6:14l
diff --git a/scripts/sa-reorder/wreplay-w11.json b/scripts/sa-reorder/wreplay-w11.json
new file mode 100644 (file)
index 0000000..d2850ba
--- /dev/null
@@ -0,0 +1,3547 @@
+[
+ {
+  "sha": "1db06c68cf6b51ce11babbdf6992e87999f6a3fb",
+  "key": [
+   0,
+   0
+  ],
+  "src": 1,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 376,
+  "files": [
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: add btrfs_claim_free_stripe_run() for stripe-exclusive allocation"
+ },
+ {
+  "sha": "3e393ff7239eeb5d38b47e29540a63f1e6bb5c0e",
+  "key": [
+   1,
+   0
+  ],
+  "src": 2,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 15,
+  "lines": 519,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/tests/btrfs-tests.c",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: add open stripe run tracking for stripe-exclusive allocation"
+ },
+ {
+  "sha": "5ec2704e997dd044b07c56b847d08c680445c645",
+  "key": [
+   2,
+   0
+  ],
+  "src": 3,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 38,
+  "lines": 423,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/tests/free-space-tests.c",
+   "fs/btrfs/zoned.c",
+   "fs/btrfs/zoned.h"
+  ],
+  "why": [],
+  "subject": "btrfs: add the stripe_alloc allocation policy for raid56 data"
+ },
+ {
+  "sha": "61d6d7930896f3157a12694a96b3d327989feeda",
+  "key": [
+   3,
+   0
+  ],
+  "src": 4,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 162,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/props.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: control the policy with a filesystem property"
+ },
+ {
+  "sha": "ddb68ce2db84fc7038994829c09445693c355876",
+  "key": [
+   4,
+   0
+  ],
+  "src": 5,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 18,
+  "lines": 173,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/ordered-data.h"
+  ],
+  "why": [],
+  "subject": "btrfs: report stripe run data IO through the ordered extent lifecycle"
+ },
+ {
+  "sha": "cd3907757821cc04a06fa748284ac0fb6c950ef9",
+  "key": [
+   5,
+   0
+  ],
+  "src": 6,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 27,
+  "lines": 272,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/ordered-data.h",
+   "fs/btrfs/tests/free-space-tests.c",
+   "fs/btrfs/transaction.c",
+   "fs/btrfs/transaction.h"
+  ],
+  "why": [],
+  "subject": "btrfs: retire stripe runs at commit and gate stripe_alloc"
+ },
+ {
+  "sha": "8bc0ee8eef5836c65576206b49431899d920a765",
+  "key": [
+   6,
+   0
+  ],
+  "src": 8,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 36,
+  "lines": 475,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/super.c",
+   "fs/btrfs/sysfs.c",
+   "fs/btrfs/transaction.c",
+   "include/trace/events/btrfs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: account stripe_alloc trapped free space for honest statfs"
+ },
+ {
+  "sha": "2609ae3c1a449ac0e48e349ca8187ba1fd4f929d",
+  "key": [
+   7,
+   0
+  ],
+  "src": 9,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 24,
+  "lines": 243,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep an open run per size band to trap less"
+ },
+ {
+  "sha": "2229cafe85a1477df8d1d8c028246a7fc44df624",
+  "key": [
+   8,
+   0
+  ],
+  "src": 10,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 105,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: grow the frontier run instead of stranding its tail"
+ },
+ {
+  "sha": "fc4cf0687582402fb9ecdf5276f764d5b04d3979",
+  "key": [
+   9,
+   0
+  ],
+  "src": 11,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 25,
+  "lines": 562,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h"
+  ],
+  "why": [
+   "transfer into old 11"
+  ],
+  "subject": "btrfs: raid56: batch stripe_alloc partial writes into full-stripe writes"
+ },
+ {
+  "sha": "502935f666a90d684c3cee2579ba6214ba481a53",
+  "key": [
+   10,
+   0
+  ],
+  "src": 12,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 43,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: never claim stripes covered by a live run"
+ },
+ {
+  "sha": "d55d0df85803103a9aea601dde3f30e9750e6dcd",
+  "key": [
+   11,
+   0
+  ],
+  "src": 14,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 26,
+  "lines": 276,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/direct-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/file.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/relocation.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: private per-inode stripe runs for log-active inodes"
+ },
+ {
+  "sha": "f267c1768f91b87f7f75f6c62292e167f54df1cd",
+  "key": [
+   12,
+   0
+  ],
+  "src": 17,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 146,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: pad sub-stripe writes to full stripes in open runs"
+ },
+ {
+  "sha": "e578fc18bc829bee1e580f1a6faec25feba67432",
+  "key": [
+   13,
+   0
+  ],
+  "src": 22,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 13,
+  "lines": 54,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: expose parking statistics in sysfs"
+ },
+ {
+  "sha": "b6577eb171f1635445d9e4e900a2837e5fedaf43",
+  "key": [
+   14,
+   0
+  ],
+  "src": 23,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 25,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: skip parking for sync rbios finished by their unplug batch"
+ },
+ {
+  "sha": "b05bc87a4e3432d8b858c1548e84700d5d46a0ec",
+  "key": [
+   15,
+   0
+  ],
+  "src": 24,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 15,
+  "lines": 77,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations"
+ },
+ {
+  "sha": "0298ea9d813226b1b800a237bfb29e8244c4e634",
+  "key": [
+   16,
+   0
+  ],
+  "src": 25,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 34,
+  "lines": 254,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/delalloc-space.h",
+   "fs/btrfs/direct-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/file.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: pessimistic data reservation margin"
+ },
+ {
+  "sha": "1bc2ef92b61725231a060d56ddd7a60c1ac52ac4",
+  "key": [
+   17,
+   0
+  ],
+  "src": 26,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 217,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: claim fully-free stripes that span free space entries"
+ },
+ {
+  "sha": "84e8de54a78241de71d0c2683cf8efa24133212f",
+  "key": [
+   18,
+   0
+  ],
+  "src": 27,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 23,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: warn when raid56 metadata is not covered"
+ },
+ {
+  "sha": "a30d1d41e3d91a3659c573df14035f74e10ee51a",
+  "key": [
+   19,
+   0
+  ],
+  "src": 30,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 15,
+  "lines": 128,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined"
+ },
+ {
+  "sha": "bc07b7a41edafbddb8fa73dd2552be2c359796ad",
+  "key": [
+   20,
+   0
+  ],
+  "src": 31,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 133,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "include/trace/events/btrfs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: trace why padding declined, at the moment it declined"
+ },
+ {
+  "sha": "b531b286f1ee03ed09b6b71d0c69dd7fafa9618d",
+  "key": [
+   21,
+   0
+  ],
+  "src": 32,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 21,
+  "lines": 164,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: complete parked writes on allocation coverage, not clocks"
+ },
+ {
+  "sha": "fd31a3158fcc754cd742af55dd1e6182c8b0c041",
+  "key": [
+   22,
+   0
+  ],
+  "src": 33,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 41,
+  "lines": 476,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: track per-sector liveness and pad from the map"
+ },
+ {
+  "sha": "76b0efb1abe4024b31ba89fcfb2921eb2fbf128f",
+  "key": [
+   23,
+   0
+  ],
+  "src": 34,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 24,
+  "lines": 144,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c",
+   "include/trace/events/btrfs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count claimable whole-stripe supply directly"
+ },
+ {
+  "sha": "ac57920f2f9fed0415945577e5080e7674dcdf07",
+  "key": [
+   24,
+   0
+  ],
+  "src": 35,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 7,
+  "lines": 32,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: adaptive park deadline from the parked-rbio backlog"
+ },
+ {
+  "sha": "8969fea8865ae7eb5d1bec46fc6399d3fef87bb4",
+  "key": [
+   25,
+   0
+  ],
+  "src": 36,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 68,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: gate data admission on claimable whole-stripe supply"
+ },
+ {
+  "sha": "30071977c41daa5cc7031637722c45029ffc10b5",
+  "key": [
+   26,
+   0
+  ],
+  "src": 37,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 50,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: cache a failed stripe run scan per block group"
+ },
+ {
+  "sha": "c41865f8c01810b41baaed59051292cfaf88dc2d",
+  "key": [
+   27,
+   0
+  ],
+  "src": 40,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 25,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep the admitted bytes placeable when a group goes read-only"
+ },
+ {
+  "sha": "8b9b0571deab6d8338a23af5af07f8976a657f9d",
+  "key": [
+   28,
+   0
+  ],
+  "src": 41,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 28,
+  "files": [
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: never let relocation wait on the whole-stripe gate"
+ },
+ {
+  "sha": "9208f45091c9467dc67f9fa48a22ec1c2cd79970",
+  "key": [
+   29,
+   0
+  ],
+  "src": 43,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 47,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: charge relocation a margin per reservation, not per extent"
+ },
+ {
+  "sha": "2c039b0c7679cca68a2761816fc51c09b390977f",
+  "key": [
+   30,
+   0
+  ],
+  "src": 44,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 12,
+  "lines": 129,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep the relocation group's stripes out of the admission supply"
+ },
+ {
+  "sha": "0347f5503c1bedd4d7e2176e6d7ef402a27613a6",
+  "key": [
+   31,
+   0
+  ],
+  "src": 45,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 19,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let a data write fall back to the relocation group rather than drop"
+ },
+ {
+  "sha": "61104edf750f47e967755fc1446ca7a79288b615",
+  "key": [
+   32,
+   0
+  ],
+  "src": 54,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 6,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: show per-group trapped bytes in the space info dump"
+ },
+ {
+  "sha": "8ab7372f16be1a33b2e4829097ea9873c22e2c97",
+  "key": [
+   33,
+   0
+  ],
+  "src": 57,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 77,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped"
+ },
+ {
+  "sha": "7274c1d02a0d038b649d720ae916469ac99ad8a0",
+  "key": [
+   34,
+   0
+  ],
+  "src": 59,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 7,
+  "lines": 43,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count nocow run lifecycles and stranded stripes in sysfs"
+ },
+ {
+  "sha": "cbd6446dffb698e6fafd2773feb27e4b56284070",
+  "key": [
+   35,
+   0
+  ],
+  "src": 60,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 30,
+  "lines": 136,
+  "files": [
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/delalloc-space.h",
+   "fs/btrfs/file.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: hold a stripe of margin across a preallocation"
+ },
+ {
+  "sha": "9bdad85a9c22c62feb8b8975ae955684c9db1ad6",
+  "key": [
+   36,
+   0
+  ],
+  "src": 62,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 27,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: return a group's allocation cluster before scanning its stripes"
+ },
+ {
+  "sha": "7a4c22bb2ca93643aba470c0ddd2d521dcba8661",
+  "key": [
+   37,
+   0
+  ],
+  "src": 63,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 47,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: release open stripe runs when a mount fails or an aborted filesystem unmounts"
+ },
+ {
+  "sha": "405992409920ffa16ce63db77580c1da619ed8d8",
+  "key": [
+   38,
+   0
+  ],
+  "src": 64,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 19,
+  "files": [
+   "fs/btrfs/super.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: say at mount whether the policy is on"
+ },
+ {
+  "sha": "6af34f57384d84993e34a9fddea98b7db9325a49",
+  "key": [
+   40,
+   0
+  ],
+  "src": 68,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 44,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/messages.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not wait for stripe runs to drain on an errored filesystem"
+ },
+ {
+  "sha": "8aa0952968957ce93eab69c63de60a2ee1df2b23",
+  "key": [
+   41,
+   0
+  ],
+  "src": 69,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 13,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: end the commit-time and log drains on an errored filesystem too"
+ },
+ {
+  "sha": "01d2bfb4b0d2ddd106eded5fc2878421d6ce7d83",
+  "key": [
+   42,
+   0
+  ],
+  "src": 73,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 62,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/fs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep relocation's stripe runs until relocation ends"
+ },
+ {
+  "sha": "35afc053ce579f202883cf6d80890cfada48037c",
+  "key": [
+   43,
+   0
+  ],
+  "src": 74,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 32,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let relocation allocate a data chunk before it fails"
+ },
+ {
+  "sha": "91236b877e3917c5e55363fb3f310ccd07fdb49c",
+  "key": [
+   44,
+   0
+  ],
+  "src": 75,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 23,
+  "lines": 296,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it"
+ },
+ {
+  "sha": "7463b35bf86dd1202fe502e8a4549bee76fc2b89",
+  "key": [
+   45,
+   0
+  ],
+  "src": 76,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 13,
+  "lines": 66,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: pad a stripe's allocated sectors whose write is still to come"
+ },
+ {
+  "sha": "7c6ae7354f5fdda5969a1a071239be863da18470",
+  "key": [
+   46,
+   0
+  ],
+  "src": 77,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 65,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/props.c",
+   "fs/btrfs/props.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: apply the property before tree-log replay"
+ },
+ {
+  "sha": "7cf05c1f25c9ec5458e78087865e28c8cfc26c87",
+  "key": [
+   47,
+   0
+  ],
+  "src": 78,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 69,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count refused rbio pins and track rbio cache high water"
+ },
+ {
+  "sha": "f3a28a2274f2fe40bb11b4181635dbc79505f98e",
+  "key": [
+   48,
+   0
+  ],
+  "src": 79,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 94,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/transaction.c"
+  ],
+  "why": [
+   "transfer into old 79"
+  ],
+  "subject": "btrfs: stripe_alloc: sweep stale rbio pins, and commit when live pins run low"
+ },
+ {
+  "sha": "1fafddb8c6cdbeed921efb3d7272f9f9ddaba8e9",
+  "key": [
+   49,
+   0
+  ],
+  "src": 82,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 26,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: don't make a parked rbio wait for sectors that will never be written"
+ },
+ {
+  "sha": "5e3fba15101db40f9e82048cd8c6f26a1392b361",
+  "key": [
+   50,
+   0
+  ],
+  "src": 84,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let relocation allocate as many data chunks as its reservation needs"
+ },
+ {
+  "sha": "ee220a9bf3dfb0bd657b8742703bf308dcdcff5c",
+  "key": [
+   51,
+   0
+  ],
+  "src": 86,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 16,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not treat an allocation error as a found extent"
+ },
+ {
+  "sha": "7ee09b5cd546f5f70208f3c24ecd305e7a46afcd",
+  "key": [
+   52,
+   0
+  ],
+  "src": 87,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 22,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/ordered-data.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: mark an ended ordered extent's sectors written"
+ },
+ {
+  "sha": "3945813870127246ae412f7e17ca159189ca8776",
+  "key": [
+   53,
+   0
+  ],
+  "src": 89,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 42,
+  "files": [
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: remove only the set bits of a bitmap when claiming a split run"
+ },
+ {
+  "sha": "d77f5f3738b2e1896a0e99e9e3743b1ea94ce451",
+  "key": [
+   54,
+   0
+  ],
+  "src": 91,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 108,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep the stripe totals consistent with the groups during the commit scan"
+ },
+ {
+  "sha": "cd942bb70a6e4d6e68b1de0e94eb0e772b444a88",
+  "key": [
+   55,
+   0
+  ],
+  "src": 92,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 27,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not delete an unused block group that still has stripe runs"
+ },
+ {
+  "sha": "d1723ff8c20e2f2c94a48e1c3384bd2815be91bd",
+  "key": [
+   56,
+   0
+  ],
+  "src": 95,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 24,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: stop the park timer before destroying the raid56 workqueue"
+ },
+ {
+  "sha": "d45f75dcc4c6ff3a9e692bf27b34caa713a048e6",
+  "key": [
+   57,
+   0
+  ],
+  "src": 96,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 7,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: order the filesystem error before waking stripe drain waiters"
+ },
+ {
+  "sha": "cf3970756d173c0dd8de42f2c05f2bb2a0fffaaa",
+  "key": [
+   58,
+   0
+  ],
+  "src": 97,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: set a padded rbio's data bitmap under bio_list_lock"
+ },
+ {
+  "sha": "503695f8e307dc0284ada7a1f058a87159e98f3a",
+  "key": [
+   59,
+   0
+  ],
+  "src": 98,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: forget the failed-claim verdict when a cluster returns its space"
+ },
+ {
+  "sha": "eda196461a4b0294ae7bdf2de8b800760e0accf5",
+  "key": [
+   60,
+   0
+  ],
+  "src": 99,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/super.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not let a remount revert the stripe_alloc property"
+ },
+ {
+  "sha": "6016b4124a0dd70ff5d3d78188aa75ff96364bf0",
+  "key": [
+   61,
+   0
+  ],
+  "src": 101,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 29,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep the head of a claimed free space entry under the lock"
+ },
+ {
+  "sha": "f9a935243029efefbd71d7dfc69c6ec45d06aad5",
+  "key": [
+   61,
+   0,
+   1,
+   97
+  ],
+  "src": 104,
+  "sub": 1,
+  "tag": "base",
+  "kind": "part",
+  "hunks": 29,
+  "lines": 363,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h"
+  ],
+  "why": [
+   "subtopic base"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (base part)"
+ },
+ {
+  "sha": "e222701ac5fe2e74848792e298f4a389c709dbb7",
+  "key": [
+   61,
+   0,
+   1,
+   98
+  ],
+  "src": 105,
+  "sub": 1,
+  "tag": "base",
+  "kind": "part",
+  "hunks": 50,
+  "lines": 598,
+  "files": [
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/file.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/props.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/super.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "subtopic base"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (base part)"
+ },
+ {
+  "sha": "ea62bfb4fa3afa96345c01b60043eb3502a0072a",
+  "key": [
+   62,
+   0
+  ],
+  "src": 109,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 36,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/volumes.c",
+   "fs/btrfs/volumes.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3"
+ },
+ {
+  "sha": "d2fbc459cbccd945fc18b556084d321a3f99039d",
+  "key": [
+   63,
+   0
+  ],
+  "src": 110,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 18,
+  "lines": 113,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count single-data-stripe groups' free space in write admission"
+ },
+ {
+  "sha": "6dc1829df3d7ae4333b57db1f8ca1b1825b7706c",
+  "key": [
+   64,
+   0
+  ],
+  "src": 18,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 19,
+  "lines": 110,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/direct-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/relocation.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: isolate nodatacow and preallocated extents by stripe"
+ },
+ {
+  "sha": "dde7a882697f6fb451e6b39d1e7d46eed1a5fe27",
+  "key": [
+   64,
+   0,
+   1,
+   34
+  ],
+  "src": 59,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "uses BTRFS_STRIPE_RUN_NOCOW from old 18"
+  ],
+  "subject": "btrfs: stripe_alloc: count nocow run lifecycles and stranded stripes in sysfs (allow_rmw part)"
+ },
+ {
+  "sha": "af2033878148c6a671b21ce0878b201cb9de4dcd",
+  "key": [
+   64,
+   0,
+   1,
+   44
+  ],
+  "src": 75,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "uses BTRFS_STRIPE_RUN_NOCOW from old 18"
+  ],
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it (allow_rmw part)"
+ },
+ {
+  "sha": "68fdab640a3dd4b9b2b678d8605f1a1586339d56",
+  "key": [
+   64,
+   0,
+   1,
+   45
+  ],
+  "src": 76,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 1,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "uses BTRFS_STRIPE_RUN_NOCOW from old 18"
+  ],
+  "subject": "btrfs: stripe_alloc: pad a stripe's allocated sectors whose write is still to come (allow_rmw part)"
+ },
+ {
+  "sha": "949fdf05cc22afc6d30a37f7e5efccf2398ca4cf",
+  "key": [
+   65,
+   0
+  ],
+  "src": 19,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 17,
+  "lines": 351,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/file.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/props.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents"
+ },
+ {
+  "sha": "79a9d13f0b70c6a9b07827b4bc013752bc5b58cb",
+  "key": [
+   65,
+   0,
+   1,
+   22
+  ],
+  "src": 33,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 26,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 19"
+  ],
+  "subject": "btrfs: stripe_alloc: track per-sector liveness and pad from the map (allow_rmw part)"
+ },
+ {
+  "sha": "2dac86126de50bbe53a2750be67956d042c512c1",
+  "key": [
+   65,
+   0,
+   1,
+   22,
+   1,
+   97
+  ],
+  "src": 104,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 16,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 33"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part)"
+ },
+ {
+  "sha": "4b0aa08e98881d312b644968e73dfac57095f2d6",
+  "key": [
+   65,
+   0,
+   1,
+   39
+  ],
+  "src": 67,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 18,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "defines stripe_round_down for its first user, old 67",
+   "deletes a line of old 19"
+  ],
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros"
+ },
+ {
+  "sha": "58fd06eda45e458a68b1d216899352e2a1c7312a",
+  "key": [
+   65,
+   0,
+   1,
+   39,
+   1,
+   97
+  ],
+  "src": 104,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 67"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part 2)"
+ },
+ {
+  "sha": "6508d50063fe48ee98871576a2030258afdaf301",
+  "key": [
+   66,
+   0
+  ],
+  "src": 20,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 18,
+  "lines": 299,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/inode.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: persist nocow runs across commits and remounts"
+ },
+ {
+  "sha": "baf15bc76a17c8db817fb544822ae58797c9a750",
+  "key": [
+   66,
+   0,
+   1,
+   15
+  ],
+  "src": 24,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 1,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "sits inside a block of old 20"
+  ],
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations (allow_rmw part)"
+ },
+ {
+  "sha": "4ebd3b5e0d97affcd3176dcf2c921799f6e81bfe",
+  "key": [
+   66,
+   0,
+   1,
+   39
+  ],
+  "src": 67,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 20"
+  ],
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros (allow_rmw part 2)"
+ },
+ {
+  "sha": "3d199e8456cedb683d347772577f5b93c7e6148c",
+  "key": [
+   67,
+   0
+  ],
+  "src": 21,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 16,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: do not park sync writes into nocow runs"
+ },
+ {
+  "sha": "9a6cf49d44881dc3f611884b82cd9ef427deb8d5",
+  "key": [
+   67,
+   0,
+   1,
+   19
+  ],
+  "src": 30,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [
+   "deletes a line of old 21"
+  ],
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined (allow_rmw part)"
+ },
+ {
+  "sha": "08686e0ba668994eb5ffff34e46f73d1fca35996",
+  "key": [
+   68,
+   0
+  ],
+  "src": 56,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 15,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not read an inline backref off a keyed-ref extent item"
+ },
+ {
+  "sha": "66d858a60848d365368b83440bc43fc1096b1811",
+  "key": [
+   69,
+   0
+  ],
+  "src": 58,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 49,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: give nocow extents a private run only while they may be written in place"
+ },
+ {
+  "sha": "310ac184dc8bb1d7b1290df09887e79a8c990835",
+  "key": [
+   70,
+   0
+  ],
+  "src": 66,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 8,
+  "lines": 96,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: close dead nocow stripe runs at commit"
+ },
+ {
+  "sha": "869e5bc6a77a1868332f20cc075e8733a4a96abe",
+  "key": [
+   71,
+   0
+  ],
+  "src": 85,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 28,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode"
+ },
+ {
+  "sha": "ae40d00f2f5bdb8f0190cb2f7b874e644d1aa415",
+  "key": [
+   72,
+   0
+  ],
+  "src": 90,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 70,
+  "files": [
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: claim a stripe tail in one free space lock section"
+ },
+ {
+  "sha": "f76c0c931feb5163a48b8ba0dae15b37f3808bfc",
+  "key": [
+   73,
+   0
+  ],
+  "src": 100,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 13,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/inode.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not block a NOWAIT write in the nocow stripe check"
+ },
+ {
+  "sha": "50c8c58043d728e69be8f584131a63e89017d7d5",
+  "key": [
+   74,
+   0
+  ],
+  "src": 103,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/fs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: remove the unused stripe_rmw_opt field"
+ },
+ {
+  "sha": "eee43c57a398f6c304dea24018001ca9d737142b",
+  "key": [
+   74,
+   0,
+   1,
+   97
+  ],
+  "src": 104,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 9,
+  "lines": 136,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h"
+  ],
+  "why": [
+   "subtopic allow_rmw"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part 3)"
+ },
+ {
+  "sha": "0b74060ef8457ec121ed5f79eff17307e35c605c",
+  "key": [
+   74,
+   0,
+   1,
+   98
+  ],
+  "src": 105,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 6,
+  "lines": 82,
+  "files": [
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [
+   "subtopic allow_rmw"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (allow_rmw part)"
+ },
+ {
+  "sha": "b1dbeb623f6b98cb11d5eb3c1488640623665bf5",
+  "key": [
+   75,
+   0
+  ],
+  "src": 46,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 129,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: hand groups full of trapped free space to the reclaim worker"
+ },
+ {
+  "sha": "bdecd54ace7a2c1d2f2b5b7b6c413e8ecf86e54e",
+  "key": [
+   75,
+   0,
+   1,
+   33
+  ],
+  "src": 57,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [
+   "deletes a line of old 46"
+  ],
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped (reclaim part)"
+ },
+ {
+  "sha": "06a7f9ab4bad06d4b2082432b656298e5822c23c",
+  "key": [
+   76,
+   0
+  ],
+  "src": 70,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 40,
+  "lines": 547,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/relocation.h",
+   "fs/btrfs/sysfs.c",
+   "fs/btrfs/volumes.c",
+   "fs/btrfs/volumes.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: compact mostly live groups instead of skipping them"
+ },
+ {
+  "sha": "0595cc48fdbba8a79329dd94b34ebf667a1fb44d",
+  "key": [
+   76,
+   0,
+   1,
+   42
+  ],
+  "src": 73,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 70"
+  ],
+  "subject": "btrfs: stripe_alloc: keep relocation's stripe runs until relocation ends (reclaim part)"
+ },
+ {
+  "sha": "2c1c1b62f0e455f59aaa53ae1aac84803b0aed5d",
+  "key": [
+   76,
+   0,
+   1,
+   98
+  ],
+  "src": 105,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "part",
+  "hunks": 4,
+  "lines": 55,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [
+   "subtopic reclaim"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (reclaim part)"
+ },
+ {
+  "sha": "da6ce58a728de47efec4fb8bf1a130b1f4f4ba86",
+  "key": [
+   77,
+   0
+  ],
+  "src": 116,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 86,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/fs.c",
+   "fs/btrfs/fs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let queued exclusive operations in between reclaims"
+ },
+ {
+  "sha": "b31137fefcc76293b58833a236422e503c04c6d8",
+  "key": [
+   78,
+   0
+  ],
+  "src": 13,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 113,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/tree-log.c"
+  ],
+  "why": [
+   "folded into old 13: deletes a line of old 13"
+  ],
+  "subject": "btrfs: stripe_alloc: settle a logged extent's stripes at log commit"
+ },
+ {
+  "sha": "2417b432126a28918e2f25cb6178e9a8e1d17403",
+  "key": [
+   78,
+   0,
+   1,
+   15
+  ],
+  "src": 24,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 13"
+  ],
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations (fsync part)"
+ },
+ {
+  "sha": "d7e978ba9e6ff440772f23cf66bfd1fb4530823b",
+  "key": [
+   78,
+   0,
+   1,
+   41
+  ],
+  "src": 69,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 3,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 13"
+  ],
+  "subject": "btrfs: stripe_alloc: end the commit-time and log drains on an errored filesystem too (fsync part)"
+ },
+ {
+  "sha": "4254ae23648a00a2ac33c8777eeb623a3e644d0f",
+  "key": [
+   78,
+   0,
+   1,
+   65
+  ],
+  "src": 19,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 15,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "sits inside a block of old 13"
+  ],
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (fsync part)"
+ },
+ {
+  "sha": "22d4aefc3583d913b285693b07f699c17b096ccc",
+  "key": [
+   79,
+   0
+  ],
+  "src": 15,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 21,
+  "lines": 308,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/defrag.c",
+   "fs/btrfs/defrag.h",
+   "fs/btrfs/file.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/tree-log.c"
+  ],
+  "why": [
+   "folded into old 15: deletes a line of old 15",
+   "folded into old 15: sits inside a block of old 15"
+  ],
+  "subject": "btrfs: stripe_alloc: carry an inode's log tail forward at fsync"
+ },
+ {
+  "sha": "5d63d4ae3f071561e5b9bee6bb486de6c08370f7",
+  "key": [
+   79,
+   0,
+   1,
+   39
+  ],
+  "src": 67,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 9,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "defines stripe_is_aligned for its first user, old 67",
+   "deletes a line of old 15"
+  ],
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros (fsync part)"
+ },
+ {
+  "sha": "ce7b2869c242a27aba00bbd38ae7d9f180ac252b",
+  "key": [
+   79,
+   0,
+   1,
+   65
+  ],
+  "src": 19,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 3,
+  "files": [
+   "fs/btrfs/defrag.c"
+  ],
+  "why": [
+   "sits inside a block of old 15"
+  ],
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (fsync part 2)"
+ },
+ {
+  "sha": "1d253ef2c3f3b077d2d8e6e8cd577617dea75c22",
+  "key": [
+   80,
+   0
+  ],
+  "src": 16,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 26,
+  "files": [
+   "fs/btrfs/file.c"
+  ],
+  "why": [
+   "folded into old 16: deletes a line of old 16"
+  ],
+  "subject": "btrfs: stripe_alloc: kick parked rbios before the fast fsync's writeback wait"
+ },
+ {
+  "sha": "cd3d2516fd213900a316f03860b28027c79ec4c3",
+  "key": [
+   81,
+   0
+  ],
+  "src": 83,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 22,
+  "lines": 223,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/defrag.c",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "transfer into old 83"
+  ],
+  "subject": "btrfs: stripe_alloc: share LOG data runs per log transaction"
+ },
+ {
+  "sha": "f1798faa62009d0ac0a0a637daaf9cd1a0fe9c9c",
+  "key": [
+   81,
+   0,
+   1,
+   71
+  ],
+  "src": 85,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 7,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 83"
+  ],
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode (fsync part)"
+ },
+ {
+  "sha": "bfdf2ef6b26a8412d9f7801430d1cf2046dcf1a3",
+  "key": [
+   82,
+   0
+  ],
+  "src": 88,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 12,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: read the shared LOG run mode once per log settle"
+ },
+ {
+  "sha": "ccf4ba23cd9e6db64ca6bac96de6141cc61cbfaa",
+  "key": [
+   82,
+   0,
+   1,
+   97
+  ],
+  "src": 104,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 3,
+  "lines": 68,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "subtopic fsync"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (fsync part)"
+ },
+ {
+  "sha": "7af777f69b0568f75cbfb0d953bea0f028fa3a72",
+  "key": [
+   82,
+   0,
+   1,
+   98
+  ],
+  "src": 105,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 7,
+  "lines": 72,
+  "files": [
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/defrag.c",
+   "fs/btrfs/file.c",
+   "fs/btrfs/fs.h"
+  ],
+  "why": [
+   "subtopic fsync"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (fsync part)"
+ },
+ {
+  "sha": "71593c72f888a8dd5a39daad9208be50416ca913",
+  "key": [
+   83,
+   0
+  ],
+  "src": 38,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 34,
+  "lines": 471,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent_io.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/transaction.c",
+   "fs/btrfs/tree-log.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: allocate tree blocks by whole stripes"
+ },
+ {
+  "sha": "948e74c0f88548a76f99d2b9fb192bd565cf4607",
+  "key": [
+   83,
+   0,
+   1,
+   42
+  ],
+  "src": 73,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 13,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 38"
+  ],
+  "subject": "btrfs: stripe_alloc: keep relocation's stripe runs until relocation ends (stripe_meta part)"
+ },
+ {
+  "sha": "4db297c53633e401592e327836eb5b7fb7a2e585",
+  "key": [
+   83,
+   0,
+   1,
+   62
+  ],
+  "src": 109,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 3,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [
+   "deletes a line of old 38"
+  ],
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3 (stripe_meta part)"
+ },
+ {
+  "sha": "93a2a0aa59188eb3de28e5ed908870dc446a44c6",
+  "key": [
+   84,
+   0
+  ],
+  "src": 42,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 28,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: give a queued stripe group a chunk to relocate into when the supply is short"
+ },
+ {
+  "sha": "b917014d18a67a3b8492853d4d0326fc760d80f2",
+  "key": [
+   84,
+   0,
+   1,
+   76
+  ],
+  "src": 70,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 6,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 42"
+  ],
+  "subject": "btrfs: stripe_alloc: compact mostly live groups instead of skipping them (stripe_meta part)"
+ },
+ {
+  "sha": "8afa50a9d46d69d1b22793b338aaeed0c299b30b",
+  "key": [
+   85,
+   0
+  ],
+  "src": 47,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 11,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: relocate a queued stripe group even while it has reserved or pinned bytes"
+ },
+ {
+  "sha": "3e227b8c1df4c8551ad94b02a6b22a66fa36d020",
+  "key": [
+   86,
+   0
+  ],
+  "src": 48,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 22,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: maintain trapped free space for metadata groups like data"
+ },
+ {
+  "sha": "57df9590f75e212cca342c169d5901038c9fd238",
+  "key": [
+   87,
+   0
+  ],
+  "src": 49,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 33,
+  "files": [
+   "fs/btrfs/block-rsv.c",
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: back the global reserve with usable stripes, and say when a tree block finds none"
+ },
+ {
+  "sha": "e31746f58533b896cc8037b50aa6fa926412d822",
+  "key": [
+   88,
+   0
+  ],
+  "src": 50,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 24,
+  "lines": 135,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: hold back whole stripes so tree blocks always land and trapped groups can be reclaimed"
+ },
+ {
+  "sha": "3e17ca92e38c3612449e1e84f496174656c2b306",
+  "key": [
+   88,
+   0,
+   1,
+   33
+  ],
+  "src": 57,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 5,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [
+   "deletes a line of old 50"
+  ],
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped (stripe_meta part)"
+ },
+ {
+  "sha": "0d40368070cdb0eeaddc4a3dceeab5a59fe87681",
+  "key": [
+   88,
+   0,
+   1,
+   54
+  ],
+  "src": 91,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 50"
+  ],
+  "subject": "btrfs: stripe_alloc: keep the stripe totals consistent with the groups during the commit scan (stripe_meta part)"
+ },
+ {
+  "sha": "a50c66202de2ed026a9127f294abbf5b4bf76775",
+  "key": [
+   88,
+   0,
+   1,
+   63
+  ],
+  "src": 110,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 5,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [
+   "deletes a line of old 50",
+   "joined with its other hunks in fs/btrfs/space-info.c"
+  ],
+  "subject": "btrfs: stripe_alloc: count single-data-stripe groups' free space in write admission (stripe_meta part)"
+ },
+ {
+  "sha": "f38742ef467d437c14a999f3501c292ef49b6a8b",
+  "key": [
+   89,
+   0
+  ],
+  "src": 51,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 42,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: do not steal from the global reserve below the relocation reserve"
+ },
+ {
+  "sha": "fe01db5e6d18dd820853884ab336b0bfbdb6e3b2",
+  "key": [
+   90,
+   0
+  ],
+  "src": 52,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 14,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: let the transaction machinery's own reservations draw on the reserve"
+ },
+ {
+  "sha": "cc528deb79377f3ea76bbe9104c7f2c9203c6883",
+  "key": [
+   91,
+   0
+  ],
+  "src": 53,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 9,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: let a group go read-only for relocation against the reserve"
+ },
+ {
+  "sha": "36d1a658434317158a4dc8a0265307e637168427",
+  "key": [
+   92,
+   0
+  ],
+  "src": 61,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 46,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: carry raid56 metadata groups through a runtime enable or disable"
+ },
+ {
+  "sha": "9e8c0ef7c30e6a2ee141bdffd4e26b1d4cbc7bf0",
+  "key": [
+   93,
+   0
+  ],
+  "src": 65,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 85,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: cover raid56 system chunks"
+ },
+ {
+  "sha": "b6030490bd37d190e1a373f677e90661c3fb44f0",
+  "key": [
+   94,
+   0
+  ],
+  "src": 81,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 24,
+  "lines": 283,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: give each log commit its own metadata stripe run"
+ },
+ {
+  "sha": "1f4ad2cb79385c9de0ac18f2e13f59ef6946d5fb",
+  "key": [
+   94,
+   0,
+   1,
+   71
+  ],
+  "src": 85,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 1,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "sits inside a block of old 81"
+  ],
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode (stripe_meta part)"
+ },
+ {
+  "sha": "0265f5a05cab265cf88d420e536112bbbe5deaed",
+  "key": [
+   94,
+   0,
+   1,
+   81
+  ],
+  "src": 83,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 3,
+  "lines": 19,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "deletes a line of old 81",
+   "sits inside a block of old 81"
+  ],
+  "subject": "btrfs: stripe_alloc: share LOG data runs per log transaction (stripe_meta part)"
+ },
+ {
+  "sha": "9634bbd9d251500e636f9a4a9abe2220abc8ec84",
+  "key": [
+   95,
+   0
+  ],
+  "src": 93,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 61,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: commit before waiting for metadata runs when making a group read-only"
+ },
+ {
+  "sha": "6302c206dd53771bbdea09a142e20b2920c712f5",
+  "key": [
+   96,
+   0
+  ],
+  "src": 102,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: check the block group lookup when freeing an unwritten tree block"
+ },
+ {
+  "sha": "9867a33694f842225e6fa4233fa9980920cd19eb",
+  "key": [
+   97,
+   0
+  ],
+  "src": 104,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 185,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments"
+ },
+ {
+  "sha": "54cc964358f7b7924253dd257a5616ecfbf080e2",
+  "key": [
+   98,
+   0
+  ],
+  "src": 105,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 8,
+  "lines": 130,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code"
+ },
+ {
+  "sha": "05f0157f78a57db01d64959fc90f00e3d57f78eb",
+  "key": [
+   98,
+   0,
+   1,
+   62
+  ],
+  "src": 109,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [
+   "deletes a line of old 105"
+  ],
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3 (stripe_meta part 2)"
+ },
+ {
+  "sha": "abb9d051b7d5e2572db580a1d44fec0c91511147",
+  "key": [
+   99,
+   0
+  ],
+  "src": 106,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 21,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: keep waiting for metadata runs that do not drain at commit"
+ },
+ {
+  "sha": "4a5d9541cdc0140259eeddb2cb735a328cab991a",
+  "key": [
+   100,
+   0
+  ],
+  "src": 111,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 13,
+  "lines": 160,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: account claimable stripes while a trim has them out"
+ },
+ {
+  "sha": "96e59a369c588f5b2c84b3a97cca14ec3fb9eda1",
+  "key": [
+   101,
+   0
+  ],
+  "src": 112,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 9,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not miss bitmap free space when debiting a trim"
+ },
+ {
+  "sha": "37fe3245fc13673796b3ea250825f249a7d40dc3",
+  "key": [
+   102,
+   0
+  ],
+  "src": 114,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 17,
+  "lines": 264,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: add stripe_reclaim_now to reclaim stripes on demand"
+ },
+ {
+  "sha": "1d41ff6032a1cb116796063a72a74f958c6eb861",
+  "key": [
+   103,
+   0
+  ],
+  "src": 115,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 14,
+  "lines": 151,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: back off block group reclaim after repeated ENOSPC"
+ },
+ {
+  "sha": "4a21c74ddaca79af5c4db7cb0a067ddff137a350",
+  "key": [
+   104,
+   0
+  ],
+  "src": 7,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 79,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: add a write-hole invariant checker to the raid56 write path"
+ },
+ {
+  "sha": "410c35dfdc4e32e13a6a058abd4e250f5c7cba35",
+  "key": [
+   104,
+   0,
+   1,
+   65
+  ],
+  "src": 19,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 3,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 7"
+  ],
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (debug part)"
+ },
+ {
+  "sha": "5ead45f4afa8969de3c19d1aa992567a76fd5c0a",
+  "key": [
+   104,
+   0,
+   1,
+   83
+  ],
+  "src": 38,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 9,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 7"
+  ],
+  "subject": "btrfs: stripe_meta: allocate tree blocks by whole stripes (debug part)"
+ },
+ {
+  "sha": "898a6c145e988df428cf24684312fffdeb67974c",
+  "key": [
+   105,
+   0
+  ],
+  "src": 28,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 48,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: report read-modify-write of uncovered stripes"
+ },
+ {
+  "sha": "9bc49da4dcb7f8df2331672a979a7095c3acee87",
+  "key": [
+   105,
+   0,
+   1,
+   83
+  ],
+  "src": 38,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 17,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [
+   "sits inside a block of old 28"
+  ],
+  "subject": "btrfs: stripe_meta: allocate tree blocks by whole stripes (debug part 2)"
+ },
+ {
+  "sha": "78a4b5aed1e949234ebfc8ac16a9ca974267300f",
+  "key": [
+   105,
+   0,
+   1,
+   83,
+   1,
+   93
+  ],
+  "src": 65,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 6,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [
+   "deletes a line of old 38"
+  ],
+  "subject": "btrfs: stripe_meta: cover raid56 system chunks (debug part)"
+ },
+ {
+  "sha": "5242b8f5c10628d3fe910d8960c5c30cdf29da8b",
+  "key": [
+   105,
+   0,
+   1,
+   83,
+   1,
+   93,
+   1,
+   98
+  ],
+  "src": 105,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 11,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [
+   "deletes a line of old 65"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (debug part)"
+ },
+ {
+  "sha": "1cc1de08aec9e32a2389ce0a6146006307a5982e",
+  "key": [
+   106,
+   0
+  ],
+  "src": 29,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 146,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: say whether a metadata read-modify-write is a write hole"
+ },
+ {
+  "sha": "c758f28d0ee1a1561541273e34a8c13e7a88e3bd",
+  "key": [
+   106,
+   0,
+   1,
+   19
+  ],
+  "src": 30,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 29"
+  ],
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined (debug part)"
+ },
+ {
+  "sha": "1c324dd49385a666858422b21da0f60132a61c43",
+  "key": [
+   106,
+   0,
+   1,
+   19,
+   1,
+   20
+  ],
+  "src": 31,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 30"
+  ],
+  "subject": "btrfs: stripe_alloc: trace why padding declined, at the moment it declined (debug part)"
+ },
+ {
+  "sha": "1443c2d29db05db059f0d55363222469bbf99302",
+  "key": [
+   106,
+   0,
+   1,
+   24
+  ],
+  "src": 35,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "deletes a line of old 29"
+  ],
+  "subject": "btrfs: raid56: adaptive park deadline from the parked-rbio backlog (debug part)"
+ },
+ {
+  "sha": "fbcd95a6bd75027cfc0e69586592393d2f895b21",
+  "key": [
+   106,
+   0,
+   1,
+   24,
+   1,
+   44
+  ],
+  "src": 75,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 35"
+  ],
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it (debug part)"
+ },
+ {
+  "sha": "ef5d49032d7eb485371a1679b96e6e53223152a4",
+  "key": [
+   106,
+   0,
+   1,
+   24,
+   1,
+   44,
+   1,
+   47
+  ],
+  "src": 78,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 14,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 75"
+  ],
+  "subject": "btrfs: stripe_alloc: count refused rbio pins and track rbio cache high water (debug part)"
+ },
+ {
+  "sha": "cd3748ce9fc01da3f129e1787faea0c2167025e1",
+  "key": [
+   106,
+   0,
+   1,
+   24,
+   1,
+   44,
+   1,
+   47,
+   1,
+   48
+  ],
+  "src": 79,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 78"
+  ],
+  "subject": "btrfs: stripe_alloc: sweep stale rbio pins, and commit when live pins run low (debug part)"
+ },
+ {
+  "sha": "f7cc73cfcfb2d7a207b400c71dd4cbe4a3819ec9",
+  "key": [
+   107,
+   0
+  ],
+  "src": 39,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 49,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: drain the legacy allocator's writes before arming the write-hole check at a runtime enable"
+ },
+ {
+  "sha": "d89f4861ccb70e72cd3604ec243a2fdb4938b788",
+  "key": [
+   107,
+   0,
+   1,
+   38
+  ],
+  "src": 64,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 12,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 39"
+  ],
+  "subject": "btrfs: stripe_alloc: say at mount whether the policy is on (debug part)"
+ },
+ {
+  "sha": "02f2b6c58c24edeaae9b0ed7a220681b0b81bf9f",
+  "key": [
+   107,
+   0,
+   1,
+   38,
+   1,
+   97
+  ],
+  "src": 104,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 6,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 64"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (debug part)"
+ },
+ {
+  "sha": "8ce3ce488bd32d209c7e7c6ee7f65ed1a96ba0cc",
+  "key": [
+   107,
+   0,
+   1,
+   92
+  ],
+  "src": 61,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 9,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "sits inside a block of old 39"
+  ],
+  "subject": "btrfs: stripe_meta: carry raid56 metadata groups through a runtime enable or disable (debug part)"
+ },
+ {
+  "sha": "81c553981bca8d7ad09269d4ba9b780817198ac0",
+  "key": [
+   107,
+   0,
+   1,
+   92,
+   1,
+   97
+  ],
+  "src": 104,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 61"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (debug part 2)"
+ },
+ {
+  "sha": "9389f955529d7ac04621541846b2621bbd4d287c",
+  "key": [
+   108,
+   0
+  ],
+  "src": 55,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 98,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: tell a dead tree block from a live one in the metadata RMW audit"
+ },
+ {
+  "sha": "1ae7393a7d4e08de3b3702a5fd79fac33d051ebd",
+  "key": [
+   109,
+   0
+  ],
+  "src": 71,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 21,
+  "lines": 155,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: attribute each data read-modify-write to why padding declined"
+ },
+ {
+  "sha": "ec41355e993dd0e4d77cab0da965d8d3e0e9484f",
+  "key": [
+   110,
+   0
+  ],
+  "src": 72,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 16,
+  "lines": 402,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: optionally audit data read-modify-writes against the committed extent tree"
+ },
+ {
+  "sha": "0afbf372d5c6f3e7c37f63965fd36fdbfac0792e",
+  "key": [
+   111,
+   0
+  ],
+  "src": 80,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 100,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "folded into old 80: deletes a line of old 80"
+  ],
+  "subject": "btrfs: stripe_alloc: break rbio pins and open stripe runs down by run class"
+ },
+ {
+  "sha": "9c5c035c87ff548f3cfc9345a75ee7949146daee",
+  "key": [
+   112,
+   0
+  ],
+  "src": 94,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 8,
+  "lines": 42,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: do not read tree blocks under the stripe lock in the metadata RMW audit"
+ },
+ {
+  "sha": "cc011a4dcac308530f4f55c18edab1e4b9f53dde",
+  "key": [
+   112,
+   0,
+   1,
+   97
+  ],
+  "src": 104,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 6,
+  "lines": 63,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "subtopic debug"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (debug part 3)"
+ },
+ {
+  "sha": "05a4879c7375d7eb0eb9b7230ede32b0933e7513",
+  "key": [
+   112,
+   0,
+   1,
+   98
+  ],
+  "src": 105,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 9,
+  "lines": 95,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "subtopic debug"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (debug part 2)"
+ },
+ {
+  "sha": "21bc1ddd05e157199a24c397b4ca55ed4b319030",
+  "key": [
+   113,
+   0
+  ],
+  "src": 107,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 47,
+  "files": [
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: remove pad refusal reasons that no longer exist"
+ },
+ {
+  "sha": "221e17542eb19b94db30973eefd45f0b5fde4b75",
+  "key": [
+   114,
+   0
+  ],
+  "src": 108,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 58,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count and log ordered extents that end with sectors unwritten"
+ },
+ {
+  "sha": "da5e6a43ea6c66d8ac23b59a81202ec63de00e21",
+  "key": [
+   115,
+   0
+  ],
+  "src": 113,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 16,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: log block group reclaim at debug level"
+ }
+]
\ No newline at end of file
diff --git a/scripts/sa-reorder/wreplay-w11.log b/scripts/sa-reorder/wreplay-w11.log
new file mode 100644 (file)
index 0000000..5ac146e
--- /dev/null
@@ -0,0 +1,196 @@
+nomatch: old19 fs/btrfs/block-group.c bool btrfs_stripe_in_open_run(struct btrfs_fs_info *fs_info, u64 logical)
+weave: 42 files
+hunks: 1261
+transfer: old7 fs/btrfs/raid56.c #include "block-group.h" -> old11
+transfer: old38 fs/btrfs/transaction.c #include "raid56.h" -> old79
+transfer: old83 fs/btrfs/disk-io.c fs_info->stripe_log_data_shared = true; -> old83
+name split: old75 fs/btrfs/block-group.c 2l: if (run->class == BTRFS_STRIPE_RUN_NOCOW)
+name split: old76 fs/btrfs/block-group.c 1l: run->class != BTRFS_STRIPE_RUN_NOCOW &&
+names: 515 new to the tree, 2 statements split out
+static function definitions tracked: 120
+def move: old67 stripe_is_aligned (39, 0) -> (79, 0, 1, 39) (user old67)
+def move: old67 stripe_round_down (39, 0) -> (65, 0, 1, 39) (user old67)
+fixpoint rounds: 4
+  1 S1 old1   main 1db06c68cf6b h=6 l=376 
+  2 S1 old2   main 3e393ff7239e h=15 l=519 
+  3 S1 old3   main 5ec2704e997d h=38 l=423 
+  4 S1 old4   main 61d6d7930896 h=10 l=162 
+  5 S1 old5   main ddb68ce2db84 h=18 l=173 
+  6 S1 old6   main cd3907757821 h=27 l=272 
+  7 S1 old8   main 8bc0ee8eef58 h=36 l=475 
+  8 S1 old9   main 2609ae3c1a44 h=24 l=243 
+  9 S1 old10  main 2229cafe85a1 h=9 l=105 
+ 10 S1 old11  main fc4cf0687582 h=25 l=562 transfer into old 11
+ 11 S1 old12  main 502935f666a9 h=4 l=43 
+ 12 S1 old14  main d55d0df85803 h=26 l=276 
+ 13 S1 old17  main f267c1768f91 h=6 l=146 
+ 14 S1 old22  main e578fc18bc82 h=13 l=54 
+ 15 S1 old23  main b6577eb171f1 h=4 l=25 
+ 16 S1 old24  main b05bc87a4e34 h=15 l=77 
+ 17 S1 old25  main 0298ea9d8132 h=34 l=254 
+ 18 S1 old26  main 1bc2ef92b617 h=6 l=217 
+ 19 S1 old27  main 84e8de54a782 h=2 l=23 
+ 20 S1 old30  main a30d1d41e3d9 h=15 l=128 
+ 21 S1 old31  main bc07b7a41eda h=11 l=133 
+ 22 S1 old32  main b531b286f1ee h=21 l=164 
+ 23 S1 old33  main fd31a3158fcc h=41 l=476 
+ 24 S1 old34  main 76b0efb1abe4 h=24 l=144 
+ 25 S1 old35  main ac57920f2f9f h=7 l=32 
+ 26 S1 old36  main 8969fea8865a h=3 l=68 
+ 27 S1 old37  main 30071977c41d h=5 l=50 
+ 28 S1 old40  main c41865f8c018 h=1 l=25 
+ 29 S1 old41  main 8b9b0571deab h=6 l=28 
+ 30 S1 old43  main 9208f45091c9 h=5 l=47 
+ 31 S1 old44  main 2c039b0c7679 h=12 l=129 
+ 32 S1 old45  main 0347f5503c1b h=1 l=19 
+ 33 S1 old54  main 61104edf750f h=1 l=6 
+ 34 S1 old57  main 8ab7372f16be h=11 l=77 
+ 35 S1 old59  main 7274c1d02a0d h=7 l=43 
+ 36 S1 old60  main cbd6446dffb6 h=30 l=136 
+ 37 S1 old62  main 9bdad85a9c22 h=3 l=27 
+ 38 S1 old63  main 7a4c22bb2ca9 h=4 l=47 
+ 39 S1 old64  main 405992409920 h=2 l=19 
+ 40 S1 old68  main 6af34f57384d h=5 l=44 
+ 41 S1 old69  main 8aa095296895 h=1 l=13 
+ 42 S1 old73  main 01d2bfb4b0d2 h=10 l=62 
+ 43 S1 old74  main 35afc053ce57 h=2 l=32 
+ 44 S1 old75  main 91236b877e39 h=23 l=296 
+ 45 S1 old76  main 7463b35bf86d h=13 l=66 
+ 46 S1 old77  main 7c6ae7354f5f h=6 l=65 
+ 47 S1 old78  main 7cf05c1f25c9 h=9 l=69 
+ 48 S1 old79  main f3a28a2274f2 h=10 l=94 transfer into old 79
+ 49 S1 old82  main 1fafddb8c6cd h=2 l=26 
+ 50 S1 old84  main 5e3fba15101d h=1 l=10 
+ 51 S1 old86  main ee220a9bf3df h=4 l=16 
+ 52 S1 old87  main 7ee09b5cd546 h=4 l=22 
+ 53 S1 old89  main 394581387012 h=2 l=42 
+ 54 S1 old91  main d77f5f3738b2 h=9 l=108 
+ 55 S1 old92  main cd942bb70a6e h=3 l=27 
+ 56 S1 old95  main d1723ff8c20e h=4 l=24 
+ 57 S1 old96  main d45f75dcc4c6 h=1 l=7 
+ 58 S1 old97  main cf3970756d17 h=1 l=8 
+ 59 S1 old98  main 503695f8e307 h=1 l=2 
+ 60 S1 old99  main eda196461a4b h=1 l=10 
+ 61 S1 old101 main 6016b4124a0d h=3 l=29 
+ 62 S1 old104 part f9a935243029 h=29 l=363 subtopic base
+ 63 S1 old105 part e222701ac5fe h=50 l=598 subtopic base
+ 64 S1 old109 main ea62bfb4fa3a h=6 l=36 
+ 65 S1 old110 main d2fbc459cbcc h=18 l=113 
+ 66 S2 old18  main 6dc1829df3d7 h=19 l=110 
+ 67 S2 old59  part dde7a882697f h=1 l=2 uses BTRFS_STRIPE_RUN_NOCOW from old 18
+ 68 S2 old75  part af2033878148 h=1 l=2 uses BTRFS_STRIPE_RUN_NOCOW from old 18
+ 69 S2 old76  part 68fdab640a3d h=1 l=1 uses BTRFS_STRIPE_RUN_NOCOW from old 18
+ 70 S2 old19  main 949fdf05cc22 h=17 l=351 
+ 71 S2 old33  part 79a9d13f0b70 h=1 l=26 deletes a line of old 19
+ 72 S2 old104 part 2dac86126de5 h=1 l=16 deletes a line of old 33
+ 73 S2 old67  main 4b0aa08e9888 h=2 l=18 defines stripe_round_down for its first user, old 67;deletes a line of old 19
+ 74 S2 old104 part 58fd06eda45e h=1 l=10 deletes a line of old 67
+ 75 S2 old20  main 6508d50063fe h=18 l=299 
+ 76 S2 old24  part baf15bc76a17 h=1 l=1 sits inside a block of old 20
+ 77 S2 old67  part 4ebd3b5e0d97 h=1 l=2 deletes a line of old 20
+ 78 S2 old21  main 3d199e8456ce h=2 l=16 
+ 79 S2 old30  part 9a6cf49d4488 h=1 l=2 deletes a line of old 21
+ 80 S2 old56  main 08686e0ba668 h=1 l=15 
+ 81 S2 old58  main 66d858a60848 h=6 l=49 
+ 82 S2 old66  main 310ac184dc8b h=8 l=96 
+ 83 S2 old85  main 869e5bc6a77a h=9 l=28 
+ 84 S2 old90  main ae40d00f2f5b h=4 l=70 
+ 85 S2 old100 main f76c0c931feb h=4 l=13 
+ 86 S2 old103 main 50c8c58043d7 h=2 l=4 
+ 87 S2 old104 part eee43c57a398 h=9 l=136 subtopic allow_rmw
+ 88 S2 old105 part 0b74060ef845 h=6 l=82 subtopic allow_rmw
+ 89 S3 old46  main b1dbeb623f6b h=9 l=129 
+ 90 S3 old57  part bdecd54ace7a h=1 l=8 deletes a line of old 46
+ 91 S3 old70  main 06a7f9ab4bad h=40 l=547 
+ 92 S3 old73  part 0595cc48fdbb h=2 l=4 sits inside an argument list of old 70
+ 93 S3 old105 part 2c1c1b62f0e4 h=4 l=55 subtopic reclaim
+ 94 S3 old116 main da6ce58a728d h=10 l=86 
+ 95 S4 old13  main b31137fefcc7 h=6 l=113 folded into old 13: deletes a line of old 13
+ 96 S4 old24  part 2417b432126a h=1 l=4 deletes a line of old 13
+ 97 S4 old69  part d7e978ba9e6f h=1 l=3 deletes a line of old 13
+ 98 S4 old19  part 4254ae23648a h=2 l=15 sits inside a block of old 13
+ 99 S4 old15  main 22d4aefc3583 h=21 l=308 folded into old 15: deletes a line of old 15;folded into old 15: sits inside a block of old 15
+100 S4 old67  part 5d63d4ae3f07 h=2 l=9 defines stripe_is_aligned for its first user, old 67;deletes a line of old 15
+101 S4 old19  part ce7b2869c242 h=1 l=3 sits inside a block of old 15
+102 S4 old16  main 1d253ef2c3f3 h=3 l=26 folded into old 16: deletes a line of old 16
+103 S4 old83  main cd3d2516fd21 h=22 l=223 transfer into old 83
+104 S4 old85  part f1798faa6200 h=2 l=7 deletes a line of old 83
+105 S4 old88  main bfdf2ef6b26a h=5 l=12 
+106 S4 old104 part ccf4ba23cd9e h=3 l=68 subtopic fsync
+107 S4 old105 part 7af777f69b05 h=7 l=72 subtopic fsync
+108 S5 old38  main 71593c72f888 h=34 l=471 
+109 S5 old73  part 948e74c0f885 h=1 l=13 deletes a line of old 38
+110 S5 old109 part 4db297c53633 h=1 l=3 deletes a line of old 38
+111 S5 old42  main 93a2a0aa5918 h=1 l=28 
+112 S5 old70  part b917014d18a6 h=1 l=6 deletes a line of old 42
+113 S5 old47  main 8afa50a9d46d h=2 l=11 
+114 S5 old48  main 3e227b8c1df4 h=4 l=22 
+115 S5 old49  main 57df9590f75e h=2 l=33 
+116 S5 old50  main e31746f58533 h=24 l=135 
+117 S5 old57  part 3e17ca92e38c h=1 l=5 deletes a line of old 50
+118 S5 old91  part 0d40368070cd h=1 l=8 deletes a line of old 50
+119 S5 old110 part a50c66202de2 h=2 l=5 deletes a line of old 50;joined with its other hunks in fs/btrfs/space-info.c
+120 S5 old51  main f38742ef467d h=6 l=42 
+121 S5 old52  main fe01db5e6d18 h=1 l=14 
+122 S5 old53  main cc528deb7937 h=1 l=9 
+123 S5 old61  main 36d1a6584343 h=3 l=46 
+124 S5 old65  main 9e8c0ef7c30e h=10 l=85 
+125 S5 old81  main b6030490bd37 h=24 l=283 
+126 S5 old85  part 1f4ad2cb7938 h=1 l=1 sits inside a block of old 81
+127 S5 old83  part 0265f5a05cab h=3 l=19 deletes a line of old 81;sits inside a block of old 81
+128 S5 old93  main 9634bbd9d251 h=6 l=61 
+129 S5 old102 main 6302c206dd53 h=1 l=10 
+130 S5 old104 main 9867a33694f8 h=11 l=185 
+131 S5 old105 main 54cc964358f7 h=8 l=130 
+132 S5 old109 part 05f0157f78a5 h=1 l=4 deletes a line of old 105
+133 S5 old106 main abb9d051b7d5 h=2 l=21 
+134 S5 old111 main 4a5d9541cdc0 h=13 l=160 
+135 S5 old112 main 96e59a369c58 h=1 l=9 
+136 S5 old114 main 37fe3245fc13 h=17 l=264 
+137 S5 old115 main 1d41ff6032a1 h=14 l=151 
+138 S6 old7   main 4a21c74ddaca h=5 l=79 
+139 S6 old19  part 410c35dfdc4e h=1 l=3 deletes a line of old 7
+140 S6 old38  part 5ead45f4afa8 h=1 l=9 deletes a line of old 7
+141 S6 old28  main 898a6c145e98 h=5 l=48 
+142 S6 old38  part 9bc49da4dcb7 h=2 l=17 sits inside a block of old 28
+143 S6 old65  part 78a4b5aed1e9 h=1 l=6 deletes a line of old 38
+144 S6 old105 part 5242b8f5c106 h=1 l=11 deletes a line of old 65
+145 S6 old29  main 1cc1de08aec9 h=6 l=146 
+146 S6 old30  part c758f28d0ee1 h=2 l=8 sits inside an argument list of old 29
+147 S6 old31  part 1c324dd49385 h=2 l=2 sits inside an argument list of old 30
+148 S6 old35  part 1443c2d29db0 h=2 l=8 deletes a line of old 29
+149 S6 old75  part fbcd95a6bd75 h=2 l=4 sits inside an argument list of old 35
+150 S6 old78  part ef5d49032d7e h=2 l=14 sits inside an argument list of old 75
+151 S6 old79  part cd3748ce9fc0 h=2 l=4 sits inside an argument list of old 78
+152 S6 old39  main f7cc73cfcfb2 h=10 l=49 
+153 S6 old64  part d89f4861ccb7 h=1 l=12 deletes a line of old 39
+154 S6 old104 part 02f2b6c58c24 h=1 l=6 deletes a line of old 64
+155 S6 old61  part 8ce3ce488bd3 h=1 l=9 sits inside a block of old 39
+156 S6 old104 part 81c553981bca h=1 l=10 deletes a line of old 61
+157 S6 old55  main 9389f955529d h=5 l=98 
+158 S6 old71  main 1ae7393a7d4e h=21 l=155 
+159 S6 old72  main ec41355e993d h=16 l=402 
+160 S6 old80  main 0afbf372d5c6 h=11 l=100 folded into old 80: deletes a line of old 80
+161 S6 old94  main 9c5c035c87ff h=8 l=42 
+162 S6 old104 part cc011a4dcac3 h=6 l=63 subtopic debug
+163 S6 old105 part 05a4879c7375 h=9 l=95 subtopic debug
+164 S6 old107 main 21bc1ddd05e1 h=9 l=47 
+165 S6 old108 main 221e17542eb1 h=10 l=58 
+166 S6 old113 main da5e6a43ea6c h=3 l=16 
+DONE da5e6a43ea6c66d8ac23b59a81202ec63de00e21 tree 4b52f5d678467702efe5b45bacb7aee8f4d0019c
+torn blocks: 15
+TORN old70 fs/btrfs/block-group.c [{] S3:36l | S5:6l
+TORN old76 fs/btrfs/block-group.c [{] S1:13l | S2:1l
+TORN old91 fs/btrfs/block-group.c [{] S1:38l | S5:8l
+TORN old104 fs/btrfs/block-group.h [enum btrfs_stripe_run_class {] S1:9l | S5:23l
+TORN old105 fs/btrfs/btrfs_inode.h [struct btrfs_inode {] S1:11l | S4:9l
+TORN old105 fs/btrfs/extent-tree.c [{] S1:15l | S2:15l
+TORN old105 fs/btrfs/extent-tree.c [{] S2:20l | S5:10l
+TORN old105 fs/btrfs/file.c [{] S1:4l | S4:11l
+TORN old105 fs/btrfs/free-space-cache.c [{] S1:12l | S3:8l
+TORN old105 fs/btrfs/fs.h [struct btrfs_fs_info {] S1:33l | S4:6l | S5:5l | S6:9l
+TORN old30 fs/btrfs/raid56.c [{] S1:12l | S2:2l
+TORN old105 fs/btrfs/raid56.c [{] S1:31l | S2:8l
+TORN old105 fs/btrfs/raid56.c [{] S6:11l | S6:6l
+TORN old105 fs/btrfs/space-info.h [struct btrfs_space_info {] S1:14l | S5:39l
+TORN old78 fs/btrfs/sysfs.c [{] S1:2l | S6:14l
diff --git a/scripts/sa-reorder/wreplay-w12.json b/scripts/sa-reorder/wreplay-w12.json
new file mode 100644 (file)
index 0000000..bea9276
--- /dev/null
@@ -0,0 +1,3547 @@
+[
+ {
+  "sha": "3b252d52ecc9354265923492a2385ea2733ce72b",
+  "key": [
+   0,
+   0
+  ],
+  "src": 1,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 376,
+  "files": [
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: add btrfs_claim_free_stripe_run() for stripe-exclusive allocation"
+ },
+ {
+  "sha": "3e557af12681fa42fb9d559254b3ff601c8b513c",
+  "key": [
+   1,
+   0
+  ],
+  "src": 2,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 15,
+  "lines": 519,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/tests/btrfs-tests.c",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: add open stripe run tracking for stripe-exclusive allocation"
+ },
+ {
+  "sha": "bdc54e52a86aa2d2de024bdfb013921905c8a42e",
+  "key": [
+   2,
+   0
+  ],
+  "src": 3,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 38,
+  "lines": 423,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/tests/free-space-tests.c",
+   "fs/btrfs/zoned.c",
+   "fs/btrfs/zoned.h"
+  ],
+  "why": [],
+  "subject": "btrfs: add the stripe_alloc allocation policy for raid56 data"
+ },
+ {
+  "sha": "1ac915bfc8ed211d4a36147293d5f9fde510b184",
+  "key": [
+   3,
+   0
+  ],
+  "src": 4,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 162,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/props.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: control the policy with a filesystem property"
+ },
+ {
+  "sha": "8b2960a5aeb2dc8eb8ff371ee2a4006805e7e410",
+  "key": [
+   4,
+   0
+  ],
+  "src": 5,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 18,
+  "lines": 173,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/ordered-data.h"
+  ],
+  "why": [],
+  "subject": "btrfs: report stripe run data IO through the ordered extent lifecycle"
+ },
+ {
+  "sha": "d1f0310dc10d946154386478ba929bd265708148",
+  "key": [
+   5,
+   0
+  ],
+  "src": 6,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 27,
+  "lines": 272,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/ordered-data.h",
+   "fs/btrfs/tests/free-space-tests.c",
+   "fs/btrfs/transaction.c",
+   "fs/btrfs/transaction.h"
+  ],
+  "why": [],
+  "subject": "btrfs: retire stripe runs at commit and gate stripe_alloc"
+ },
+ {
+  "sha": "ade5923eb0c2f0934d8680e1dd627c002791e7d0",
+  "key": [
+   6,
+   0
+  ],
+  "src": 8,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 36,
+  "lines": 475,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/super.c",
+   "fs/btrfs/sysfs.c",
+   "fs/btrfs/transaction.c",
+   "include/trace/events/btrfs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: account stripe_alloc trapped free space for honest statfs"
+ },
+ {
+  "sha": "d2fd9fd090a645f0124c5dfcc67418089aaec485",
+  "key": [
+   7,
+   0
+  ],
+  "src": 9,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 24,
+  "lines": 243,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep an open run per size band to trap less"
+ },
+ {
+  "sha": "22cf6592854f0048e4028ea9f3c38089961acfa8",
+  "key": [
+   8,
+   0
+  ],
+  "src": 10,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 105,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: grow the frontier run instead of stranding its tail"
+ },
+ {
+  "sha": "b6b2a1ec43d2a6ebcd3cfc77aa9283e8f534c41d",
+  "key": [
+   9,
+   0
+  ],
+  "src": 11,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 25,
+  "lines": 562,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h"
+  ],
+  "why": [
+   "transfer into old 11"
+  ],
+  "subject": "btrfs: raid56: batch stripe_alloc partial writes into full-stripe writes"
+ },
+ {
+  "sha": "0ff418e8aa803552abc0972aa8c1c9131b6dd2e5",
+  "key": [
+   10,
+   0
+  ],
+  "src": 12,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 43,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: never claim stripes covered by a live run"
+ },
+ {
+  "sha": "584fdcff0a9b68158e804488b59dfcd70a309f6d",
+  "key": [
+   11,
+   0
+  ],
+  "src": 14,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 26,
+  "lines": 276,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/direct-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/file.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/relocation.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: private per-inode stripe runs for log-active inodes"
+ },
+ {
+  "sha": "515cfb748f66ad9a6cbc2258592075f746304ec8",
+  "key": [
+   12,
+   0
+  ],
+  "src": 17,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 146,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: pad sub-stripe writes to full stripes in open runs"
+ },
+ {
+  "sha": "626602852d5b6efa37f7a50ff2054521fb64e978",
+  "key": [
+   13,
+   0
+  ],
+  "src": 22,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 13,
+  "lines": 54,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: expose parking statistics in sysfs"
+ },
+ {
+  "sha": "df1e9316248e7a6d77c649973a424b908850285c",
+  "key": [
+   14,
+   0
+  ],
+  "src": 23,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 25,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: skip parking for sync rbios finished by their unplug batch"
+ },
+ {
+  "sha": "44771f8779acaf14c6b2eb7d11578fec0334d34a",
+  "key": [
+   15,
+   0
+  ],
+  "src": 24,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 15,
+  "lines": 77,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations"
+ },
+ {
+  "sha": "a13a53cdfd15867289c9c5b6ef0f285e268702b5",
+  "key": [
+   16,
+   0
+  ],
+  "src": 25,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 34,
+  "lines": 254,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/delalloc-space.h",
+   "fs/btrfs/direct-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/file.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: pessimistic data reservation margin"
+ },
+ {
+  "sha": "73525324ac5aa236f34c43e1e46d29b95d591e45",
+  "key": [
+   17,
+   0
+  ],
+  "src": 26,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 217,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: claim fully-free stripes that span free space entries"
+ },
+ {
+  "sha": "3f9aadb0183588a5edb669632cb4f29751e9da76",
+  "key": [
+   18,
+   0
+  ],
+  "src": 27,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 23,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: warn when raid56 metadata is not covered"
+ },
+ {
+  "sha": "925f657a1877cf89d2fe941185ea4ddbe76a058d",
+  "key": [
+   19,
+   0
+  ],
+  "src": 30,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 15,
+  "lines": 128,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined"
+ },
+ {
+  "sha": "da6d852d981117ba4c97fcab692181f5c3966bd4",
+  "key": [
+   20,
+   0
+  ],
+  "src": 31,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 133,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "include/trace/events/btrfs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: trace why padding declined, at the moment it declined"
+ },
+ {
+  "sha": "b8f41f1873ab6be7b74b6692390fc132c259a900",
+  "key": [
+   21,
+   0
+  ],
+  "src": 32,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 21,
+  "lines": 164,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: complete parked writes on allocation coverage, not clocks"
+ },
+ {
+  "sha": "56f3a7d654cfb8719dd027f9f57ffb01115f694e",
+  "key": [
+   22,
+   0
+  ],
+  "src": 33,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 41,
+  "lines": 476,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: track per-sector liveness and pad from the map"
+ },
+ {
+  "sha": "80a801d5ed9886f32926b9636e77307546306980",
+  "key": [
+   23,
+   0
+  ],
+  "src": 34,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 24,
+  "lines": 144,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c",
+   "include/trace/events/btrfs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count claimable whole-stripe supply directly"
+ },
+ {
+  "sha": "14a93c83b5a95d23fc85d37589231b1bf1cac945",
+  "key": [
+   24,
+   0
+  ],
+  "src": 35,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 7,
+  "lines": 32,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: adaptive park deadline from the parked-rbio backlog"
+ },
+ {
+  "sha": "09f03a2065e2613d5d77557e6b4ddf45860d445f",
+  "key": [
+   25,
+   0
+  ],
+  "src": 36,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 68,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: gate data admission on claimable whole-stripe supply"
+ },
+ {
+  "sha": "9ecdf8c95438de8995d0f8b14d8e574c749393f5",
+  "key": [
+   26,
+   0
+  ],
+  "src": 37,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 50,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: cache a failed stripe run scan per block group"
+ },
+ {
+  "sha": "e27df6a126741288825954ad43856cc46e458795",
+  "key": [
+   27,
+   0
+  ],
+  "src": 40,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 25,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep the admitted bytes placeable when a group goes read-only"
+ },
+ {
+  "sha": "e24bca35600f430b02f983040ce969afd8aa6e1a",
+  "key": [
+   28,
+   0
+  ],
+  "src": 41,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 28,
+  "files": [
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: never let relocation wait on the whole-stripe gate"
+ },
+ {
+  "sha": "e4079b02774144645ee801e65b8bbbd4918b2bfe",
+  "key": [
+   29,
+   0
+  ],
+  "src": 43,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 47,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: charge relocation a margin per reservation, not per extent"
+ },
+ {
+  "sha": "6a81bd8c607e2f72fa39a49a96276355f5d553a4",
+  "key": [
+   30,
+   0
+  ],
+  "src": 44,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 12,
+  "lines": 129,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep the relocation group's stripes out of the admission supply"
+ },
+ {
+  "sha": "60d3dff8b12afa1105239ac34f74fe8cabcea7a0",
+  "key": [
+   31,
+   0
+  ],
+  "src": 45,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 19,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let a data write fall back to the relocation group rather than drop"
+ },
+ {
+  "sha": "ed0b20138196a9db68c27833a6e48e2744cbc85b",
+  "key": [
+   32,
+   0
+  ],
+  "src": 54,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 6,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: show per-group trapped bytes in the space info dump"
+ },
+ {
+  "sha": "dc7879d94c6460e41a08fe4b8dcad6983cc47828",
+  "key": [
+   33,
+   0
+  ],
+  "src": 57,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 77,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped"
+ },
+ {
+  "sha": "cd45bb4b4757dc899ba0f667c3b2ce30d5086b1c",
+  "key": [
+   34,
+   0
+  ],
+  "src": 59,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 7,
+  "lines": 43,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count nocow run lifecycles and stranded stripes in sysfs"
+ },
+ {
+  "sha": "b5ac6408bf0ba81f7639f3e24bb5efe815455952",
+  "key": [
+   35,
+   0
+  ],
+  "src": 60,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 30,
+  "lines": 136,
+  "files": [
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/delalloc-space.h",
+   "fs/btrfs/file.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: hold a stripe of margin across a preallocation"
+ },
+ {
+  "sha": "c80493840c5dfa09cd38be3e99183e9c4ad22244",
+  "key": [
+   36,
+   0
+  ],
+  "src": 62,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 27,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: return a group's allocation cluster before scanning its stripes"
+ },
+ {
+  "sha": "7d5670104df648d9e0c87dd91f108f61bdf336d3",
+  "key": [
+   37,
+   0
+  ],
+  "src": 63,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 47,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: release open stripe runs when a mount fails or an aborted filesystem unmounts"
+ },
+ {
+  "sha": "86638dbb27a2d8033db7223891e6dcd878cdb4a6",
+  "key": [
+   38,
+   0
+  ],
+  "src": 64,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 19,
+  "files": [
+   "fs/btrfs/super.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: say at mount whether the policy is on"
+ },
+ {
+  "sha": "6133db6d2048fb8144464775b58664f7e768cbd4",
+  "key": [
+   40,
+   0
+  ],
+  "src": 68,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 44,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/messages.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not wait for stripe runs to drain on an errored filesystem"
+ },
+ {
+  "sha": "1761f1e463f8891ee316b86cb4e879480e96ef87",
+  "key": [
+   41,
+   0
+  ],
+  "src": 69,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 13,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: end the commit-time and log drains on an errored filesystem too"
+ },
+ {
+  "sha": "1852dd13676a0e81ec25250d00699aa559cb1caf",
+  "key": [
+   42,
+   0
+  ],
+  "src": 73,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 62,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/fs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep relocation's stripe runs until relocation ends"
+ },
+ {
+  "sha": "c45de4dedb64914949b4d5716bf5930be4aa0ad4",
+  "key": [
+   43,
+   0
+  ],
+  "src": 74,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 32,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let relocation allocate a data chunk before it fails"
+ },
+ {
+  "sha": "4c32987b759b1e857995be7cd776d6b75b6b464b",
+  "key": [
+   44,
+   0
+  ],
+  "src": 75,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 23,
+  "lines": 296,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it"
+ },
+ {
+  "sha": "4c883d1a7eb1eda0e890494f79d0ebd112f92e22",
+  "key": [
+   45,
+   0
+  ],
+  "src": 76,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 13,
+  "lines": 66,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: pad a stripe's allocated sectors whose write is still to come"
+ },
+ {
+  "sha": "baec0c769e5d992b6b941f702b0f7d62f057c267",
+  "key": [
+   46,
+   0
+  ],
+  "src": 77,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 65,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/props.c",
+   "fs/btrfs/props.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: apply the property before tree-log replay"
+ },
+ {
+  "sha": "4eacb728fb94b97eacf8616012393519ef716c28",
+  "key": [
+   47,
+   0
+  ],
+  "src": 78,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 69,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count refused rbio pins and track rbio cache high water"
+ },
+ {
+  "sha": "99b703eeba65207ca2e7421c0ce7231f8d311702",
+  "key": [
+   48,
+   0
+  ],
+  "src": 79,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 94,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/transaction.c"
+  ],
+  "why": [
+   "transfer into old 79"
+  ],
+  "subject": "btrfs: stripe_alloc: sweep stale rbio pins, and commit when live pins run low"
+ },
+ {
+  "sha": "b15092718a6855d2fa8a290694a1b3c1b0623e52",
+  "key": [
+   49,
+   0
+  ],
+  "src": 82,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 26,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: don't make a parked rbio wait for sectors that will never be written"
+ },
+ {
+  "sha": "9958bac9145b6618cdf410a14e6a8761424ca052",
+  "key": [
+   50,
+   0
+  ],
+  "src": 84,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let relocation allocate as many data chunks as its reservation needs"
+ },
+ {
+  "sha": "e5f4d4d5451b47b746b2726612ef5e3dc05a49db",
+  "key": [
+   51,
+   0
+  ],
+  "src": 86,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 16,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not treat an allocation error as a found extent"
+ },
+ {
+  "sha": "c882a8ea988ca5054ff6c3076ec2261bef38bf0a",
+  "key": [
+   52,
+   0
+  ],
+  "src": 87,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 22,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/ordered-data.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: mark an ended ordered extent's sectors written"
+ },
+ {
+  "sha": "dd7a428053ee6ac4d392516982969a2cf531cd9d",
+  "key": [
+   53,
+   0
+  ],
+  "src": 89,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 42,
+  "files": [
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: remove only the set bits of a bitmap when claiming a split run"
+ },
+ {
+  "sha": "5d0ee36764007a2f2ceda8b38b0a657d92a72f38",
+  "key": [
+   54,
+   0
+  ],
+  "src": 91,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 108,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep the stripe totals consistent with the groups during the commit scan"
+ },
+ {
+  "sha": "bace3a73a2f5b14cddb96b1f7b586ce9b67871a5",
+  "key": [
+   55,
+   0
+  ],
+  "src": 92,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 27,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not delete an unused block group that still has stripe runs"
+ },
+ {
+  "sha": "d4b46e81b033d92c2d02a78026de43a42f57fbd1",
+  "key": [
+   56,
+   0
+  ],
+  "src": 95,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 24,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: stop the park timer before destroying the raid56 workqueue"
+ },
+ {
+  "sha": "f9aef27ad60b683877d4a1cf96fe4685a9153af4",
+  "key": [
+   57,
+   0
+  ],
+  "src": 96,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 7,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: order the filesystem error before waking stripe drain waiters"
+ },
+ {
+  "sha": "164a75eaee1a62e2d8c018ca5d785bc664fa988a",
+  "key": [
+   58,
+   0
+  ],
+  "src": 97,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: set a padded rbio's data bitmap under bio_list_lock"
+ },
+ {
+  "sha": "a1c63a337373e2718dbb14520ae92aff135b60c9",
+  "key": [
+   59,
+   0
+  ],
+  "src": 98,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: forget the failed-claim verdict when a cluster returns its space"
+ },
+ {
+  "sha": "ef26f5d1ebb1bcb4a34f67a2b2316bfe852c9b88",
+  "key": [
+   60,
+   0
+  ],
+  "src": 99,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/super.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not let a remount revert the stripe_alloc property"
+ },
+ {
+  "sha": "e003ba550434d9414839bc4fd5b36d5e770a5891",
+  "key": [
+   61,
+   0
+  ],
+  "src": 101,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 29,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep the head of a claimed free space entry under the lock"
+ },
+ {
+  "sha": "217c4fafcd7309c7dea2ab004d3df38f34fa5245",
+  "key": [
+   61,
+   0,
+   1,
+   98
+  ],
+  "src": 104,
+  "sub": 1,
+  "tag": "base",
+  "kind": "part",
+  "hunks": 29,
+  "lines": 363,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h"
+  ],
+  "why": [
+   "subtopic base"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (base part)"
+ },
+ {
+  "sha": "4e92a880f9a091eaf1d81e1f4a3975a5d573b1fc",
+  "key": [
+   61,
+   0,
+   1,
+   99
+  ],
+  "src": 105,
+  "sub": 1,
+  "tag": "base",
+  "kind": "part",
+  "hunks": 50,
+  "lines": 598,
+  "files": [
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/file.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/props.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/super.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "subtopic base"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (base part)"
+ },
+ {
+  "sha": "17e5fe0863acfb4cbab162c8fb352a7f42d3ef3a",
+  "key": [
+   62,
+   0
+  ],
+  "src": 109,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 36,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/volumes.c",
+   "fs/btrfs/volumes.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3"
+ },
+ {
+  "sha": "081dcf1fedc60bff2849cbaa0285fb6d437033ca",
+  "key": [
+   63,
+   0
+  ],
+  "src": 110,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 18,
+  "lines": 113,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count single-data-stripe groups' free space in write admission"
+ },
+ {
+  "sha": "cc58bec0b7c45759fae68c0bcc183890833efc8f",
+  "key": [
+   64,
+   0
+  ],
+  "src": 18,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 19,
+  "lines": 110,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/direct-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/relocation.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: isolate nodatacow and preallocated extents by stripe"
+ },
+ {
+  "sha": "d5f2c7f7489c2ab08fe201b81e84d778b50c1c28",
+  "key": [
+   64,
+   0,
+   1,
+   34
+  ],
+  "src": 59,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "uses BTRFS_STRIPE_RUN_NOCOW from old 18"
+  ],
+  "subject": "btrfs: stripe_alloc: count nocow run lifecycles and stranded stripes in sysfs (allow_rmw part)"
+ },
+ {
+  "sha": "f72c0be6644b66423f34145056ebea40eca7dcf1",
+  "key": [
+   64,
+   0,
+   1,
+   44
+  ],
+  "src": 75,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "uses BTRFS_STRIPE_RUN_NOCOW from old 18"
+  ],
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it (allow_rmw part)"
+ },
+ {
+  "sha": "d84f09114f3e35e16e9a34f9874b40b7e2b28bd4",
+  "key": [
+   64,
+   0,
+   1,
+   45
+  ],
+  "src": 76,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 1,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "uses BTRFS_STRIPE_RUN_NOCOW from old 18"
+  ],
+  "subject": "btrfs: stripe_alloc: pad a stripe's allocated sectors whose write is still to come (allow_rmw part)"
+ },
+ {
+  "sha": "6639687a4e6cc895fbf5a2e029a794cd8384cee0",
+  "key": [
+   65,
+   0
+  ],
+  "src": 19,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 17,
+  "lines": 351,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/file.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/props.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents"
+ },
+ {
+  "sha": "0a136662c9ebc31818e2addf51fdf6fbe421f32b",
+  "key": [
+   65,
+   0,
+   1,
+   22
+  ],
+  "src": 33,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 26,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 19"
+  ],
+  "subject": "btrfs: stripe_alloc: track per-sector liveness and pad from the map (allow_rmw part)"
+ },
+ {
+  "sha": "d334509911c430ee22250dfbe1ae286ffcc72ceb",
+  "key": [
+   65,
+   0,
+   1,
+   22,
+   1,
+   98
+  ],
+  "src": 104,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 16,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 33"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part)"
+ },
+ {
+  "sha": "ee2aca0306427e0dfde923dc3aecd7a923c3fb29",
+  "key": [
+   65,
+   0,
+   1,
+   39
+  ],
+  "src": 67,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 18,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "defines stripe_round_down for its first user, old 67",
+   "deletes a line of old 19"
+  ],
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros"
+ },
+ {
+  "sha": "79275a3c0a527d6133f75ea95e72eafc0cda5f09",
+  "key": [
+   65,
+   0,
+   1,
+   39,
+   1,
+   98
+  ],
+  "src": 104,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 67"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part 2)"
+ },
+ {
+  "sha": "2faf69a2c359dfa9a84ccc822367616f55669086",
+  "key": [
+   66,
+   0
+  ],
+  "src": 20,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 18,
+  "lines": 299,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/inode.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: persist nocow runs across commits and remounts"
+ },
+ {
+  "sha": "b9b4d65f3e427781bc09662e5b1b6a0d350ee853",
+  "key": [
+   66,
+   0,
+   1,
+   15
+  ],
+  "src": 24,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 1,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "sits inside a block of old 20"
+  ],
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations (allow_rmw part)"
+ },
+ {
+  "sha": "f3253c7b40ab759cb7799f522fe972225b888955",
+  "key": [
+   66,
+   0,
+   1,
+   39
+  ],
+  "src": 67,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 20"
+  ],
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros (allow_rmw part 2)"
+ },
+ {
+  "sha": "77c6f9e1a0c60ee305e4724a1403bb3a00b77f90",
+  "key": [
+   67,
+   0
+  ],
+  "src": 21,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 16,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: do not park sync writes into nocow runs"
+ },
+ {
+  "sha": "b718bc187b63be42ca509dde16bbb0368667118f",
+  "key": [
+   67,
+   0,
+   1,
+   19
+  ],
+  "src": 30,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [
+   "deletes a line of old 21"
+  ],
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined (allow_rmw part)"
+ },
+ {
+  "sha": "dc1330996403360a4afdcdca86b83407186474f0",
+  "key": [
+   68,
+   0
+  ],
+  "src": 56,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 15,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not read an inline backref off a keyed-ref extent item"
+ },
+ {
+  "sha": "802f1a2172fdc28b73bfa61de1556cf9f727887f",
+  "key": [
+   69,
+   0
+  ],
+  "src": 58,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 49,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: give nocow extents a private run only while they may be written in place"
+ },
+ {
+  "sha": "ae8652999354f8ef569731a025a90efc72b91005",
+  "key": [
+   70,
+   0
+  ],
+  "src": 66,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 8,
+  "lines": 96,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: close dead nocow stripe runs at commit"
+ },
+ {
+  "sha": "1bc3ae85e0d172b88c3cfc9c3c2915c7b207b060",
+  "key": [
+   71,
+   0
+  ],
+  "src": 85,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 28,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode"
+ },
+ {
+  "sha": "77b0dbe12a73290e33a511ecb5b77a1e1c7ede7a",
+  "key": [
+   72,
+   0
+  ],
+  "src": 90,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 70,
+  "files": [
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: claim a stripe tail in one free space lock section"
+ },
+ {
+  "sha": "71c65250972fa83a7f3c0d5a623dba74cd2c20b3",
+  "key": [
+   73,
+   0
+  ],
+  "src": 100,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 13,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/inode.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not block a NOWAIT write in the nocow stripe check"
+ },
+ {
+  "sha": "fbb913068fdcab3861c754da58164e184935a7f1",
+  "key": [
+   74,
+   0
+  ],
+  "src": 103,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/fs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: remove the unused stripe_rmw_opt field"
+ },
+ {
+  "sha": "dccffeb4b5fa0720426906c3c7b0824c9b9253e7",
+  "key": [
+   74,
+   0,
+   1,
+   98
+  ],
+  "src": 104,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 9,
+  "lines": 136,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h"
+  ],
+  "why": [
+   "subtopic allow_rmw"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part 3)"
+ },
+ {
+  "sha": "72c9005a8f1ae77fa9d980badbbf316615b8285c",
+  "key": [
+   74,
+   0,
+   1,
+   99
+  ],
+  "src": 105,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 6,
+  "lines": 82,
+  "files": [
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [
+   "subtopic allow_rmw"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (allow_rmw part)"
+ },
+ {
+  "sha": "e2f7309fdd44246645a05eafacac74bc55e02d5f",
+  "key": [
+   75,
+   0
+  ],
+  "src": 46,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 129,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: hand groups full of trapped free space to the reclaim worker"
+ },
+ {
+  "sha": "a6ff13b150783c3afd0cb11cda3e2011a69b78c6",
+  "key": [
+   75,
+   0,
+   1,
+   33
+  ],
+  "src": 57,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [
+   "deletes a line of old 46"
+  ],
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped (reclaim part)"
+ },
+ {
+  "sha": "df0a44a7f6d2e59807a7224ff617740354e47f73",
+  "key": [
+   76,
+   0
+  ],
+  "src": 70,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 40,
+  "lines": 547,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/relocation.h",
+   "fs/btrfs/sysfs.c",
+   "fs/btrfs/volumes.c",
+   "fs/btrfs/volumes.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: compact mostly live groups instead of skipping them"
+ },
+ {
+  "sha": "b96e15182d997cbd79c9ce10842fa737f3a9b52f",
+  "key": [
+   76,
+   0,
+   1,
+   42
+  ],
+  "src": 73,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 70"
+  ],
+  "subject": "btrfs: stripe_alloc: keep relocation's stripe runs until relocation ends (reclaim part)"
+ },
+ {
+  "sha": "360b2be9a7d90cbd67bedadf5d9b14f550bb7aa7",
+  "key": [
+   76,
+   0,
+   1,
+   99
+  ],
+  "src": 105,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "part",
+  "hunks": 4,
+  "lines": 55,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [
+   "subtopic reclaim"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (reclaim part)"
+ },
+ {
+  "sha": "7cf4f7a31f06a637d60d991a73ee418ea94e7f1d",
+  "key": [
+   77,
+   0
+  ],
+  "src": 113,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 16,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: log block group reclaim at debug level"
+ },
+ {
+  "sha": "3ebc41138cbc297588ecd81d5350ab1311eff0c0",
+  "key": [
+   78,
+   0
+  ],
+  "src": 116,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 86,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/fs.c",
+   "fs/btrfs/fs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let queued exclusive operations in between reclaims"
+ },
+ {
+  "sha": "4b0fab32ceaad8dd37cab39b1eed9b9b70350ac3",
+  "key": [
+   79,
+   0
+  ],
+  "src": 13,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 113,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/tree-log.c"
+  ],
+  "why": [
+   "folded into old 13: deletes a line of old 13"
+  ],
+  "subject": "btrfs: stripe_alloc: settle a logged extent's stripes at log commit"
+ },
+ {
+  "sha": "5eda616a7d9b8a56f09efe015663494f341aaa8d",
+  "key": [
+   79,
+   0,
+   1,
+   15
+  ],
+  "src": 24,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 13"
+  ],
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations (fsync part)"
+ },
+ {
+  "sha": "1c915f58b5f1ed6264f32e71b3f24c65f24812ff",
+  "key": [
+   79,
+   0,
+   1,
+   41
+  ],
+  "src": 69,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 3,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 13"
+  ],
+  "subject": "btrfs: stripe_alloc: end the commit-time and log drains on an errored filesystem too (fsync part)"
+ },
+ {
+  "sha": "fa870e44ab21237f861995c7c83b594d5cca339d",
+  "key": [
+   79,
+   0,
+   1,
+   65
+  ],
+  "src": 19,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 15,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "sits inside a block of old 13"
+  ],
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (fsync part)"
+ },
+ {
+  "sha": "601972d287519af4efe0738e8615dacd1635520f",
+  "key": [
+   80,
+   0
+  ],
+  "src": 15,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 21,
+  "lines": 308,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/defrag.c",
+   "fs/btrfs/defrag.h",
+   "fs/btrfs/file.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/tree-log.c"
+  ],
+  "why": [
+   "folded into old 15: deletes a line of old 15",
+   "folded into old 15: sits inside a block of old 15"
+  ],
+  "subject": "btrfs: stripe_alloc: carry an inode's log tail forward at fsync"
+ },
+ {
+  "sha": "a58a734993e5ecae455fd356b9d523496a78c666",
+  "key": [
+   80,
+   0,
+   1,
+   39
+  ],
+  "src": 67,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 9,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "defines stripe_is_aligned for its first user, old 67",
+   "deletes a line of old 15"
+  ],
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros (fsync part)"
+ },
+ {
+  "sha": "74b0deb8378405dc9ece213e9679d0a0eac01486",
+  "key": [
+   80,
+   0,
+   1,
+   65
+  ],
+  "src": 19,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 3,
+  "files": [
+   "fs/btrfs/defrag.c"
+  ],
+  "why": [
+   "sits inside a block of old 15"
+  ],
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (fsync part 2)"
+ },
+ {
+  "sha": "368b766b0f91fe81ea48f1900b6eec7c0192a4d1",
+  "key": [
+   81,
+   0
+  ],
+  "src": 16,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 26,
+  "files": [
+   "fs/btrfs/file.c"
+  ],
+  "why": [
+   "folded into old 16: deletes a line of old 16"
+  ],
+  "subject": "btrfs: stripe_alloc: kick parked rbios before the fast fsync's writeback wait"
+ },
+ {
+  "sha": "76ffc2967b8e4a0155557d60ba97e998efed5529",
+  "key": [
+   82,
+   0
+  ],
+  "src": 83,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 22,
+  "lines": 223,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/defrag.c",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "transfer into old 83"
+  ],
+  "subject": "btrfs: stripe_alloc: share LOG data runs per log transaction"
+ },
+ {
+  "sha": "d092e59cf3323954c1be5c9a6c8de39a7f59032c",
+  "key": [
+   82,
+   0,
+   1,
+   71
+  ],
+  "src": 85,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 7,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 83"
+  ],
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode (fsync part)"
+ },
+ {
+  "sha": "a169a2b289d7c9cc3910fa36a0c9b49647c21f2b",
+  "key": [
+   83,
+   0
+  ],
+  "src": 88,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 12,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: read the shared LOG run mode once per log settle"
+ },
+ {
+  "sha": "fd3ef9d53cfc862bbb911586ede49e13ad3d9a87",
+  "key": [
+   83,
+   0,
+   1,
+   98
+  ],
+  "src": 104,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 3,
+  "lines": 68,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "subtopic fsync"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (fsync part)"
+ },
+ {
+  "sha": "be5caaae761bdc6a146d1b41f19f72bcf61d4797",
+  "key": [
+   83,
+   0,
+   1,
+   99
+  ],
+  "src": 105,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 7,
+  "lines": 72,
+  "files": [
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/defrag.c",
+   "fs/btrfs/file.c",
+   "fs/btrfs/fs.h"
+  ],
+  "why": [
+   "subtopic fsync"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (fsync part)"
+ },
+ {
+  "sha": "a36c35f4b01e5a810378c1464534507265c73db3",
+  "key": [
+   84,
+   0
+  ],
+  "src": 38,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 34,
+  "lines": 471,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent_io.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/transaction.c",
+   "fs/btrfs/tree-log.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: allocate tree blocks by whole stripes"
+ },
+ {
+  "sha": "406105d1bc1e6478302b4841ed241ca333168a6c",
+  "key": [
+   84,
+   0,
+   1,
+   42
+  ],
+  "src": 73,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 13,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 38"
+  ],
+  "subject": "btrfs: stripe_alloc: keep relocation's stripe runs until relocation ends (stripe_meta part)"
+ },
+ {
+  "sha": "99955c34d8e964c50ead9ddf3aa4a5b2083bddcc",
+  "key": [
+   84,
+   0,
+   1,
+   62
+  ],
+  "src": 109,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 3,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [
+   "deletes a line of old 38"
+  ],
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3 (stripe_meta part)"
+ },
+ {
+  "sha": "a6c93fe59b33a7f0346943ca387e9e2bcd95b4e6",
+  "key": [
+   85,
+   0
+  ],
+  "src": 42,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 28,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: give a queued stripe group a chunk to relocate into when the supply is short"
+ },
+ {
+  "sha": "bf67f496676abcd5b2cc027ba83da8df284d41ef",
+  "key": [
+   85,
+   0,
+   1,
+   76
+  ],
+  "src": 70,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 6,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 42"
+  ],
+  "subject": "btrfs: stripe_alloc: compact mostly live groups instead of skipping them (stripe_meta part)"
+ },
+ {
+  "sha": "5c510f2d061a0621b2a15e2411664d15d9a20146",
+  "key": [
+   86,
+   0
+  ],
+  "src": 47,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 11,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: relocate a queued stripe group even while it has reserved or pinned bytes"
+ },
+ {
+  "sha": "f68d710511fb24eb761acb50aa1e224a20e4ff86",
+  "key": [
+   87,
+   0
+  ],
+  "src": 48,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 22,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: maintain trapped free space for metadata groups like data"
+ },
+ {
+  "sha": "cdddbf19efa33c12ff047c909deef2f3ebd164df",
+  "key": [
+   88,
+   0
+  ],
+  "src": 49,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 33,
+  "files": [
+   "fs/btrfs/block-rsv.c",
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: back the global reserve with usable stripes, and say when a tree block finds none"
+ },
+ {
+  "sha": "b8eee25a92534e24b28a1aad912d53aa1577f1bf",
+  "key": [
+   89,
+   0
+  ],
+  "src": 50,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 24,
+  "lines": 135,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: hold back whole stripes so tree blocks always land and trapped groups can be reclaimed"
+ },
+ {
+  "sha": "389a7aeee472e7e6ca584505843afcd534a50a75",
+  "key": [
+   89,
+   0,
+   1,
+   33
+  ],
+  "src": 57,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 5,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [
+   "deletes a line of old 50"
+  ],
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped (stripe_meta part)"
+ },
+ {
+  "sha": "254af6031b8f3bb7d1278fab78685cf691806dfb",
+  "key": [
+   89,
+   0,
+   1,
+   54
+  ],
+  "src": 91,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 50"
+  ],
+  "subject": "btrfs: stripe_alloc: keep the stripe totals consistent with the groups during the commit scan (stripe_meta part)"
+ },
+ {
+  "sha": "624c42980632870789baadf101f13e1c36a9c64e",
+  "key": [
+   89,
+   0,
+   1,
+   63
+  ],
+  "src": 110,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 5,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [
+   "deletes a line of old 50",
+   "joined with its other hunks in fs/btrfs/space-info.c"
+  ],
+  "subject": "btrfs: stripe_alloc: count single-data-stripe groups' free space in write admission (stripe_meta part)"
+ },
+ {
+  "sha": "3108036f0eca6c3c63a09f0e7bfa706e3066af76",
+  "key": [
+   90,
+   0
+  ],
+  "src": 51,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 42,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: do not steal from the global reserve below the relocation reserve"
+ },
+ {
+  "sha": "9ced534233ef033a666de808d6d92c1827d5bc25",
+  "key": [
+   91,
+   0
+  ],
+  "src": 52,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 14,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: let the transaction machinery's own reservations draw on the reserve"
+ },
+ {
+  "sha": "d2f2af63c05179e383eb918e4aa4c49d100cd735",
+  "key": [
+   92,
+   0
+  ],
+  "src": 53,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 9,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: let a group go read-only for relocation against the reserve"
+ },
+ {
+  "sha": "ffff71454d37d7c690457489275e1ac8a55ba91b",
+  "key": [
+   93,
+   0
+  ],
+  "src": 61,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 46,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: carry raid56 metadata groups through a runtime enable or disable"
+ },
+ {
+  "sha": "3590d5328ceb47f0c831bb8644cb9699da731761",
+  "key": [
+   94,
+   0
+  ],
+  "src": 65,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 85,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: cover raid56 system chunks"
+ },
+ {
+  "sha": "71eb86e0f559e0fa7f9b88b2fde8a9e4676d7e70",
+  "key": [
+   95,
+   0
+  ],
+  "src": 81,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 24,
+  "lines": 283,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: give each log commit its own metadata stripe run"
+ },
+ {
+  "sha": "740641f276f9763283a4b96c326a387ae29b517e",
+  "key": [
+   95,
+   0,
+   1,
+   71
+  ],
+  "src": 85,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 1,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "sits inside a block of old 81"
+  ],
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode (stripe_meta part)"
+ },
+ {
+  "sha": "456cbe52614b3d1d7f66a81b72ab90ae1c38a870",
+  "key": [
+   95,
+   0,
+   1,
+   82
+  ],
+  "src": 83,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 3,
+  "lines": 19,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "deletes a line of old 81",
+   "sits inside a block of old 81"
+  ],
+  "subject": "btrfs: stripe_alloc: share LOG data runs per log transaction (stripe_meta part)"
+ },
+ {
+  "sha": "3d17fd7a140db4de0d16b09dfd447b70f66b7b4a",
+  "key": [
+   96,
+   0
+  ],
+  "src": 93,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 61,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: commit before waiting for metadata runs when making a group read-only"
+ },
+ {
+  "sha": "8021608ec764a02a70fff8e378a772a06ab8776d",
+  "key": [
+   97,
+   0
+  ],
+  "src": 102,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: check the block group lookup when freeing an unwritten tree block"
+ },
+ {
+  "sha": "358d20e92e1778fffeb661d5671e164b79d7b074",
+  "key": [
+   98,
+   0
+  ],
+  "src": 104,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 185,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments"
+ },
+ {
+  "sha": "991bf6e9350094deed33241343ad2dca8d56f21c",
+  "key": [
+   99,
+   0
+  ],
+  "src": 105,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 8,
+  "lines": 130,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code"
+ },
+ {
+  "sha": "4cd2d6efccbe38cc9ea952ed5c14177b9102200d",
+  "key": [
+   99,
+   0,
+   1,
+   62
+  ],
+  "src": 109,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [
+   "deletes a line of old 105"
+  ],
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3 (stripe_meta part 2)"
+ },
+ {
+  "sha": "4ea58319100c7a7e84f371b9f90496c1f043a190",
+  "key": [
+   100,
+   0
+  ],
+  "src": 106,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 21,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: keep waiting for metadata runs that do not drain at commit"
+ },
+ {
+  "sha": "3cf8a38bb9a68a507e9632c122740c65b6af73aa",
+  "key": [
+   101,
+   0
+  ],
+  "src": 111,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 13,
+  "lines": 160,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: account claimable stripes while a trim has them out"
+ },
+ {
+  "sha": "e3047994fc1a68b34d37008a6d08b74e18f80936",
+  "key": [
+   102,
+   0
+  ],
+  "src": 112,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 9,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not miss bitmap free space when debiting a trim"
+ },
+ {
+  "sha": "0a8b40851af0a3f4ec3fc260102c2cd60b60c0f5",
+  "key": [
+   103,
+   0
+  ],
+  "src": 114,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 17,
+  "lines": 264,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: add stripe_reclaim_now to reclaim stripes on demand"
+ },
+ {
+  "sha": "53114de6d131f6425a5b9a802a5798151d2c1a45",
+  "key": [
+   104,
+   0
+  ],
+  "src": 115,
+  "sub": 5,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 14,
+  "lines": 151,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: back off block group reclaim after repeated ENOSPC"
+ },
+ {
+  "sha": "531bb585e483a8f05339a038e433724c656a4393",
+  "key": [
+   105,
+   0
+  ],
+  "src": 7,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 79,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: add a write-hole invariant checker to the raid56 write path"
+ },
+ {
+  "sha": "7a46f10904661d351cfcc8bee9f07b78474f500b",
+  "key": [
+   105,
+   0,
+   1,
+   65
+  ],
+  "src": 19,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 3,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 7"
+  ],
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (debug part)"
+ },
+ {
+  "sha": "189fd87d965e3d562d47a859f62d119e95de70e9",
+  "key": [
+   105,
+   0,
+   1,
+   84
+  ],
+  "src": 38,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 9,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 7"
+  ],
+  "subject": "btrfs: stripe_meta: allocate tree blocks by whole stripes (debug part)"
+ },
+ {
+  "sha": "54d2e7fc7511ce15ba73cc904bd62424d705f007",
+  "key": [
+   106,
+   0
+  ],
+  "src": 28,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 48,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: report read-modify-write of uncovered stripes"
+ },
+ {
+  "sha": "d7be3be5ca66e19778a706ef0fae3453efec6c60",
+  "key": [
+   106,
+   0,
+   1,
+   84
+  ],
+  "src": 38,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 17,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [
+   "sits inside a block of old 28"
+  ],
+  "subject": "btrfs: stripe_meta: allocate tree blocks by whole stripes (debug part 2)"
+ },
+ {
+  "sha": "17a284285e0060ae438527d73fb1370df99f146e",
+  "key": [
+   106,
+   0,
+   1,
+   84,
+   1,
+   94
+  ],
+  "src": 65,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 6,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [
+   "deletes a line of old 38"
+  ],
+  "subject": "btrfs: stripe_meta: cover raid56 system chunks (debug part)"
+ },
+ {
+  "sha": "80820f1d47e23334b9d821add3bb8f574241bdd8",
+  "key": [
+   106,
+   0,
+   1,
+   84,
+   1,
+   94,
+   1,
+   99
+  ],
+  "src": 105,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 11,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [
+   "deletes a line of old 65"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (debug part)"
+ },
+ {
+  "sha": "e131776e945b1350dcf8ab0875a94773a2f1d6c9",
+  "key": [
+   107,
+   0
+  ],
+  "src": 29,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 146,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: say whether a metadata read-modify-write is a write hole"
+ },
+ {
+  "sha": "d3fdacb4a2ce1e0117107022dcb46971a445e2f6",
+  "key": [
+   107,
+   0,
+   1,
+   19
+  ],
+  "src": 30,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 29"
+  ],
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined (debug part)"
+ },
+ {
+  "sha": "bc9c2eb8792c05181967ddfc29f9332f90a51ee7",
+  "key": [
+   107,
+   0,
+   1,
+   19,
+   1,
+   20
+  ],
+  "src": 31,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 30"
+  ],
+  "subject": "btrfs: stripe_alloc: trace why padding declined, at the moment it declined (debug part)"
+ },
+ {
+  "sha": "3317514a75bb0bf9e053ce3b063131f4561c7df3",
+  "key": [
+   107,
+   0,
+   1,
+   24
+  ],
+  "src": 35,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "deletes a line of old 29"
+  ],
+  "subject": "btrfs: raid56: adaptive park deadline from the parked-rbio backlog (debug part)"
+ },
+ {
+  "sha": "7e0e84b0ebc062618f7153b5062a9d6c3ecffe99",
+  "key": [
+   107,
+   0,
+   1,
+   24,
+   1,
+   44
+  ],
+  "src": 75,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 35"
+  ],
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it (debug part)"
+ },
+ {
+  "sha": "fe21141bf6d4d015b8243f5518361e228f1e94d0",
+  "key": [
+   107,
+   0,
+   1,
+   24,
+   1,
+   44,
+   1,
+   47
+  ],
+  "src": 78,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 14,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 75"
+  ],
+  "subject": "btrfs: stripe_alloc: count refused rbio pins and track rbio cache high water (debug part)"
+ },
+ {
+  "sha": "7b5e79c054dabdc446cada2751b56e820588fd6d",
+  "key": [
+   107,
+   0,
+   1,
+   24,
+   1,
+   44,
+   1,
+   47,
+   1,
+   48
+  ],
+  "src": 79,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 78"
+  ],
+  "subject": "btrfs: stripe_alloc: sweep stale rbio pins, and commit when live pins run low (debug part)"
+ },
+ {
+  "sha": "1221fda7a6030bd9f312f172d8b0eaf904c72ba5",
+  "key": [
+   108,
+   0
+  ],
+  "src": 39,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 49,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: drain the legacy allocator's writes before arming the write-hole check at a runtime enable"
+ },
+ {
+  "sha": "e2fbbd3bd9c08a9a729f2bdda633ccbdbf926a44",
+  "key": [
+   108,
+   0,
+   1,
+   38
+  ],
+  "src": 64,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 12,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 39"
+  ],
+  "subject": "btrfs: stripe_alloc: say at mount whether the policy is on (debug part)"
+ },
+ {
+  "sha": "90b1f37b4cef22c2ac3e7c1d264f3ad92db56aa7",
+  "key": [
+   108,
+   0,
+   1,
+   38,
+   1,
+   98
+  ],
+  "src": 104,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 6,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 64"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (debug part)"
+ },
+ {
+  "sha": "3e1e37ad156ea8a8c915fb60a214ccba17605c45",
+  "key": [
+   108,
+   0,
+   1,
+   93
+  ],
+  "src": 61,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 9,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "sits inside a block of old 39"
+  ],
+  "subject": "btrfs: stripe_meta: carry raid56 metadata groups through a runtime enable or disable (debug part)"
+ },
+ {
+  "sha": "0f2398420d7b0cd014741303879e3e03652bd0e0",
+  "key": [
+   108,
+   0,
+   1,
+   93,
+   1,
+   98
+  ],
+  "src": 104,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 61"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (debug part 2)"
+ },
+ {
+  "sha": "3f1ca84090d33f9289d7d7e592baf57dd0f9b1a1",
+  "key": [
+   109,
+   0
+  ],
+  "src": 55,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 98,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: tell a dead tree block from a live one in the metadata RMW audit"
+ },
+ {
+  "sha": "0b0a16d73f85ea4b1a5ed64af0b0e0fe40e051d1",
+  "key": [
+   110,
+   0
+  ],
+  "src": 71,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 21,
+  "lines": 155,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: attribute each data read-modify-write to why padding declined"
+ },
+ {
+  "sha": "02c44dde4e3195b4bb1bb53094119a215c765909",
+  "key": [
+   111,
+   0
+  ],
+  "src": 72,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 16,
+  "lines": 402,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: optionally audit data read-modify-writes against the committed extent tree"
+ },
+ {
+  "sha": "453d72a8e478f60021328bbfc870b56567dc10f3",
+  "key": [
+   112,
+   0
+  ],
+  "src": 80,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 100,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "folded into old 80: deletes a line of old 80"
+  ],
+  "subject": "btrfs: stripe_alloc: break rbio pins and open stripe runs down by run class"
+ },
+ {
+  "sha": "17730daacaf0c95e52c74c0090428e1c43b90bb4",
+  "key": [
+   113,
+   0
+  ],
+  "src": 94,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 8,
+  "lines": 42,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: do not read tree blocks under the stripe lock in the metadata RMW audit"
+ },
+ {
+  "sha": "1a877297455d65481d3a08a51c1122e527e6c317",
+  "key": [
+   113,
+   0,
+   1,
+   98
+  ],
+  "src": 104,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 6,
+  "lines": 63,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "subtopic debug"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (debug part 3)"
+ },
+ {
+  "sha": "788650d8580cd6797ae0e140dea613ee745a69a3",
+  "key": [
+   113,
+   0,
+   1,
+   99
+  ],
+  "src": 105,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 9,
+  "lines": 95,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "subtopic debug"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (debug part 2)"
+ },
+ {
+  "sha": "394f31f4c222e2706c45db8aaae44cf7906ce355",
+  "key": [
+   114,
+   0
+  ],
+  "src": 107,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 47,
+  "files": [
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: remove pad refusal reasons that no longer exist"
+ },
+ {
+  "sha": "5b4847cb8f7abb57749a39737ff047c56d12b44c",
+  "key": [
+   115,
+   0
+  ],
+  "src": 108,
+  "sub": 6,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 58,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count and log ordered extents that end with sectors unwritten"
+ }
+]
\ No newline at end of file
diff --git a/scripts/sa-reorder/wreplay-w12.log b/scripts/sa-reorder/wreplay-w12.log
new file mode 100644 (file)
index 0000000..238bf32
--- /dev/null
@@ -0,0 +1,196 @@
+nomatch: old19 fs/btrfs/block-group.c bool btrfs_stripe_in_open_run(struct btrfs_fs_info *fs_info, u64 logical)
+weave: 42 files
+hunks: 1261
+transfer: old7 fs/btrfs/raid56.c #include "block-group.h" -> old11
+transfer: old38 fs/btrfs/transaction.c #include "raid56.h" -> old79
+transfer: old83 fs/btrfs/disk-io.c fs_info->stripe_log_data_shared = true; -> old83
+name split: old75 fs/btrfs/block-group.c 2l: if (run->class == BTRFS_STRIPE_RUN_NOCOW)
+name split: old76 fs/btrfs/block-group.c 1l: run->class != BTRFS_STRIPE_RUN_NOCOW &&
+names: 515 new to the tree, 2 statements split out
+static function definitions tracked: 120
+def move: old67 stripe_is_aligned (39, 0) -> (80, 0, 1, 39) (user old67)
+def move: old67 stripe_round_down (39, 0) -> (65, 0, 1, 39) (user old67)
+fixpoint rounds: 4
+  1 S1 old1   main 3b252d52ecc9 h=6 l=376 
+  2 S1 old2   main 3e557af12681 h=15 l=519 
+  3 S1 old3   main bdc54e52a86a h=38 l=423 
+  4 S1 old4   main 1ac915bfc8ed h=10 l=162 
+  5 S1 old5   main 8b2960a5aeb2 h=18 l=173 
+  6 S1 old6   main d1f0310dc10d h=27 l=272 
+  7 S1 old8   main ade5923eb0c2 h=36 l=475 
+  8 S1 old9   main d2fd9fd090a6 h=24 l=243 
+  9 S1 old10  main 22cf6592854f h=9 l=105 
+ 10 S1 old11  main b6b2a1ec43d2 h=25 l=562 transfer into old 11
+ 11 S1 old12  main 0ff418e8aa80 h=4 l=43 
+ 12 S1 old14  main 584fdcff0a9b h=26 l=276 
+ 13 S1 old17  main 515cfb748f66 h=6 l=146 
+ 14 S1 old22  main 626602852d5b h=13 l=54 
+ 15 S1 old23  main df1e9316248e h=4 l=25 
+ 16 S1 old24  main 44771f8779ac h=15 l=77 
+ 17 S1 old25  main a13a53cdfd15 h=34 l=254 
+ 18 S1 old26  main 73525324ac5a h=6 l=217 
+ 19 S1 old27  main 3f9aadb01835 h=2 l=23 
+ 20 S1 old30  main 925f657a1877 h=15 l=128 
+ 21 S1 old31  main da6d852d9811 h=11 l=133 
+ 22 S1 old32  main b8f41f1873ab h=21 l=164 
+ 23 S1 old33  main 56f3a7d654cf h=41 l=476 
+ 24 S1 old34  main 80a801d5ed98 h=24 l=144 
+ 25 S1 old35  main 14a93c83b5a9 h=7 l=32 
+ 26 S1 old36  main 09f03a2065e2 h=3 l=68 
+ 27 S1 old37  main 9ecdf8c95438 h=5 l=50 
+ 28 S1 old40  main e27df6a12674 h=1 l=25 
+ 29 S1 old41  main e24bca35600f h=6 l=28 
+ 30 S1 old43  main e4079b027741 h=5 l=47 
+ 31 S1 old44  main 6a81bd8c607e h=12 l=129 
+ 32 S1 old45  main 60d3dff8b12a h=1 l=19 
+ 33 S1 old54  main ed0b20138196 h=1 l=6 
+ 34 S1 old57  main dc7879d94c64 h=11 l=77 
+ 35 S1 old59  main cd45bb4b4757 h=7 l=43 
+ 36 S1 old60  main b5ac6408bf0b h=30 l=136 
+ 37 S1 old62  main c80493840c5d h=3 l=27 
+ 38 S1 old63  main 7d5670104df6 h=4 l=47 
+ 39 S1 old64  main 86638dbb27a2 h=2 l=19 
+ 40 S1 old68  main 6133db6d2048 h=5 l=44 
+ 41 S1 old69  main 1761f1e463f8 h=1 l=13 
+ 42 S1 old73  main 1852dd13676a h=10 l=62 
+ 43 S1 old74  main c45de4dedb64 h=2 l=32 
+ 44 S1 old75  main 4c32987b759b h=23 l=296 
+ 45 S1 old76  main 4c883d1a7eb1 h=13 l=66 
+ 46 S1 old77  main baec0c769e5d h=6 l=65 
+ 47 S1 old78  main 4eacb728fb94 h=9 l=69 
+ 48 S1 old79  main 99b703eeba65 h=10 l=94 transfer into old 79
+ 49 S1 old82  main b15092718a68 h=2 l=26 
+ 50 S1 old84  main 9958bac9145b h=1 l=10 
+ 51 S1 old86  main e5f4d4d5451b h=4 l=16 
+ 52 S1 old87  main c882a8ea988c h=4 l=22 
+ 53 S1 old89  main dd7a428053ee h=2 l=42 
+ 54 S1 old91  main 5d0ee3676400 h=9 l=108 
+ 55 S1 old92  main bace3a73a2f5 h=3 l=27 
+ 56 S1 old95  main d4b46e81b033 h=4 l=24 
+ 57 S1 old96  main f9aef27ad60b h=1 l=7 
+ 58 S1 old97  main 164a75eaee1a h=1 l=8 
+ 59 S1 old98  main a1c63a337373 h=1 l=2 
+ 60 S1 old99  main ef26f5d1ebb1 h=1 l=10 
+ 61 S1 old101 main e003ba550434 h=3 l=29 
+ 62 S1 old104 part 217c4fafcd73 h=29 l=363 subtopic base
+ 63 S1 old105 part 4e92a880f9a0 h=50 l=598 subtopic base
+ 64 S1 old109 main 17e5fe0863ac h=6 l=36 
+ 65 S1 old110 main 081dcf1fedc6 h=18 l=113 
+ 66 S2 old18  main cc58bec0b7c4 h=19 l=110 
+ 67 S2 old59  part d5f2c7f7489c h=1 l=2 uses BTRFS_STRIPE_RUN_NOCOW from old 18
+ 68 S2 old75  part f72c0be6644b h=1 l=2 uses BTRFS_STRIPE_RUN_NOCOW from old 18
+ 69 S2 old76  part d84f09114f3e h=1 l=1 uses BTRFS_STRIPE_RUN_NOCOW from old 18
+ 70 S2 old19  main 6639687a4e6c h=17 l=351 
+ 71 S2 old33  part 0a136662c9eb h=1 l=26 deletes a line of old 19
+ 72 S2 old104 part d334509911c4 h=1 l=16 deletes a line of old 33
+ 73 S2 old67  main ee2aca030642 h=2 l=18 defines stripe_round_down for its first user, old 67;deletes a line of old 19
+ 74 S2 old104 part 79275a3c0a52 h=1 l=10 deletes a line of old 67
+ 75 S2 old20  main 2faf69a2c359 h=18 l=299 
+ 76 S2 old24  part b9b4d65f3e42 h=1 l=1 sits inside a block of old 20
+ 77 S2 old67  part f3253c7b40ab h=1 l=2 deletes a line of old 20
+ 78 S2 old21  main 77c6f9e1a0c6 h=2 l=16 
+ 79 S2 old30  part b718bc187b63 h=1 l=2 deletes a line of old 21
+ 80 S2 old56  main dc1330996403 h=1 l=15 
+ 81 S2 old58  main 802f1a2172fd h=6 l=49 
+ 82 S2 old66  main ae8652999354 h=8 l=96 
+ 83 S2 old85  main 1bc3ae85e0d1 h=9 l=28 
+ 84 S2 old90  main 77b0dbe12a73 h=4 l=70 
+ 85 S2 old100 main 71c65250972f h=4 l=13 
+ 86 S2 old103 main fbb913068fdc h=2 l=4 
+ 87 S2 old104 part dccffeb4b5fa h=9 l=136 subtopic allow_rmw
+ 88 S2 old105 part 72c9005a8f1a h=6 l=82 subtopic allow_rmw
+ 89 S3 old46  main e2f7309fdd44 h=9 l=129 
+ 90 S3 old57  part a6ff13b15078 h=1 l=8 deletes a line of old 46
+ 91 S3 old70  main df0a44a7f6d2 h=40 l=547 
+ 92 S3 old73  part b96e15182d99 h=2 l=4 sits inside an argument list of old 70
+ 93 S3 old105 part 360b2be9a7d9 h=4 l=55 subtopic reclaim
+ 94 S3 old113 main 7cf4f7a31f06 h=3 l=16 
+ 95 S3 old116 main 3ebc41138cbc h=10 l=86 
+ 96 S4 old13  main 4b0fab32ceaa h=6 l=113 folded into old 13: deletes a line of old 13
+ 97 S4 old24  part 5eda616a7d9b h=1 l=4 deletes a line of old 13
+ 98 S4 old69  part 1c915f58b5f1 h=1 l=3 deletes a line of old 13
+ 99 S4 old19  part fa870e44ab21 h=2 l=15 sits inside a block of old 13
+100 S4 old15  main 601972d28751 h=21 l=308 folded into old 15: deletes a line of old 15;folded into old 15: sits inside a block of old 15
+101 S4 old67  part a58a734993e5 h=2 l=9 defines stripe_is_aligned for its first user, old 67;deletes a line of old 15
+102 S4 old19  part 74b0deb83784 h=1 l=3 sits inside a block of old 15
+103 S4 old16  main 368b766b0f91 h=3 l=26 folded into old 16: deletes a line of old 16
+104 S4 old83  main 76ffc2967b8e h=22 l=223 transfer into old 83
+105 S4 old85  part d092e59cf332 h=2 l=7 deletes a line of old 83
+106 S4 old88  main a169a2b289d7 h=5 l=12 
+107 S4 old104 part fd3ef9d53cfc h=3 l=68 subtopic fsync
+108 S4 old105 part be5caaae761b h=7 l=72 subtopic fsync
+109 S5 old38  main a36c35f4b01e h=34 l=471 
+110 S5 old73  part 406105d1bc1e h=1 l=13 deletes a line of old 38
+111 S5 old109 part 99955c34d8e9 h=1 l=3 deletes a line of old 38
+112 S5 old42  main a6c93fe59b33 h=1 l=28 
+113 S5 old70  part bf67f496676a h=1 l=6 deletes a line of old 42
+114 S5 old47  main 5c510f2d061a h=2 l=11 
+115 S5 old48  main f68d710511fb h=4 l=22 
+116 S5 old49  main cdddbf19efa3 h=2 l=33 
+117 S5 old50  main b8eee25a9253 h=24 l=135 
+118 S5 old57  part 389a7aeee472 h=1 l=5 deletes a line of old 50
+119 S5 old91  part 254af6031b8f h=1 l=8 deletes a line of old 50
+120 S5 old110 part 624c42980632 h=2 l=5 deletes a line of old 50;joined with its other hunks in fs/btrfs/space-info.c
+121 S5 old51  main 3108036f0eca h=6 l=42 
+122 S5 old52  main 9ced534233ef h=1 l=14 
+123 S5 old53  main d2f2af63c051 h=1 l=9 
+124 S5 old61  main ffff71454d37 h=3 l=46 
+125 S5 old65  main 3590d5328ceb h=10 l=85 
+126 S5 old81  main 71eb86e0f559 h=24 l=283 
+127 S5 old85  part 740641f276f9 h=1 l=1 sits inside a block of old 81
+128 S5 old83  part 456cbe52614b h=3 l=19 deletes a line of old 81;sits inside a block of old 81
+129 S5 old93  main 3d17fd7a140d h=6 l=61 
+130 S5 old102 main 8021608ec764 h=1 l=10 
+131 S5 old104 main 358d20e92e17 h=11 l=185 
+132 S5 old105 main 991bf6e93500 h=8 l=130 
+133 S5 old109 part 4cd2d6efccbe h=1 l=4 deletes a line of old 105
+134 S5 old106 main 4ea58319100c h=2 l=21 
+135 S5 old111 main 3cf8a38bb9a6 h=13 l=160 
+136 S5 old112 main e3047994fc1a h=1 l=9 
+137 S5 old114 main 0a8b40851af0 h=17 l=264 
+138 S5 old115 main 53114de6d131 h=14 l=151 
+139 S6 old7   main 531bb585e483 h=5 l=79 
+140 S6 old19  part 7a46f1090466 h=1 l=3 deletes a line of old 7
+141 S6 old38  part 189fd87d965e h=1 l=9 deletes a line of old 7
+142 S6 old28  main 54d2e7fc7511 h=5 l=48 
+143 S6 old38  part d7be3be5ca66 h=2 l=17 sits inside a block of old 28
+144 S6 old65  part 17a284285e00 h=1 l=6 deletes a line of old 38
+145 S6 old105 part 80820f1d47e2 h=1 l=11 deletes a line of old 65
+146 S6 old29  main e131776e945b h=6 l=146 
+147 S6 old30  part d3fdacb4a2ce h=2 l=8 sits inside an argument list of old 29
+148 S6 old31  part bc9c2eb8792c h=2 l=2 sits inside an argument list of old 30
+149 S6 old35  part 3317514a75bb h=2 l=8 deletes a line of old 29
+150 S6 old75  part 7e0e84b0ebc0 h=2 l=4 sits inside an argument list of old 35
+151 S6 old78  part fe21141bf6d4 h=2 l=14 sits inside an argument list of old 75
+152 S6 old79  part 7b5e79c054da h=2 l=4 sits inside an argument list of old 78
+153 S6 old39  main 1221fda7a603 h=10 l=49 
+154 S6 old64  part e2fbbd3bd9c0 h=1 l=12 deletes a line of old 39
+155 S6 old104 part 90b1f37b4cef h=1 l=6 deletes a line of old 64
+156 S6 old61  part 3e1e37ad156e h=1 l=9 sits inside a block of old 39
+157 S6 old104 part 0f2398420d7b h=1 l=10 deletes a line of old 61
+158 S6 old55  main 3f1ca84090d3 h=5 l=98 
+159 S6 old71  main 0b0a16d73f85 h=21 l=155 
+160 S6 old72  main 02c44dde4e31 h=16 l=402 
+161 S6 old80  main 453d72a8e478 h=11 l=100 folded into old 80: deletes a line of old 80
+162 S6 old94  main 17730daacaf0 h=8 l=42 
+163 S6 old104 part 1a877297455d h=6 l=63 subtopic debug
+164 S6 old105 part 788650d8580c h=9 l=95 subtopic debug
+165 S6 old107 main 394f31f4c222 h=9 l=47 
+166 S6 old108 main 5b4847cb8f7a h=10 l=58 
+DONE 5b4847cb8f7abb57749a39737ff047c56d12b44c tree 4b52f5d678467702efe5b45bacb7aee8f4d0019c
+torn blocks: 15
+TORN old70 fs/btrfs/block-group.c [{] S3:36l | S5:6l
+TORN old76 fs/btrfs/block-group.c [{] S1:13l | S2:1l
+TORN old91 fs/btrfs/block-group.c [{] S1:38l | S5:8l
+TORN old104 fs/btrfs/block-group.h [enum btrfs_stripe_run_class {] S1:9l | S5:23l
+TORN old105 fs/btrfs/btrfs_inode.h [struct btrfs_inode {] S1:11l | S4:9l
+TORN old105 fs/btrfs/extent-tree.c [{] S1:15l | S2:15l
+TORN old105 fs/btrfs/extent-tree.c [{] S2:20l | S5:10l
+TORN old105 fs/btrfs/file.c [{] S1:4l | S4:11l
+TORN old105 fs/btrfs/free-space-cache.c [{] S1:12l | S3:8l
+TORN old105 fs/btrfs/fs.h [struct btrfs_fs_info {] S1:33l | S4:6l | S5:5l | S6:9l
+TORN old30 fs/btrfs/raid56.c [{] S1:12l | S2:2l
+TORN old105 fs/btrfs/raid56.c [{] S1:31l | S2:8l
+TORN old105 fs/btrfs/raid56.c [{] S6:11l | S6:6l
+TORN old105 fs/btrfs/space-info.h [struct btrfs_space_info {] S1:14l | S5:39l
+TORN old78 fs/btrfs/sysfs.c [{] S1:2l | S6:14l
diff --git a/scripts/sa-reorder/wreplay-x15.json b/scripts/sa-reorder/wreplay-x15.json
new file mode 100644 (file)
index 0000000..daef2eb
--- /dev/null
@@ -0,0 +1,3510 @@
+[
+ {
+  "sha": "0ff761d2af8513b85416850a2aaf13a69878ffe5",
+  "key": [
+   0,
+   0
+  ],
+  "src": 1,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 376,
+  "files": [
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: add btrfs_claim_free_stripe_run() for stripe-exclusive allocation"
+ },
+ {
+  "sha": "dfe88651458caa353b2fe44c2b3bbe50d8830717",
+  "key": [
+   1,
+   0
+  ],
+  "src": 2,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 15,
+  "lines": 519,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/tests/btrfs-tests.c",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: add open stripe run tracking for stripe-exclusive allocation"
+ },
+ {
+  "sha": "6996907b26e73fd6db7245415649dc950c95e5ec",
+  "key": [
+   2,
+   0
+  ],
+  "src": 3,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 38,
+  "lines": 423,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/tests/free-space-tests.c",
+   "fs/btrfs/zoned.c",
+   "fs/btrfs/zoned.h"
+  ],
+  "why": [],
+  "subject": "btrfs: add the stripe_alloc allocation policy for raid56 data"
+ },
+ {
+  "sha": "25fbab8ca25f4b68eebfcafe854737822879bd11",
+  "key": [
+   3,
+   0
+  ],
+  "src": 4,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 162,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/props.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: control the policy with a filesystem property"
+ },
+ {
+  "sha": "62f56a27bbc810eb1ff5ec51e691695335a6c8cb",
+  "key": [
+   4,
+   0
+  ],
+  "src": 5,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 18,
+  "lines": 173,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/ordered-data.h"
+  ],
+  "why": [],
+  "subject": "btrfs: report stripe run data IO through the ordered extent lifecycle"
+ },
+ {
+  "sha": "80c70aea496a533e3a554523fc71650f8e28ffbd",
+  "key": [
+   5,
+   0
+  ],
+  "src": 6,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 27,
+  "lines": 272,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/ordered-data.h",
+   "fs/btrfs/tests/free-space-tests.c",
+   "fs/btrfs/transaction.c",
+   "fs/btrfs/transaction.h"
+  ],
+  "why": [],
+  "subject": "btrfs: retire stripe runs at commit and gate stripe_alloc"
+ },
+ {
+  "sha": "529ae5d168c6ce976544b696c7ceb88ea14d0e14",
+  "key": [
+   6,
+   0
+  ],
+  "src": 8,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 36,
+  "lines": 475,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/super.c",
+   "fs/btrfs/sysfs.c",
+   "fs/btrfs/transaction.c",
+   "include/trace/events/btrfs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: account stripe_alloc trapped free space for honest statfs"
+ },
+ {
+  "sha": "764c719cd0597ad07334c4e36f052f4ed887acf0",
+  "key": [
+   7,
+   0
+  ],
+  "src": 9,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 24,
+  "lines": 243,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep an open run per size band to trap less"
+ },
+ {
+  "sha": "3a3f55749583348affc0b1ef98dbadabc98e49b6",
+  "key": [
+   8,
+   0
+  ],
+  "src": 10,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 105,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: grow the frontier run instead of stranding its tail"
+ },
+ {
+  "sha": "fd93c7cf90bf8c919fa52fb9f92bfcf389b5c91e",
+  "key": [
+   9,
+   0
+  ],
+  "src": 11,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 25,
+  "lines": 562,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h"
+  ],
+  "why": [
+   "transfer into old 11"
+  ],
+  "subject": "btrfs: raid56: batch stripe_alloc partial writes into full-stripe writes"
+ },
+ {
+  "sha": "8c9e32db749430f2becc72d56553f5a6b521fd1e",
+  "key": [
+   10,
+   0
+  ],
+  "src": 12,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 43,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: never claim stripes covered by a live run"
+ },
+ {
+  "sha": "aa07565744723011844b3b49d6828f2cd8538a4f",
+  "key": [
+   11,
+   0
+  ],
+  "src": 14,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 26,
+  "lines": 276,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/direct-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/file.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/relocation.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: private per-inode stripe runs for log-active inodes"
+ },
+ {
+  "sha": "014efd25c440cdec940fec5df9887392fa7547f2",
+  "key": [
+   12,
+   0
+  ],
+  "src": 17,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 146,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: pad sub-stripe writes to full stripes in open runs"
+ },
+ {
+  "sha": "e141403bd555f13dbf7d82b8776e19d2f981ec74",
+  "key": [
+   13,
+   0
+  ],
+  "src": 22,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 13,
+  "lines": 54,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: expose parking statistics in sysfs"
+ },
+ {
+  "sha": "ce982693f87f90597cfeb363f50ff47c071b3100",
+  "key": [
+   14,
+   0
+  ],
+  "src": 23,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 25,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: skip parking for sync rbios finished by their unplug batch"
+ },
+ {
+  "sha": "67faa552b1a680dbfcad5d1f818d76c921591741",
+  "key": [
+   15,
+   0
+  ],
+  "src": 24,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 15,
+  "lines": 77,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations"
+ },
+ {
+  "sha": "16d4b3754e2ab40d9fe071957dc905e5c8c812c8",
+  "key": [
+   16,
+   0
+  ],
+  "src": 25,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 34,
+  "lines": 254,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/delalloc-space.h",
+   "fs/btrfs/direct-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/file.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: pessimistic data reservation margin"
+ },
+ {
+  "sha": "35841aca5f5fe84504464b7591a258270cdf3c9d",
+  "key": [
+   17,
+   0
+  ],
+  "src": 26,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 217,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: claim fully-free stripes that span free space entries"
+ },
+ {
+  "sha": "c02721e6f0c8f042d6406d7214727853b3758c27",
+  "key": [
+   18,
+   0
+  ],
+  "src": 27,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 23,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: warn when raid56 metadata is not covered"
+ },
+ {
+  "sha": "50eb42c1670d96ab0643054072b480a6995c2798",
+  "key": [
+   19,
+   0
+  ],
+  "src": 28,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 40,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: report read-modify-write of uncovered stripes"
+ },
+ {
+  "sha": "d494b6f73c51a7a9ed5382e28d56709edcbdd7fc",
+  "key": [
+   20,
+   0
+  ],
+  "src": 30,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 15,
+  "lines": 128,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined"
+ },
+ {
+  "sha": "150e01cc8b5f8e9271a246e73b91f5f205fb310c",
+  "key": [
+   21,
+   0
+  ],
+  "src": 31,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 133,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "include/trace/events/btrfs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: trace why padding declined, at the moment it declined"
+ },
+ {
+  "sha": "b50899b8f05f8ab966773977a5c5cfdb39732262",
+  "key": [
+   22,
+   0
+  ],
+  "src": 32,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 21,
+  "lines": 164,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: complete parked writes on allocation coverage, not clocks"
+ },
+ {
+  "sha": "54574bcca4f587864827d2a303e74776a278032e",
+  "key": [
+   23,
+   0
+  ],
+  "src": 33,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 41,
+  "lines": 476,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: track per-sector liveness and pad from the map"
+ },
+ {
+  "sha": "9ddaa7aa9797d934642390c2302e33fa3eb25892",
+  "key": [
+   24,
+   0
+  ],
+  "src": 34,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 24,
+  "lines": 144,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c",
+   "include/trace/events/btrfs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count claimable whole-stripe supply directly"
+ },
+ {
+  "sha": "a8c4297477bd21bafef1225a79519f1a22510377",
+  "key": [
+   25,
+   0
+  ],
+  "src": 35,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 7,
+  "lines": 32,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: adaptive park deadline from the parked-rbio backlog"
+ },
+ {
+  "sha": "34bbfe843390534a0fa19f586f78266cf7f725c1",
+  "key": [
+   26,
+   0
+  ],
+  "src": 36,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 68,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: gate data admission on claimable whole-stripe supply"
+ },
+ {
+  "sha": "d8b7a6884ff739bc3ad22fb0dc3b8bd4f565fecf",
+  "key": [
+   27,
+   0
+  ],
+  "src": 37,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 50,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: cache a failed stripe run scan per block group"
+ },
+ {
+  "sha": "9f6828935e5664dd3df6ef611422ba77df7f7412",
+  "key": [
+   28,
+   0
+  ],
+  "src": 40,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 25,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep the admitted bytes placeable when a group goes read-only"
+ },
+ {
+  "sha": "c4661beb2dbfd6a2f71b6df1e4cce4b7d10637a3",
+  "key": [
+   29,
+   0
+  ],
+  "src": 41,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 28,
+  "files": [
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: never let relocation wait on the whole-stripe gate"
+ },
+ {
+  "sha": "6981d6148840c3de8e34905aa6129aa15ecb313e",
+  "key": [
+   30,
+   0
+  ],
+  "src": 43,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 47,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: charge relocation a margin per reservation, not per extent"
+ },
+ {
+  "sha": "b74dc09c20cd2a4495e3627ba45f0429709d0743",
+  "key": [
+   31,
+   0
+  ],
+  "src": 44,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 12,
+  "lines": 129,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep the relocation group's stripes out of the admission supply"
+ },
+ {
+  "sha": "5d1596087b2114f2ba9c396c311171e11c1f44f1",
+  "key": [
+   32,
+   0
+  ],
+  "src": 45,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 19,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let a data write fall back to the relocation group rather than drop"
+ },
+ {
+  "sha": "0560fb56d6eb75d6d13afe026e8d2c3b406b87e8",
+  "key": [
+   33,
+   0
+  ],
+  "src": 54,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 6,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: show per-group trapped bytes in the space info dump"
+ },
+ {
+  "sha": "8fa80bd94dbea69a56dbd0c127c288ef30fab5c7",
+  "key": [
+   34,
+   0
+  ],
+  "src": 57,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 77,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped"
+ },
+ {
+  "sha": "14ff917d04dcc8d751638ce9607a3337c78f156c",
+  "key": [
+   35,
+   0
+  ],
+  "src": 59,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 7,
+  "lines": 43,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count nocow run lifecycles and stranded stripes in sysfs"
+ },
+ {
+  "sha": "d7b49313d285e654ffc67ec4edb39b6365911677",
+  "key": [
+   36,
+   0
+  ],
+  "src": 60,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 30,
+  "lines": 136,
+  "files": [
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/delalloc-space.h",
+   "fs/btrfs/file.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: hold a stripe of margin across a preallocation"
+ },
+ {
+  "sha": "01a3936d13e7c91c772aa066e259c18f31ae816b",
+  "key": [
+   37,
+   0
+  ],
+  "src": 62,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 27,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: return a group's allocation cluster before scanning its stripes"
+ },
+ {
+  "sha": "e7d1c0527ad156ad2fc1e526675fc4f1ceb35031",
+  "key": [
+   38,
+   0
+  ],
+  "src": 63,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 47,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: release open stripe runs when a mount fails or an aborted filesystem unmounts"
+ },
+ {
+  "sha": "01707c824e837148346709e08dbf47e54bdc5977",
+  "key": [
+   39,
+   0
+  ],
+  "src": 64,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 19,
+  "files": [
+   "fs/btrfs/super.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: say at mount whether the policy is on"
+ },
+ {
+  "sha": "b9548e251fe98af39ba7235446227c102a6fadfa",
+  "key": [
+   41,
+   0
+  ],
+  "src": 68,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 44,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/messages.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not wait for stripe runs to drain on an errored filesystem"
+ },
+ {
+  "sha": "132656ed0da660d8229b18178804a32c89db7ec7",
+  "key": [
+   42,
+   0
+  ],
+  "src": 69,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 13,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: end the commit-time and log drains on an errored filesystem too"
+ },
+ {
+  "sha": "8889dfe345cd72f0de6a9d0e8ba511380a65b539",
+  "key": [
+   43,
+   0
+  ],
+  "src": 73,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 62,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/fs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep relocation's stripe runs until relocation ends"
+ },
+ {
+  "sha": "b5a6efe1f87e58f1c7a29d199af3cf01bd5d1b2c",
+  "key": [
+   44,
+   0
+  ],
+  "src": 74,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 32,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let relocation allocate a data chunk before it fails"
+ },
+ {
+  "sha": "bf1856d36945e08f3336db623b3ce89b7fb4b3c2",
+  "key": [
+   45,
+   0
+  ],
+  "src": 75,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 23,
+  "lines": 296,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it"
+ },
+ {
+  "sha": "9888fbd80f15db8656712c8ba4a836818c931294",
+  "key": [
+   46,
+   0
+  ],
+  "src": 76,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 13,
+  "lines": 66,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: pad a stripe's allocated sectors whose write is still to come"
+ },
+ {
+  "sha": "7a08af1a9ee658a5fdace2ccbbb19c5ef78affa9",
+  "key": [
+   47,
+   0
+  ],
+  "src": 77,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 65,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/props.c",
+   "fs/btrfs/props.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: apply the property before tree-log replay"
+ },
+ {
+  "sha": "26845acfdff82f62243ec8076de9c868e7e4167c",
+  "key": [
+   48,
+   0
+  ],
+  "src": 78,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 69,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count refused rbio pins and track rbio cache high water"
+ },
+ {
+  "sha": "f14fe1e95b9a9f7fdffdc3a6ab4220ae268eb940",
+  "key": [
+   49,
+   0
+  ],
+  "src": 79,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 94,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/transaction.c"
+  ],
+  "why": [
+   "transfer into old 79"
+  ],
+  "subject": "btrfs: stripe_alloc: sweep stale rbio pins, and commit when live pins run low"
+ },
+ {
+  "sha": "72d1843ff002526658c43246feea27c68df77495",
+  "key": [
+   50,
+   0
+  ],
+  "src": 82,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 26,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: don't make a parked rbio wait for sectors that will never be written"
+ },
+ {
+  "sha": "1658ad5ef6d66d48f6e05b449753b4342ffed9d5",
+  "key": [
+   51,
+   0
+  ],
+  "src": 84,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let relocation allocate as many data chunks as its reservation needs"
+ },
+ {
+  "sha": "8c864207ad95f828c0b7575d9b98537986cd3db9",
+  "key": [
+   52,
+   0
+  ],
+  "src": 86,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 16,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not treat an allocation error as a found extent"
+ },
+ {
+  "sha": "cde9fe68ac794be1dc99142f3ae250768a4cd37c",
+  "key": [
+   53,
+   0
+  ],
+  "src": 87,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 22,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/ordered-data.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: mark an ended ordered extent's sectors written"
+ },
+ {
+  "sha": "f65d167f4268f839553d5e5abe1f63fbb37fba3d",
+  "key": [
+   54,
+   0
+  ],
+  "src": 89,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 42,
+  "files": [
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: remove only the set bits of a bitmap when claiming a split run"
+ },
+ {
+  "sha": "22d07d08fb15800dfcfafde37a143fc392dde4c3",
+  "key": [
+   55,
+   0
+  ],
+  "src": 91,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 108,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep the stripe totals consistent with the groups during the commit scan"
+ },
+ {
+  "sha": "b86eb61d3a1cf00ffe134c6d8a15e7edf27aa33c",
+  "key": [
+   56,
+   0
+  ],
+  "src": 92,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 27,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not delete an unused block group that still has stripe runs"
+ },
+ {
+  "sha": "ab64c3b14db145c85625eaf68f8436379529d153",
+  "key": [
+   57,
+   0
+  ],
+  "src": 95,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 24,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: stop the park timer before destroying the raid56 workqueue"
+ },
+ {
+  "sha": "6ddb66abc429762238ef1e21901dbde0cd706df0",
+  "key": [
+   58,
+   0
+  ],
+  "src": 96,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 7,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: order the filesystem error before waking stripe drain waiters"
+ },
+ {
+  "sha": "9ae6d347ba1643324eb677435963604444e917b8",
+  "key": [
+   59,
+   0
+  ],
+  "src": 97,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: set a padded rbio's data bitmap under bio_list_lock"
+ },
+ {
+  "sha": "96e9b4f49e9bd1eacb6a79ff45cf1af2002e088a",
+  "key": [
+   60,
+   0
+  ],
+  "src": 98,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: forget the failed-claim verdict when a cluster returns its space"
+ },
+ {
+  "sha": "676cc8b9b43092c9cb081a99f764f0324091e175",
+  "key": [
+   61,
+   0
+  ],
+  "src": 99,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/super.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not let a remount revert the stripe_alloc property"
+ },
+ {
+  "sha": "9f3e296f726c3ccb961f408a934600089fcee6c9",
+  "key": [
+   62,
+   0
+  ],
+  "src": 101,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 29,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep the head of a claimed free space entry under the lock"
+ },
+ {
+  "sha": "f610d92945792bf7ac8f8ba067be5fcff451876b",
+  "key": [
+   62,
+   0,
+   1,
+   110
+  ],
+  "src": 104,
+  "sub": 1,
+  "tag": "base",
+  "kind": "part",
+  "hunks": 29,
+  "lines": 363,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h"
+  ],
+  "why": [
+   "subtopic base"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (base part)"
+ },
+ {
+  "sha": "cbc8a43b3a232f1f0c23d2f348b2bb73049e9a95",
+  "key": [
+   62,
+   0,
+   1,
+   111
+  ],
+  "src": 105,
+  "sub": 1,
+  "tag": "base",
+  "kind": "part",
+  "hunks": 52,
+  "lines": 621,
+  "files": [
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/file.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/props.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/super.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "subtopic base"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (base part)"
+ },
+ {
+  "sha": "7879dd04c872c473a1dad3ba00845a8c4123841a",
+  "key": [
+   63,
+   0
+  ],
+  "src": 109,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 36,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/volumes.c",
+   "fs/btrfs/volumes.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3"
+ },
+ {
+  "sha": "16a89a6595fbfe141cff7d1ea803e2cf0025d1a0",
+  "key": [
+   64,
+   0
+  ],
+  "src": 110,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 18,
+  "lines": 113,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count single-data-stripe groups' free space in write admission"
+ },
+ {
+  "sha": "c39553dc11c95dde1f952be626ec6dd2216d6f5e",
+  "key": [
+   65,
+   0
+  ],
+  "src": 18,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 19,
+  "lines": 110,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/direct-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/relocation.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: isolate nodatacow and preallocated extents by stripe"
+ },
+ {
+  "sha": "6df13ed994c2b3dff069ea484fd39b4d21ae0d31",
+  "key": [
+   65,
+   0,
+   1,
+   35
+  ],
+  "src": 59,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "uses BTRFS_STRIPE_RUN_NOCOW from old 18"
+  ],
+  "subject": "btrfs: stripe_alloc: count nocow run lifecycles and stranded stripes in sysfs (allow_rmw part)"
+ },
+ {
+  "sha": "8a969dc01fb0d349b34dfd5fa33306a6a2caa5a4",
+  "key": [
+   65,
+   0,
+   1,
+   45
+  ],
+  "src": 75,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "uses BTRFS_STRIPE_RUN_NOCOW from old 18"
+  ],
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it (allow_rmw part)"
+ },
+ {
+  "sha": "849abc27cdd1cbdc409f510c9f42b803d160b4a8",
+  "key": [
+   65,
+   0,
+   1,
+   46
+  ],
+  "src": 76,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 1,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "uses BTRFS_STRIPE_RUN_NOCOW from old 18"
+  ],
+  "subject": "btrfs: stripe_alloc: pad a stripe's allocated sectors whose write is still to come (allow_rmw part)"
+ },
+ {
+  "sha": "7772ab68e2755805d554e26179786d651a897048",
+  "key": [
+   66,
+   0
+  ],
+  "src": 19,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 17,
+  "lines": 351,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/file.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/props.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents"
+ },
+ {
+  "sha": "e9d738f2f9921e7f4520f9057f3223de0014dd90",
+  "key": [
+   66,
+   0,
+   1,
+   23
+  ],
+  "src": 33,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 26,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 19"
+  ],
+  "subject": "btrfs: stripe_alloc: track per-sector liveness and pad from the map (allow_rmw part)"
+ },
+ {
+  "sha": "ddc40d8db98df0d7b01711d2068d8437df6cc92a",
+  "key": [
+   66,
+   0,
+   1,
+   23,
+   1,
+   110
+  ],
+  "src": 104,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 16,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 33"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part)"
+ },
+ {
+  "sha": "c44c3bb41de75ca40c69e506e0a1acd9b2708ebb",
+  "key": [
+   66,
+   0,
+   1,
+   40
+  ],
+  "src": 67,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 18,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "defines stripe_round_down for its first user, old 67",
+   "deletes a line of old 19"
+  ],
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros"
+ },
+ {
+  "sha": "7a61bd6452b133c4e954a40cd64b00a9d4c64a9c",
+  "key": [
+   66,
+   0,
+   1,
+   40,
+   1,
+   110
+  ],
+  "src": 104,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 67"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part 2)"
+ },
+ {
+  "sha": "9460ef10099eaf35f8eb8dd49e3e774ffb2cb986",
+  "key": [
+   67,
+   0
+  ],
+  "src": 20,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 18,
+  "lines": 299,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/inode.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: persist nocow runs across commits and remounts"
+ },
+ {
+  "sha": "b0dbdcf315caabe35c3531af45301d97d2af171a",
+  "key": [
+   67,
+   0,
+   1,
+   15
+  ],
+  "src": 24,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 1,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "sits inside a block of old 20"
+  ],
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations (allow_rmw part)"
+ },
+ {
+  "sha": "89f44a9e70fca3d90926585311a8ccd8340d7a3e",
+  "key": [
+   67,
+   0,
+   1,
+   40
+  ],
+  "src": 67,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 20"
+  ],
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros (allow_rmw part 2)"
+ },
+ {
+  "sha": "21aa2c84b41e1cbac2c0da2bcd3a08e1634299a7",
+  "key": [
+   68,
+   0
+  ],
+  "src": 21,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 16,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: do not park sync writes into nocow runs"
+ },
+ {
+  "sha": "e03fc839b5f20260eca0417471a1fbdb59300725",
+  "key": [
+   68,
+   0,
+   1,
+   20
+  ],
+  "src": 30,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [
+   "deletes a line of old 21"
+  ],
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined (allow_rmw part)"
+ },
+ {
+  "sha": "f787537a90e015083ff128f7a22b230ebc9f969a",
+  "key": [
+   69,
+   0
+  ],
+  "src": 56,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 15,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not read an inline backref off a keyed-ref extent item"
+ },
+ {
+  "sha": "127df03d7a54ea1668db5b0c56750e038c4c9ee7",
+  "key": [
+   70,
+   0
+  ],
+  "src": 58,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 49,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: give nocow extents a private run only while they may be written in place"
+ },
+ {
+  "sha": "eb99d2c063d14dbeb97b7a75ff12cdefb50e8eaa",
+  "key": [
+   71,
+   0
+  ],
+  "src": 66,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 8,
+  "lines": 96,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: close dead nocow stripe runs at commit"
+ },
+ {
+  "sha": "06e05a0c35302fe12d995129adf45cdb80f3cd31",
+  "key": [
+   72,
+   0
+  ],
+  "src": 85,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 28,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode"
+ },
+ {
+  "sha": "0bf08adba47e6668ce05bdcf742b0f825904c53e",
+  "key": [
+   73,
+   0
+  ],
+  "src": 90,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 70,
+  "files": [
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: claim a stripe tail in one free space lock section"
+ },
+ {
+  "sha": "5034bc58d7cb44e05c1a4ff3ed0d654af0dbe500",
+  "key": [
+   74,
+   0
+  ],
+  "src": 100,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 13,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/inode.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not block a NOWAIT write in the nocow stripe check"
+ },
+ {
+  "sha": "90e4af5e860ef185061416ad911f5f24d29e2528",
+  "key": [
+   75,
+   0
+  ],
+  "src": 103,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/fs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: remove the unused stripe_rmw_opt field"
+ },
+ {
+  "sha": "66df3246d17825bc175a917a116b05d3490141de",
+  "key": [
+   75,
+   0,
+   1,
+   110
+  ],
+  "src": 104,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 9,
+  "lines": 136,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h"
+  ],
+  "why": [
+   "subtopic allow_rmw"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part 3)"
+ },
+ {
+  "sha": "777923b7b1c4d31e799624d631660caa6ebbd700",
+  "key": [
+   75,
+   0,
+   1,
+   111
+  ],
+  "src": 105,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 6,
+  "lines": 82,
+  "files": [
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [
+   "subtopic allow_rmw"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (allow_rmw part)"
+ },
+ {
+  "sha": "28676fd5c9b1492550443735977f5da188b37400",
+  "key": [
+   76,
+   0
+  ],
+  "src": 42,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 28,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: give a queued stripe group a chunk to relocate into when the supply is short"
+ },
+ {
+  "sha": "86f8a994c6b84096ee43396951673a0948fa7303",
+  "key": [
+   77,
+   0
+  ],
+  "src": 46,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 128,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: hand groups full of trapped free space to the reclaim worker"
+ },
+ {
+  "sha": "551be878a41eb6b985495c45f2779e0d287f40d3",
+  "key": [
+   77,
+   0,
+   1,
+   34
+  ],
+  "src": 57,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [
+   "deletes a line of old 46"
+  ],
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped (reclaim part)"
+ },
+ {
+  "sha": "3f6aa3e1e790245e0078ca1218490ba57430a76a",
+  "key": [
+   78,
+   0
+  ],
+  "src": 47,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: relocate a queued stripe group even while it has reserved or pinned bytes"
+ },
+ {
+  "sha": "e6c0d98bcc1a6bb9da9f5338262e068bd8714ecc",
+  "key": [
+   79,
+   0
+  ],
+  "src": 70,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 41,
+  "lines": 549,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/relocation.h",
+   "fs/btrfs/sysfs.c",
+   "fs/btrfs/volumes.c",
+   "fs/btrfs/volumes.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: compact mostly live groups instead of skipping them"
+ },
+ {
+  "sha": "3a74a38d5dc54a90c2feeae6946e3d616d5ae389",
+  "key": [
+   79,
+   0,
+   1,
+   43
+  ],
+  "src": 73,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 70"
+  ],
+  "subject": "btrfs: stripe_alloc: keep relocation's stripe runs until relocation ends (reclaim part)"
+ },
+ {
+  "sha": "ec8a4b2c2d0915f4fec5579083083b74ba5e6733",
+  "key": [
+   79,
+   0,
+   1,
+   110
+  ],
+  "src": 104,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 12,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "subtopic reclaim"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (reclaim part)"
+ },
+ {
+  "sha": "4ee5ba6f6e23b1bae22071f111482f9aedd3f4ba",
+  "key": [
+   79,
+   0,
+   1,
+   111
+  ],
+  "src": 105,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "part",
+  "hunks": 4,
+  "lines": 55,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [
+   "subtopic reclaim"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (reclaim part)"
+ },
+ {
+  "sha": "518e5340922af58e0dec48728735410903dabda2",
+  "key": [
+   80,
+   0
+  ],
+  "src": 113,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 16,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: log block group reclaim at debug level"
+ },
+ {
+  "sha": "792f4ce95da9a810bf5c36c47608793932c93b09",
+  "key": [
+   81,
+   0
+  ],
+  "src": 114,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 17,
+  "lines": 262,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: add stripe_reclaim_now to reclaim stripes on demand"
+ },
+ {
+  "sha": "67bc0cab13ebbcb3efe4e7d1b27049fc3016f9cf",
+  "key": [
+   82,
+   0
+  ],
+  "src": 115,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 14,
+  "lines": 151,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: back off block group reclaim after repeated ENOSPC"
+ },
+ {
+  "sha": "b293fbeb57180a83224b67cc87777d716cbc4f63",
+  "key": [
+   83,
+   0
+  ],
+  "src": 116,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 86,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/fs.c",
+   "fs/btrfs/fs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let queued exclusive operations in between reclaims"
+ },
+ {
+  "sha": "4e7c183937d1a0fa761d8a5d80641b926f257079",
+  "key": [
+   84,
+   0
+  ],
+  "src": 13,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 113,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/tree-log.c"
+  ],
+  "why": [
+   "folded into old 13: deletes a line of old 13"
+  ],
+  "subject": "btrfs: stripe_alloc: settle a logged extent's stripes at log commit"
+ },
+ {
+  "sha": "dff17c8e98115e403d94b3bed6d80a53cf2478e9",
+  "key": [
+   84,
+   0,
+   1,
+   15
+  ],
+  "src": 24,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 13"
+  ],
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations (fsync part)"
+ },
+ {
+  "sha": "fb8c8c9c54afee6713cd270dde9c3082235a9be4",
+  "key": [
+   84,
+   0,
+   1,
+   42
+  ],
+  "src": 69,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 3,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 13"
+  ],
+  "subject": "btrfs: stripe_alloc: end the commit-time and log drains on an errored filesystem too (fsync part)"
+ },
+ {
+  "sha": "8c74fa6d5a43ca63948d8ccf817aa56c47aecde0",
+  "key": [
+   84,
+   0,
+   1,
+   66
+  ],
+  "src": 19,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 15,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "sits inside a block of old 13"
+  ],
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (fsync part)"
+ },
+ {
+  "sha": "c13b7ff6638f4bcb04a0f8f9ec57eb1f5ad68434",
+  "key": [
+   85,
+   0
+  ],
+  "src": 15,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 21,
+  "lines": 308,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/defrag.c",
+   "fs/btrfs/defrag.h",
+   "fs/btrfs/file.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/tree-log.c"
+  ],
+  "why": [
+   "folded into old 15: deletes a line of old 15",
+   "folded into old 15: sits inside a block of old 15"
+  ],
+  "subject": "btrfs: stripe_alloc: carry an inode's log tail forward at fsync"
+ },
+ {
+  "sha": "cddd789c6403a435b246fcac4b653533d644ec32",
+  "key": [
+   85,
+   0,
+   1,
+   40
+  ],
+  "src": 67,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 9,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "defines stripe_is_aligned for its first user, old 67",
+   "deletes a line of old 15"
+  ],
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros (fsync part)"
+ },
+ {
+  "sha": "ac09434fb807e3f5e55db71bd8539a338ddccb41",
+  "key": [
+   85,
+   0,
+   1,
+   66
+  ],
+  "src": 19,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 3,
+  "files": [
+   "fs/btrfs/defrag.c"
+  ],
+  "why": [
+   "sits inside a block of old 15"
+  ],
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (fsync part 2)"
+ },
+ {
+  "sha": "bc8aae42a8fc1bd457dd266ecb4b46296f5c490a",
+  "key": [
+   86,
+   0
+  ],
+  "src": 16,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 26,
+  "files": [
+   "fs/btrfs/file.c"
+  ],
+  "why": [
+   "folded into old 16: deletes a line of old 16"
+  ],
+  "subject": "btrfs: stripe_alloc: kick parked rbios before the fast fsync's writeback wait"
+ },
+ {
+  "sha": "4ef5e908ec471e478e3c415190e0da74539ac52b",
+  "key": [
+   87,
+   0
+  ],
+  "src": 83,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 22,
+  "lines": 223,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/defrag.c",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "transfer into old 83"
+  ],
+  "subject": "btrfs: stripe_alloc: share LOG data runs per log transaction"
+ },
+ {
+  "sha": "f93797a247372442c7f028575865bf08fe6bc3df",
+  "key": [
+   87,
+   0,
+   1,
+   72
+  ],
+  "src": 85,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 7,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 83"
+  ],
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode (fsync part)"
+ },
+ {
+  "sha": "a75303c4150af3b6e161d1dae4f6a7e3dbdafbe1",
+  "key": [
+   88,
+   0
+  ],
+  "src": 88,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 12,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: read the shared LOG run mode once per log settle"
+ },
+ {
+  "sha": "d1714c6aa1cb5ae92f64dbee7e3c9817532bf723",
+  "key": [
+   88,
+   0,
+   1,
+   110
+  ],
+  "src": 104,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 3,
+  "lines": 68,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "subtopic fsync"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (fsync part)"
+ },
+ {
+  "sha": "191fa286bc580e48a43f551103c87c6623e38d84",
+  "key": [
+   88,
+   0,
+   1,
+   111
+  ],
+  "src": 105,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 7,
+  "lines": 72,
+  "files": [
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/defrag.c",
+   "fs/btrfs/file.c",
+   "fs/btrfs/fs.h"
+  ],
+  "why": [
+   "subtopic fsync"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (fsync part)"
+ },
+ {
+  "sha": "cf62ab98df337d3e10684c30fbcfbc9f59c83d06",
+  "key": [
+   89,
+   0
+  ],
+  "src": 7,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 79,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: add a write-hole invariant checker to the raid56 write path"
+ },
+ {
+  "sha": "1ddfabb1a6b26c5e6719cc753453b576061003de",
+  "key": [
+   89,
+   0,
+   1,
+   19,
+   1,
+   19
+  ],
+  "src": 28,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 4,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "joined with its other hunks in the patch",
+   "uses meta_rmw from old 28"
+  ],
+  "subject": "btrfs: stripe_alloc: report read-modify-write of uncovered stripes (debug part)"
+ },
+ {
+  "sha": "b9f467af571155619f6ccfc0f6494b6c6b14f3b9",
+  "key": [
+   89,
+   0,
+   1,
+   66
+  ],
+  "src": 19,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 3,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 7"
+  ],
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (debug part)"
+ },
+ {
+  "sha": "ba03444e1a42f21aaae77ecc2b2ed5c6deee3e50",
+  "key": [
+   90,
+   0
+  ],
+  "src": 39,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 49,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: drain the legacy allocator's writes before arming the write-hole check at a runtime enable"
+ },
+ {
+  "sha": "e16d6213ef59e25abea13c55493139c23c9ffdc9",
+  "key": [
+   90,
+   0,
+   1,
+   39
+  ],
+  "src": 64,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 12,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 39"
+  ],
+  "subject": "btrfs: stripe_alloc: say at mount whether the policy is on (debug part)"
+ },
+ {
+  "sha": "74a54f7f4290d416f35c31c79c43c89ee57015c5",
+  "key": [
+   90,
+   0,
+   1,
+   39,
+   1,
+   110
+  ],
+  "src": 104,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 6,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 64"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (debug part)"
+ },
+ {
+  "sha": "67ef1e02e94a4ccfbfdfda80f716b0cef0552bcb",
+  "key": [
+   91,
+   0
+  ],
+  "src": 71,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 19,
+  "lines": 127,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: attribute each data read-modify-write to why padding declined"
+ },
+ {
+  "sha": "5ce8acb058301d6f4e4fa6d53b3f9bea94ccc446",
+  "key": [
+   92,
+   0
+  ],
+  "src": 72,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 16,
+  "lines": 402,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: optionally audit data read-modify-writes against the committed extent tree"
+ },
+ {
+  "sha": "ca0a47641b7b511991ca1dd22118dccfa4e16146",
+  "key": [
+   93,
+   0
+  ],
+  "src": 80,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 98,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: break rbio pins and open stripe runs down by run class"
+ },
+ {
+  "sha": "f932b1110e3118e2430ad3520cef88fe0d717682",
+  "key": [
+   93,
+   0,
+   1,
+   110
+  ],
+  "src": 104,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 6,
+  "lines": 63,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "subtopic debug"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (debug part 2)"
+ },
+ {
+  "sha": "58de566a8e56915e71af3c2ccb8315bd37497ed9",
+  "key": [
+   93,
+   0,
+   1,
+   111
+  ],
+  "src": 105,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 3,
+  "lines": 14,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "subtopic debug"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (debug part)"
+ },
+ {
+  "sha": "af05a982014ea1b259cfc1364c754df95831d138",
+  "key": [
+   94,
+   0
+  ],
+  "src": 108,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 8,
+  "lines": 50,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/ordered-data.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count and log ordered extents that end with sectors unwritten"
+ },
+ {
+  "sha": "0f22463d99728607438e33050c2c926c504adc64",
+  "key": [
+   95,
+   0
+  ],
+  "src": 38,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 39,
+  "lines": 512,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent_io.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c",
+   "fs/btrfs/transaction.c",
+   "fs/btrfs/tree-log.c"
+  ],
+  "why": [
+   "folded into old 38",
+   "folded into old 38: deletes a line of old 38"
+  ],
+  "subject": "btrfs: stripe_meta: allocate tree blocks by whole stripes"
+ },
+ {
+  "sha": "a21f277afd4181de8f2dc78b4144fd6017a9caec",
+  "key": [
+   95,
+   0,
+   1,
+   63
+  ],
+  "src": 109,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 3,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [
+   "deletes a line of old 38"
+  ],
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3 (stripe_meta part)"
+ },
+ {
+  "sha": "93ea86b2d4cec4576dfa2222c2c83b16bf969998",
+  "key": [
+   96,
+   0
+  ],
+  "src": 64.5,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "new",
+  "hunks": 19,
+  "lines": 42,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/sysfs.c",
+   "fs/btrfs/volumes.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: extend stripe reclaim to metadata block groups",
+  "srcs": [
+   64.5,
+   116.5
+  ]
+ },
+ {
+  "sha": "104626da44cbce60460a235cc0cb9e8677348379",
+  "key": [
+   99,
+   0
+  ],
+  "src": 48,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 22,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: maintain trapped free space for metadata groups like data"
+ },
+ {
+  "sha": "80a2a4bcd0307f3339bbe3c53ef99ab18e3d231c",
+  "key": [
+   100,
+   0
+  ],
+  "src": 49,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 33,
+  "files": [
+   "fs/btrfs/block-rsv.c",
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: back the global reserve with usable stripes, and say when a tree block finds none"
+ },
+ {
+  "sha": "9dde816705152275721ce8ef2906f8d1c84c41b2",
+  "key": [
+   101,
+   0
+  ],
+  "src": 50,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 24,
+  "lines": 135,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: hold back whole stripes so tree blocks always land and trapped groups can be reclaimed"
+ },
+ {
+  "sha": "15f9c04f76613b36359f35fefc9212076f1081ec",
+  "key": [
+   101,
+   0,
+   1,
+   34
+  ],
+  "src": 57,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 5,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [
+   "deletes a line of old 50"
+  ],
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped (stripe_meta part)"
+ },
+ {
+  "sha": "ccdeea1af337a0b8a7dd23d8d0cc7cc9b88ec340",
+  "key": [
+   101,
+   0,
+   1,
+   55
+  ],
+  "src": 91,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 50"
+  ],
+  "subject": "btrfs: stripe_alloc: keep the stripe totals consistent with the groups during the commit scan (stripe_meta part)"
+ },
+ {
+  "sha": "fafd6cee7e96caa4c4f06f9611bdb1dcebbe9839",
+  "key": [
+   101,
+   0,
+   1,
+   64
+  ],
+  "src": 110,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 5,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [
+   "deletes a line of old 50",
+   "joined with its other hunks in fs/btrfs/space-info.c"
+  ],
+  "subject": "btrfs: stripe_alloc: count single-data-stripe groups' free space in write admission (stripe_meta part)"
+ },
+ {
+  "sha": "110357f516d9b8b428b91425e29622c6efa28d6c",
+  "key": [
+   102,
+   0
+  ],
+  "src": 51,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 42,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: do not steal from the global reserve below the relocation reserve"
+ },
+ {
+  "sha": "43b0cb49028c319ff5e2a7104a7f711b475997d6",
+  "key": [
+   103,
+   0
+  ],
+  "src": 52,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 14,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: let the transaction machinery's own reservations draw on the reserve"
+ },
+ {
+  "sha": "48192148bdd084874df638ed81737dcd0dc48ddf",
+  "key": [
+   104,
+   0
+  ],
+  "src": 53,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 9,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: let a group go read-only for relocation against the reserve"
+ },
+ {
+  "sha": "b293f5e30f8f9b29b5da731072441fff8a828bb0",
+  "key": [
+   105,
+   0
+  ],
+  "src": 61,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 55,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: carry raid56 metadata groups through a runtime enable or disable"
+ },
+ {
+  "sha": "0113dbe591ee8e9118944619780757b6cab4d55b",
+  "key": [
+   106,
+   0
+  ],
+  "src": 65,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 91,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: cover raid56 system chunks"
+ },
+ {
+  "sha": "7df0160e7efd342460f8203fdbfb7ba3e022c4ab",
+  "key": [
+   107,
+   0
+  ],
+  "src": 81,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 25,
+  "lines": 285,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: give each log commit its own metadata stripe run"
+ },
+ {
+  "sha": "0a6a85ef639f2e0ddeba9034b33a6b081db89ddb",
+  "key": [
+   107,
+   0,
+   1,
+   72
+  ],
+  "src": 85,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 1,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "sits inside a block of old 81"
+  ],
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode (stripe_meta part)"
+ },
+ {
+  "sha": "3a2c91f85d5a6e55135a366963f8ddc89183c4d8",
+  "key": [
+   107,
+   0,
+   1,
+   87
+  ],
+  "src": 83,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 3,
+  "lines": 19,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "deletes a line of old 81",
+   "sits inside a block of old 81"
+  ],
+  "subject": "btrfs: stripe_alloc: share LOG data runs per log transaction (stripe_meta part)"
+ },
+ {
+  "sha": "308b5a121aa89e3f9f330c0856624541d07d4185",
+  "key": [
+   108,
+   0
+  ],
+  "src": 93,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 61,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: commit before waiting for metadata runs when making a group read-only"
+ },
+ {
+  "sha": "1d3ae0cd95fdf26a1bbc9ee4c04907d2e14734af",
+  "key": [
+   109,
+   0
+  ],
+  "src": 102,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: check the block group lookup when freeing an unwritten tree block"
+ },
+ {
+  "sha": "850533ec8156a345771d9c7f0ace221a5b4e95f7",
+  "key": [
+   110,
+   0
+  ],
+  "src": 104,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 183,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments"
+ },
+ {
+  "sha": "13cee3a7f329550bea43f8ac8569f48ce6377aad",
+  "key": [
+   111,
+   0
+  ],
+  "src": 105,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 141,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code"
+ },
+ {
+  "sha": "967fe161386f49ef7b28ca240d07bc9a1e5ae4b7",
+  "key": [
+   111,
+   0,
+   1,
+   63
+  ],
+  "src": 109,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [
+   "deletes a line of old 105"
+  ],
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3 (stripe_meta part 2)"
+ },
+ {
+  "sha": "e91f3a3fd2fe6b5e1d59c945b591295fbff82f10",
+  "key": [
+   112,
+   0
+  ],
+  "src": 106,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 21,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: keep waiting for metadata runs that do not drain at commit"
+ },
+ {
+  "sha": "1ce02a2c0709ba4574bbbed976c976679ead85a3",
+  "key": [
+   113,
+   0
+  ],
+  "src": 111,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 13,
+  "lines": 160,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: account claimable stripes while a trim has them out"
+ },
+ {
+  "sha": "0d3c77b154a36cad0d87f98a2926de0670ecb642",
+  "key": [
+   114,
+   0
+  ],
+  "src": 112,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 9,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not miss bitmap free space when debiting a trim"
+ },
+ {
+  "sha": "f26d7fe7b52f1dfa204bbff0047ada6d1641f242",
+  "key": [
+   114,
+   0,
+   2,
+   94
+  ],
+  "src": 108,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "deletes a line of old 83; after the stripe_meta subtopic"
+  ],
+  "subject": "btrfs: stripe_alloc: count and log ordered extents that end with sectors unwritten (debug_meta part)"
+ },
+ {
+  "sha": "31665a601e0accdf1f4f71c90e6120bd11eb4ed6",
+  "key": [
+   115,
+   0
+  ],
+  "src": 29,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 146,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: say whether a metadata read-modify-write is a write hole"
+ },
+ {
+  "sha": "9f86cfbaac137d4df433f8b9778fa52af621c0d5",
+  "key": [
+   115,
+   0,
+   1,
+   20
+  ],
+  "src": 30,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 29"
+  ],
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined (debug_meta part)"
+ },
+ {
+  "sha": "c8edb392a5eefac3008a06cb41b3fbf577e0fa7d",
+  "key": [
+   115,
+   0,
+   1,
+   20,
+   1,
+   21
+  ],
+  "src": 31,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 30"
+  ],
+  "subject": "btrfs: stripe_alloc: trace why padding declined, at the moment it declined (debug_meta part)"
+ },
+ {
+  "sha": "32b0ba7b1e2b68a8c71e482f6182483f6f367abe",
+  "key": [
+   115,
+   0,
+   1,
+   20,
+   1,
+   21,
+   1,
+   91
+  ],
+  "src": 71,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 28,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 31"
+  ],
+  "subject": "btrfs: stripe_alloc: attribute each data read-modify-write to why padding declined (debug_meta part)"
+ },
+ {
+  "sha": "08bfa0c17ff00b1dc241d31fe9e1ebb4a40901e0",
+  "key": [
+   115,
+   0,
+   1,
+   25
+  ],
+  "src": 35,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "deletes a line of old 29"
+  ],
+  "subject": "btrfs: raid56: adaptive park deadline from the parked-rbio backlog (debug_meta part)"
+ },
+ {
+  "sha": "06f23f4488c3d64a83c91df135312748b498e6c0",
+  "key": [
+   115,
+   0,
+   1,
+   25,
+   1,
+   45
+  ],
+  "src": 75,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 35"
+  ],
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it (debug_meta part)"
+ },
+ {
+  "sha": "1e213d8eb7a6f277aee9b7f6e0b1734155b6357a",
+  "key": [
+   115,
+   0,
+   1,
+   25,
+   1,
+   45,
+   1,
+   48
+  ],
+  "src": 78,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 14,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 75"
+  ],
+  "subject": "btrfs: stripe_alloc: count refused rbio pins and track rbio cache high water (debug_meta part)"
+ },
+ {
+  "sha": "b6d8e147eb9ad942bbe7a1379c3ec23bd493df7d",
+  "key": [
+   115,
+   0,
+   1,
+   25,
+   1,
+   45,
+   1,
+   48,
+   1,
+   49
+  ],
+  "src": 79,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 78"
+  ],
+  "subject": "btrfs: stripe_alloc: sweep stale rbio pins, and commit when live pins run low (debug_meta part)"
+ },
+ {
+  "sha": "38cfd9f096ad453bd47a1f4613237da087a9625e",
+  "key": [
+   116,
+   0
+  ],
+  "src": 55,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 98,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: tell a dead tree block from a live one in the metadata RMW audit"
+ },
+ {
+  "sha": "0fc23632e1d93c9ab89a613ef9c8f0bfc1d64cd4",
+  "key": [
+   117,
+   0
+  ],
+  "src": 94,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "main",
+  "hunks": 8,
+  "lines": 42,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: do not read tree blocks under the stripe lock in the metadata RMW audit"
+ },
+ {
+  "sha": "bafbe3e759a0c2aba3265ddcb3730553ac0a34a4",
+  "key": [
+   117,
+   0,
+   1,
+   111
+  ],
+  "src": 105,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 4,
+  "lines": 58,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [
+   "subtopic debug_meta"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (debug_meta part)"
+ },
+ {
+  "sha": "5b273677ccbcbf2b38363b20187a98812dc2a515",
+  "key": [
+   118,
+   0
+  ],
+  "src": 107,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 47,
+  "files": [
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: remove pad refusal reasons that no longer exist"
+ }
+]
\ No newline at end of file
diff --git a/scripts/sa-reorder/wreplay-x15.log b/scripts/sa-reorder/wreplay-x15.log
new file mode 100644 (file)
index 0000000..26b2c6c
--- /dev/null
@@ -0,0 +1,225 @@
+nomatch: old19 fs/btrfs/block-group.c bool btrfs_stripe_in_open_run(struct btrfs_fs_info *fs_info, u64 logical)
+weave: 42 files
+rewrite: old42 fs/btrfs/block-group.c:          * A stripe_alloc group's live extents can only move into | synth 64.5:          * A stripe_alloc / stripe_meta group's live extents can only move into
+rewrite: old47 fs/btrfs/block-group.c:                  * Not for a stripe_alloc group: under | synth 64.5:             * Not for a stripe_alloc or stripe_meta group: under
+rewrite: old46 fs/btrfs/block-group.c:  * Periodic re-evaluation of stripe_alloc groups from the | synth 64.5:  * Periodic re-evaluation of stripe_alloc / stripe_meta groups from the
+rewrite: old70 fs/btrfs/block-group.c:                  * Too full to relocate whole.  A stripe_alloc | synth 116.5:            * Too full to relocate whole.  A stripe_alloc / stripe_meta
+rewrite: old114 fs/btrfs/block-group.c:  * /sys/fs/btrfs/<uuid>/stripe_reclaim_now: reclaim stripe_alloc | synth 116.5:  * /sys/fs/btrfs/<uuid>/stripe_reclaim_now: reclaim stripe_alloc / stripe_meta
+rewrite: old114 fs/btrfs/block-group.c:  * there; -EINVAL: not a stripe_alloc raid56 group (relocate | synth 116.5:  * there; -EINVAL: not a stripe_alloc / stripe_meta raid56 group (relocate
+rewrite in place: old46 del old105 fs/btrfs/free-space-cache.c:  * Does this stripe_alloc / stripe_meta group want the reclaim worker?  Like ->  * Does this stripe_alloc group want the reclaim worker?  Like
+rewrite: old105 fs/btrfs/free-space-cache.c:  * Does this stripe_alloc group want the reclaim worker?  As | synth 116.5:  * Does this stripe_alloc / stripe_meta group want the reclaim worker?  As
+rewrite: old70 fs/btrfs/fs.h:   * Reclaim compacts a mostly live stripe_alloc group once | synth 116.5:         * Reclaim compacts a mostly live stripe_alloc / stripe_meta group once
+rewrite: old114 fs/btrfs/sysfs.c:  * Reclaim stripe_alloc raid56 block groups now: "all" (or "1") | synth 116.5:  * Reclaim stripe_alloc / stripe_meta raid56 block groups now: "all" (or "1")
+rewrite: old70 fs/btrfs/volumes.c:  * Compact a stripe_alloc group: relocate only the extents in | synth 116.5:  * Compact a stripe_alloc / stripe_meta group: relocate only the extents in
+rewrite: old70 fs/btrfs/relocation.c:  * Stripe compaction.  A stripe_alloc group whose free space is | synth 116.5:  * Stripe compaction.  A stripe_alloc / stripe_meta group whose free space is
+rewrite: old42 fs/btrfs/block-group.c:         if (btrfs_is_stripe_alloc_bg(bg)) { | synth 64.5:       if (btrfs_is_stripe_alloc_bg(bg) || btrfs_is_stripe_meta_bg(bg)) {
+rewrite: old46 fs/btrfs/block-group.c:                 if (!(sinfo->flags & BTRFS_BLOCK_GROUP_DATA)) | synth 64.5:             if (!(sinfo->flags & (BTRFS_BLOCK_GROUP_DATA |
+rewrite: old46 fs/btrfs/block-group.c: None | synth 64.5:                                    BTRFS_BLOCK_GROUP_METADATA))) (del old65)
+rewrite: old47 fs/btrfs/block-group.c:              !btrfs_is_stripe_alloc_bg(bg))) { | synth 64.5:         !btrfs_is_stripe_alloc_bg(bg) &&
+rewrite: old47 fs/btrfs/block-group.c: None | synth 64.5:           !btrfs_is_stripe_meta_bg(bg))) {
+rewrite: old70 fs/btrfs/relocation.c:  * again instead of removed. | synth 116.5:  * again instead of removed.  A tree block never spans a stripe, so for a
+rewrite: old70 fs/btrfs/relocation.c: None | synth 116.5:  * metadata group the closure is the partial stripes themselves.
+rewrite: old70 fs/btrfs/relocation.c: None | synth 116.5:              else if (key.type == BTRFS_METADATA_ITEM_KEY)
+rewrite: old70 fs/btrfs/relocation.c: None | synth 116.5:                      len = fs_info->nodesize;
+rewrite: old70 fs/btrfs/relocation.c: None | synth 116.5:      struct btrfs_fs_info *fs_info = bg->fs_info;
+rewrite: old114 fs/btrfs/block-group.c:                } else if (!btrfs_is_stripe_alloc_bg(bg)) { | synth 116.5:              } else if (!btrfs_is_stripe_alloc_bg(bg) &&
+rewrite: old114 fs/btrfs/block-group.c: None | synth 116.5:                       !btrfs_is_stripe_meta_bg(bg)) {
+rewrite: old114 fs/btrfs/block-group.c:                                if (!btrfs_is_stripe_alloc_bg(bg)) | synth 116.5:                               if (!btrfs_is_stripe_alloc_bg(bg) &&
+rewrite: old114 fs/btrfs/block-group.c: None | synth 116.5:                                !btrfs_is_stripe_meta_bg(bg))
+rewrite: old80 fs/btrfs/sysfs.c:               "cow", "reloc", "log", "nocow", | synth 80.5:           "cow", "reloc", "log", "nocow", "meta", (del old81)
+hunks: 1281
+transfer: old7 fs/btrfs/raid56.c #include "block-group.h" -> old11
+transfer: old38 fs/btrfs/transaction.c #include "raid56.h" -> old79
+transfer: old83 fs/btrfs/disk-io.c fs_info->stripe_log_data_shared = true; -> old83
+split stmt: old28 fs/btrfs/raid56.c atomic64_inc(&fs_info->stripe_park_stats.meta_rmw);
+force: old28 fs/btrfs/fs.h hunk with /atomic64_t meta_rmw;/ -> after old7
+force: old28 fs/btrfs/sysfs.c hunk with /meta_rmw/ -> after old7
+force: old28 fs/btrfs/sysfs.c hunk with /meta_rmw/ -> after old7
+name split: old75 fs/btrfs/block-group.c 2l: if (run->class == BTRFS_STRIPE_RUN_NOCOW)
+name split: old76 fs/btrfs/block-group.c 1l: run->class != BTRFS_STRIPE_RUN_NOCOW &&
+names: 515 new to the tree, 2 statements split out
+static function definitions tracked: 119
+def move: old67 stripe_is_aligned (40, 0) -> (85, 0, 1, 40) (user old67)
+def move: old67 stripe_round_down (40, 0) -> (66, 0, 1, 40) (user old67)
+fixpoint rounds: 4
+  1 S1 old1   main 0ff761d2af85 h=6 l=376 
+  2 S1 old2   main dfe88651458c h=15 l=519 
+  3 S1 old3   main 6996907b26e7 h=38 l=423 
+  4 S1 old4   main 25fbab8ca25f h=10 l=162 
+  5 S1 old5   main 62f56a27bbc8 h=18 l=173 
+  6 S1 old6   main 80c70aea496a h=27 l=272 
+  7 S1 old8   main 529ae5d168c6 h=36 l=475 
+  8 S1 old9   main 764c719cd059 h=24 l=243 
+  9 S1 old10  main 3a3f55749583 h=9 l=105 
+ 10 S1 old11  main fd93c7cf90bf h=25 l=562 transfer into old 11
+ 11 S1 old12  main 8c9e32db7494 h=4 l=43 
+ 12 S1 old14  main aa0756574472 h=26 l=276 
+ 13 S1 old17  main 014efd25c440 h=6 l=146 
+ 14 S1 old22  main e141403bd555 h=13 l=54 
+ 15 S1 old23  main ce982693f87f h=4 l=25 
+ 16 S1 old24  main 67faa552b1a6 h=15 l=77 
+ 17 S1 old25  main 16d4b3754e2a h=34 l=254 
+ 18 S1 old26  main 35841aca5f5f h=6 l=217 
+ 19 S1 old27  main c02721e6f0c8 h=2 l=23 
+ 20 S1 old28  main 50eb42c1670d h=2 l=40 
+ 21 S1 old30  main d494b6f73c51 h=15 l=128 
+ 22 S1 old31  main 150e01cc8b5f h=11 l=133 
+ 23 S1 old32  main b50899b8f05f h=21 l=164 
+ 24 S1 old33  main 54574bcca4f5 h=41 l=476 
+ 25 S1 old34  main 9ddaa7aa9797 h=24 l=144 
+ 26 S1 old35  main a8c4297477bd h=7 l=32 
+ 27 S1 old36  main 34bbfe843390 h=3 l=68 
+ 28 S1 old37  main d8b7a6884ff7 h=5 l=50 
+ 29 S1 old40  main 9f6828935e56 h=1 l=25 
+ 30 S1 old41  main c4661beb2dbf h=6 l=28 
+ 31 S1 old43  main 6981d6148840 h=5 l=47 
+ 32 S1 old44  main b74dc09c20cd h=12 l=129 
+ 33 S1 old45  main 5d1596087b21 h=1 l=19 
+ 34 S1 old54  main 0560fb56d6eb h=1 l=6 
+ 35 S1 old57  main 8fa80bd94dbe h=11 l=77 
+ 36 S1 old59  main 14ff917d04dc h=7 l=43 
+ 37 S1 old60  main d7b49313d285 h=30 l=136 
+ 38 S1 old62  main 01a3936d13e7 h=3 l=27 
+ 39 S1 old63  main e7d1c0527ad1 h=4 l=47 
+ 40 S1 old64  main 01707c824e83 h=2 l=19 
+ 41 S1 old68  main b9548e251fe9 h=5 l=44 
+ 42 S1 old69  main 132656ed0da6 h=1 l=13 
+ 43 S1 old73  main 8889dfe345cd h=10 l=62 
+ 44 S1 old74  main b5a6efe1f87e h=2 l=32 
+ 45 S1 old75  main bf1856d36945 h=23 l=296 
+ 46 S1 old76  main 9888fbd80f15 h=13 l=66 
+ 47 S1 old77  main 7a08af1a9ee6 h=6 l=65 
+ 48 S1 old78  main 26845acfdff8 h=9 l=69 
+ 49 S1 old79  main f14fe1e95b9a h=10 l=94 transfer into old 79
+ 50 S1 old82  main 72d1843ff002 h=2 l=26 
+ 51 S1 old84  main 1658ad5ef6d6 h=1 l=10 
+ 52 S1 old86  main 8c864207ad95 h=4 l=16 
+ 53 S1 old87  main cde9fe68ac79 h=4 l=22 
+ 54 S1 old89  main f65d167f4268 h=2 l=42 
+ 55 S1 old91  main 22d07d08fb15 h=9 l=108 
+ 56 S1 old92  main b86eb61d3a1c h=3 l=27 
+ 57 S1 old95  main ab64c3b14db1 h=4 l=24 
+ 58 S1 old96  main 6ddb66abc429 h=1 l=7 
+ 59 S1 old97  main 9ae6d347ba16 h=1 l=8 
+ 60 S1 old98  main 96e9b4f49e9b h=1 l=2 
+ 61 S1 old99  main 676cc8b9b430 h=1 l=10 
+ 62 S1 old101 main 9f3e296f726c h=3 l=29 
+ 63 S1 old104 part f610d9294579 h=29 l=363 subtopic base
+ 64 S1 old105 part cbc8a43b3a23 h=52 l=621 subtopic base
+ 65 S1 old109 main 7879dd04c872 h=6 l=36 
+ 66 S1 old110 main 16a89a6595fb h=18 l=113 
+ 67 S2 old18  main c39553dc11c9 h=19 l=110 
+ 68 S2 old59  part 6df13ed994c2 h=1 l=2 uses BTRFS_STRIPE_RUN_NOCOW from old 18
+ 69 S2 old75  part 8a969dc01fb0 h=1 l=2 uses BTRFS_STRIPE_RUN_NOCOW from old 18
+ 70 S2 old76  part 849abc27cdd1 h=1 l=1 uses BTRFS_STRIPE_RUN_NOCOW from old 18
+ 71 S2 old19  main 7772ab68e275 h=17 l=351 
+ 72 S2 old33  part e9d738f2f992 h=1 l=26 deletes a line of old 19
+ 73 S2 old104 part ddc40d8db98d h=1 l=16 deletes a line of old 33
+ 74 S2 old67  main c44c3bb41de7 h=2 l=18 defines stripe_round_down for its first user, old 67;deletes a line of old 19
+ 75 S2 old104 part 7a61bd6452b1 h=1 l=10 deletes a line of old 67
+ 76 S2 old20  main 9460ef10099e h=18 l=299 
+ 77 S2 old24  part b0dbdcf315ca h=1 l=1 sits inside a block of old 20
+ 78 S2 old67  part 89f44a9e70fc h=1 l=2 deletes a line of old 20
+ 79 S2 old21  main 21aa2c84b41e h=2 l=16 
+ 80 S2 old30  part e03fc839b5f2 h=1 l=2 deletes a line of old 21
+ 81 S2 old56  main f787537a90e0 h=1 l=15 
+ 82 S2 old58  main 127df03d7a54 h=6 l=49 
+ 83 S2 old66  main eb99d2c063d1 h=8 l=96 
+ 84 S2 old85  main 06e05a0c3530 h=9 l=28 
+ 85 S2 old90  main 0bf08adba47e h=4 l=70 
+ 86 S2 old100 main 5034bc58d7cb h=4 l=13 
+ 87 S2 old103 main 90e4af5e860e h=2 l=4 
+ 88 S2 old104 part 66df3246d178 h=9 l=136 subtopic allow_rmw
+ 89 S2 old105 part 777923b7b1c4 h=6 l=82 subtopic allow_rmw
+ 90 S3 old42  main 28676fd5c9b1 h=1 l=28 
+ 91 S3 old46  main 86f8a994c6b8 h=9 l=128 
+ 92 S3 old57  part 551be878a41e h=1 l=8 deletes a line of old 46
+ 93 S3 old47  main 3f6aa3e1e790 h=2 l=10 
+ 94 S3 old70  main e6c0d98bcc1a h=41 l=549 
+ 95 S3 old73  part 3a74a38d5dc5 h=2 l=4 sits inside an argument list of old 70
+ 96 S3 old104 part ec8a4b2c2d09 h=1 l=12 subtopic reclaim
+ 97 S3 old105 part 4ee5ba6f6e23 h=4 l=55 subtopic reclaim
+ 98 S3 old113 main 518e5340922a h=3 l=16 
+ 99 S3 old114 main 792f4ce95da9 h=17 l=262 
+100 S3 old115 main 67bc0cab13eb h=14 l=151 
+101 S3 old116 main b293fbeb5718 h=10 l=86 
+102 S4 old13  main 4e7c183937d1 h=6 l=113 folded into old 13: deletes a line of old 13
+103 S4 old24  part dff17c8e9811 h=1 l=4 deletes a line of old 13
+104 S4 old69  part fb8c8c9c54af h=1 l=3 deletes a line of old 13
+105 S4 old19  part 8c74fa6d5a43 h=2 l=15 sits inside a block of old 13
+106 S4 old15  main c13b7ff6638f h=21 l=308 folded into old 15: deletes a line of old 15;folded into old 15: sits inside a block of old 15
+107 S4 old67  part cddd789c6403 h=2 l=9 defines stripe_is_aligned for its first user, old 67;deletes a line of old 15
+108 S4 old19  part ac09434fb807 h=1 l=3 sits inside a block of old 15
+109 S4 old16  main bc8aae42a8fc h=3 l=26 folded into old 16: deletes a line of old 16
+110 S4 old83  main 4ef5e908ec47 h=22 l=223 transfer into old 83
+111 S4 old85  part f93797a24737 h=2 l=7 deletes a line of old 83
+112 S4 old88  main a75303c4150a h=5 l=12 
+113 S4 old104 part d1714c6aa1cb h=3 l=68 subtopic fsync
+114 S4 old105 part 191fa286bc58 h=7 l=72 subtopic fsync
+115 S5 old7   main cf62ab98df33 h=5 l=79 
+116 S5 old28  part 1ddfabb1a6b2 h=4 l=8 joined with its other hunks in the patch;uses meta_rmw from old 28
+117 S5 old19  part b9f467af5711 h=1 l=3 deletes a line of old 7
+118 S5 old39  main ba03444e1a42 h=10 l=49 
+119 S5 old64  part e16d6213ef59 h=1 l=12 deletes a line of old 39
+120 S5 old104 part 74a54f7f4290 h=1 l=6 deletes a line of old 64
+121 S5 old71  main 67ef1e02e94a h=19 l=127 
+122 S5 old72  main 5ce8acb05830 h=16 l=402 
+123 S5 old80  main ca0a47641b7b h=10 l=98 
+124 S5 old104 part f932b1110e31 h=6 l=63 subtopic debug
+125 S5 old105 part 58de566a8e56 h=3 l=14 subtopic debug
+126 S5 old108 main af05a982014e h=8 l=50 
+127 S6 old38  main 0f22463d9972 h=39 l=512 folded into old 38;folded into old 38: deletes a line of old 38
+128 S6 old109 part a21f277afd41 h=1 l=3 deletes a line of old 38
+129 S6 old64.5 new  b17bef00933f h=6 l=14 
+129 S6 synth116.5 merged into the previous commit 93ea86b2d4ce l=42
+130 S6 old48  main 104626da44cb h=4 l=22 
+131 S6 old49  main 80a2a4bcd030 h=2 l=33 
+132 S6 old50  main 9dde81670515 h=24 l=135 
+133 S6 old57  part 15f9c04f7661 h=1 l=5 deletes a line of old 50
+134 S6 old91  part ccdeea1af337 h=1 l=8 deletes a line of old 50
+135 S6 old110 part fafd6cee7e96 h=2 l=5 deletes a line of old 50;joined with its other hunks in fs/btrfs/space-info.c
+136 S6 old51  main 110357f516d9 h=6 l=42 
+137 S6 old52  main 43b0cb49028c h=1 l=14 
+138 S6 old53  main 48192148bdd0 h=1 l=9 
+139 S6 old61  main b293f5e30f8f h=4 l=55 
+140 S6 old65  main 0113dbe591ee h=11 l=91 
+141 S6 old81  main 7df0160e7efd h=25 l=285 
+142 S6 old85  part 0a6a85ef639f h=1 l=1 sits inside a block of old 81
+143 S6 old83  part 3a2c91f85d5a h=3 l=19 deletes a line of old 81;sits inside a block of old 81
+144 S6 old93  main 308b5a121aa8 h=6 l=61 
+145 S6 old102 main 1d3ae0cd95fd h=1 l=10 
+146 S6 old104 main 850533ec8156 h=11 l=183 
+147 S6 old105 main 13cee3a7f329 h=9 l=141 
+148 S6 old109 part 967fe161386f h=1 l=4 deletes a line of old 105
+149 S6 old106 main e91f3a3fd2fe h=2 l=21 
+150 S6 old111 main 1ce02a2c0709 h=13 l=160 
+151 S6 old112 main 0d3c77b154a3 h=1 l=9 
+152 S7 old108 part f26d7fe7b52f h=2 l=8 deletes a line of old 83; after the stripe_meta subtopic
+153 S7 old29  main 31665a601e0a h=6 l=146 
+154 S7 old30  part 9f86cfbaac13 h=2 l=8 sits inside an argument list of old 29
+155 S7 old31  part c8edb392a5ee h=2 l=2 sits inside an argument list of old 30
+156 S7 old71  part 32b0ba7b1e2b h=2 l=28 sits inside an argument list of old 31
+157 S7 old35  part 08bfa0c17ff0 h=2 l=8 deletes a line of old 29
+158 S7 old75  part 06f23f4488c3 h=2 l=4 sits inside an argument list of old 35
+159 S7 old78  part 1e213d8eb7a6 h=2 l=14 sits inside an argument list of old 75
+160 S7 old79  part b6d8e147eb9a h=2 l=4 sits inside an argument list of old 78
+161 S7 old55  main 38cfd9f096ad h=5 l=98 
+162 S7 old94  main 0fc23632e1d9 h=8 l=42 
+163 S7 old105 part bafbe3e759a0 h=4 l=58 subtopic debug_meta
+164 S7 old107 main 5b273677ccbc h=9 l=47 
+DONE 5b273677ccbcbf2b38363b20187a98812dc2a515 tree 4b52f5d678467702efe5b45bacb7aee8f4d0019c
+torn blocks: 14
+TORN old76 fs/btrfs/block-group.c [{] S1:13l | S2:1l
+TORN old91 fs/btrfs/block-group.c [{] S1:38l | S6:8l
+TORN old104 fs/btrfs/block-group.h [enum btrfs_stripe_run_class {] S1:9l | S6:23l
+TORN old105 fs/btrfs/btrfs_inode.h [struct btrfs_inode {] S1:11l | S4:9l
+TORN old105 fs/btrfs/extent-tree.c [{] S1:15l | S2:15l
+TORN old105 fs/btrfs/extent-tree.c [{] S2:20l | S6:10l
+TORN old105 fs/btrfs/file.c [{] S1:4l | S4:11l
+TORN old105 fs/btrfs/free-space-cache.c [{] S1:12l | S3:8l
+TORN old105 fs/btrfs/fs.h [struct btrfs_fs_info {] S1:33l | S4:6l | S5:4l | S6:5l | S7:5l
+TORN old30 fs/btrfs/raid56.c [{] S1:12l | S2:2l
+TORN old105 fs/btrfs/raid56.c [{] S1:31l | S2:8l
+TORN old105 fs/btrfs/raid56.c [{] S1:6l | S6:11l
+TORN old105 fs/btrfs/space-info.h [struct btrfs_space_info {] S1:14l | S6:39l
+TORN old78 fs/btrfs/sysfs.c [{] S1:2l | S7:14l
diff --git a/scripts/sa-reorder/wreplay-y15.json b/scripts/sa-reorder/wreplay-y15.json
new file mode 100644 (file)
index 0000000..fa59db0
--- /dev/null
@@ -0,0 +1,3838 @@
+[
+ {
+  "sha": "cafb9bcb65fc5d32dea16887a52f2304e9fad9f0",
+  "key": [
+   0,
+   0
+  ],
+  "src": 1,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 376,
+  "files": [
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: add btrfs_claim_free_stripe_run() for stripe-exclusive allocation"
+ },
+ {
+  "sha": "ba7a11d90baa2dc4417c240e749d482d36f06ea7",
+  "key": [
+   1,
+   0
+  ],
+  "src": 2,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 15,
+  "lines": 519,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/tests/btrfs-tests.c",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: add open stripe run tracking for stripe-exclusive allocation"
+ },
+ {
+  "sha": "91a0d5fbb185cdca7f72a3b51235d2ec88cb61e3",
+  "key": [
+   2,
+   0
+  ],
+  "src": 3,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 42,
+  "lines": 434,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/super.c",
+   "fs/btrfs/tests/free-space-tests.c",
+   "fs/btrfs/zoned.c",
+   "fs/btrfs/zoned.h"
+  ],
+  "why": [],
+  "subject": "btrfs: add the stripe_alloc allocation policy for raid56 data"
+ },
+ {
+  "sha": "4160a0b745ffcc231164356a5a90e2e5c1602d88",
+  "key": [
+   3,
+   0
+  ],
+  "src": 4,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 18,
+  "lines": 173,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/ordered-data.h"
+  ],
+  "why": [],
+  "subject": "btrfs: report stripe run data IO through the ordered extent lifecycle"
+ },
+ {
+  "sha": "1b1019c4c78438d01fe1883450c205f9ca8da751",
+  "key": [
+   4,
+   0
+  ],
+  "src": 5,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 27,
+  "lines": 290,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/ordered-data.h",
+   "fs/btrfs/super.c",
+   "fs/btrfs/tests/free-space-tests.c",
+   "fs/btrfs/transaction.c",
+   "fs/btrfs/transaction.h"
+  ],
+  "why": [],
+  "subject": "btrfs: retire stripe runs at commit and gate stripe_alloc"
+ },
+ {
+  "sha": "e3d3fff7c4d31dcf5c69cf95bbed9e7c78ffcd42",
+  "key": [
+   5,
+   0
+  ],
+  "src": 7,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 105,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/super.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: refuse space_cache=v1"
+ },
+ {
+  "sha": "7525e3a5ca48c6c03c60e0d7908a5f2cbca7f2fc",
+  "key": [
+   6,
+   0
+  ],
+  "src": 8,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 31,
+  "lines": 419,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/super.c",
+   "fs/btrfs/sysfs.c",
+   "fs/btrfs/transaction.c",
+   "include/trace/events/btrfs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: account stripe_alloc trapped free space for honest statfs"
+ },
+ {
+  "sha": "a0765de28eb29cf1254895e4b972be08085740c0",
+  "key": [
+   7,
+   0
+  ],
+  "src": 9,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 24,
+  "lines": 243,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep an open run per size band to trap less"
+ },
+ {
+  "sha": "fb82fd869c7579369500e0bdd8a33c72d5cc5003",
+  "key": [
+   8,
+   0
+  ],
+  "src": 10,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 105,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: grow the frontier run instead of stranding its tail"
+ },
+ {
+  "sha": "2283f041d5b6508e9b75c2594c10b08734ace0fa",
+  "key": [
+   9,
+   0
+  ],
+  "src": 11,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 23,
+  "lines": 316,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h"
+  ],
+  "why": [
+   "transfer into old 11"
+  ],
+  "subject": "btrfs: raid56: batch stripe_alloc partial writes into full-stripe writes"
+ },
+ {
+  "sha": "e69804de43b0235cebc7d7268bad2495790a73b9",
+  "key": [
+   10,
+   0
+  ],
+  "src": 12,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 43,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: never claim stripes covered by a live run"
+ },
+ {
+  "sha": "dc3b2bfc9def12f33088b054bd12f0c5ee496daa",
+  "key": [
+   11,
+   0
+  ],
+  "src": 13,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 202,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/props.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: control the policy with a filesystem property"
+ },
+ {
+  "sha": "ab73e027d08b946b7268b7ef13ed037710a97472",
+  "key": [
+   12,
+   0
+  ],
+  "src": 15,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 24,
+  "lines": 265,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/direct-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/file.c",
+   "fs/btrfs/inode.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: private per-inode stripe runs for log-active inodes"
+ },
+ {
+  "sha": "ca493ee0f5147f6a99463d0be2a607b31d410ea8",
+  "key": [
+   13,
+   0
+  ],
+  "src": 18,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 141,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: pad sub-stripe writes to full stripes in open runs"
+ },
+ {
+  "sha": "8d8e5ea402920de13a662a64152bded7d0080f24",
+  "key": [
+   14,
+   0
+  ],
+  "src": 23,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 12,
+  "lines": 54,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: expose parking statistics in sysfs"
+ },
+ {
+  "sha": "7983e5f8f2643e78277c9d8651ea9887f31e9c44",
+  "key": [
+   15,
+   0
+  ],
+  "src": 24,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 25,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: skip parking for sync rbios finished by their unplug batch"
+ },
+ {
+  "sha": "3f52774611e7e0af68b5047da4f7a5dc105d368a",
+  "key": [
+   16,
+   0
+  ],
+  "src": 25,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 16,
+  "lines": 70,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations"
+ },
+ {
+  "sha": "911bf629005ddb088c3782014c2a2b3cbb077ac3",
+  "key": [
+   17,
+   0
+  ],
+  "src": 26,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 19,
+  "lines": 204,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: pessimistic data reservation margin"
+ },
+ {
+  "sha": "a3a8aed553c6948a1cd5f0c449a7fd84265cc764",
+  "key": [
+   18,
+   0
+  ],
+  "src": 27,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 217,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: claim fully-free stripes that span free space entries"
+ },
+ {
+  "sha": "46798a53a5a3f22d5f4cbee0817c251599dc9855",
+  "key": [
+   19,
+   0
+  ],
+  "src": 28,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 21,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: warn at mount when raid56 metadata is not covered"
+ },
+ {
+  "sha": "e591400a1f0913fa4039070d2a81685bab2e3220",
+  "key": [
+   20,
+   0
+  ],
+  "src": 29,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 40,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: report read-modify-write of uncovered stripes"
+ },
+ {
+  "sha": "bb27525adb1e9727ee0ac1652b39fcd8af973444",
+  "key": [
+   21,
+   0
+  ],
+  "src": 31,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 15,
+  "lines": 128,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined"
+ },
+ {
+  "sha": "d3c47d97b3a962f9cdcba61bb5679b262f889cd5",
+  "key": [
+   22,
+   0
+  ],
+  "src": 32,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 133,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "include/trace/events/btrfs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: trace why padding declined, at the moment it declined"
+ },
+ {
+  "sha": "afbabf7c96bc741466ae2bc1c8cde2b2dab701ca",
+  "key": [
+   23,
+   0
+  ],
+  "src": 33,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 21,
+  "lines": 164,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: complete parked writes on allocation coverage, not clocks"
+ },
+ {
+  "sha": "2c937f1f391d684c1a61899ff8003d85271fcc4d",
+  "key": [
+   24,
+   0
+  ],
+  "src": 34,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 42,
+  "lines": 477,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: track per-sector liveness and pad from the map"
+ },
+ {
+  "sha": "990b38d1c56372cf7f1ce57bd6307daf77a8fbdb",
+  "key": [
+   25,
+   0
+  ],
+  "src": 35,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 24,
+  "lines": 144,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c",
+   "include/trace/events/btrfs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count claimable whole-stripe supply directly"
+ },
+ {
+  "sha": "1b651efb421f47ee90c33b872e3f120f339d8c2a",
+  "key": [
+   26,
+   0
+  ],
+  "src": 36,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 7,
+  "lines": 32,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: adaptive park deadline from the parked-rbio backlog"
+ },
+ {
+  "sha": "64cca995f34997d5389c3a910aa6c742e2b1c7eb",
+  "key": [
+   27,
+   0
+  ],
+  "src": 37,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 39,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: gate data admission on claimable whole-stripe supply"
+ },
+ {
+  "sha": "687e7bd37eac6fc2496005699a8b24d4023fd174",
+  "key": [
+   28,
+   0
+  ],
+  "src": 38,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 50,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: cache a failed stripe run scan per block group"
+ },
+ {
+  "sha": "03a9e494ed6b8e5c867666ec408f229aa6f4ba8e",
+  "key": [
+   29,
+   0
+  ],
+  "src": 41,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 16,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not count trapped free space twice when making a block group read-only"
+ },
+ {
+  "sha": "7800828b9bc108a8fdf80c8e88b3c2178ba1425e",
+  "key": [
+   30,
+   0
+  ],
+  "src": 42,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 13,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep the admitted bytes placeable when a group goes read-only"
+ },
+ {
+  "sha": "defefff7ee88728c7b7c29f0652a1a6d884ec7a2",
+  "key": [
+   31,
+   0
+  ],
+  "src": 43,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 28,
+  "files": [
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: never let relocation wait on the whole-stripe gate"
+ },
+ {
+  "sha": "15aa910f27b667b6279285a595fc67461060a420",
+  "key": [
+   32,
+   0
+  ],
+  "src": 45,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 25,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: charge relocation a margin per reservation, not per extent"
+ },
+ {
+  "sha": "e85b96f90afaeff8e3a84875835a116dbb8776f9",
+  "key": [
+   33,
+   0
+  ],
+  "src": 46,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 12,
+  "lines": 71,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep the relocation group's stripes out of the admission supply"
+ },
+ {
+  "sha": "eb77ce16eadde89f1b8bd3e89dc258f02968731e",
+  "key": [
+   34,
+   0
+  ],
+  "src": 47,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 19,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let a data write fall back to the relocation group rather than drop"
+ },
+ {
+  "sha": "3a148f81c3e3c3bef863404ed0ba95e9a09820f5",
+  "key": [
+   35,
+   0
+  ],
+  "src": 56,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 6,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: show per-group trapped bytes in the space info dump"
+ },
+ {
+  "sha": "c75b6d1856bfdb51ff253edf36978b1da649bff1",
+  "key": [
+   36,
+   0
+  ],
+  "src": 59,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 77,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped"
+ },
+ {
+  "sha": "4c46b6c5201a94a9c2e2c5766678e8252ed2a5a1",
+  "key": [
+   37,
+   0
+  ],
+  "src": 61,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 7,
+  "lines": 43,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count nocow run lifecycles and stranded stripes in sysfs"
+ },
+ {
+  "sha": "f15601fb56230fb044331e99f32f26b98e302e78",
+  "key": [
+   38,
+   0
+  ],
+  "src": 62,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 17,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: charge the held stripe margin against every admission"
+ },
+ {
+  "sha": "1ab2fc220fd73fca457ed69f0c03e8c0dcae59e6",
+  "key": [
+   39,
+   0
+  ],
+  "src": 63,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 14,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: admit data reservations by whole stripes"
+ },
+ {
+  "sha": "4d52e2f4f0c2b2ee429bc1f185e6fa0420d82592",
+  "key": [
+   40,
+   0
+  ],
+  "src": 64,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 17,
+  "lines": 58,
+  "files": [
+   "fs/btrfs/file.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: hold a stripe of margin across a preallocation"
+ },
+ {
+  "sha": "687b299965f5e81ff3f661c297e35ca694a02ce0",
+  "key": [
+   41,
+   0
+  ],
+  "src": 65,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 20,
+  "lines": 60,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/delalloc-space.h",
+   "fs/btrfs/direct-io.c",
+   "fs/btrfs/file.c",
+   "fs/btrfs/inode.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: hold the probe margin until the metadata reservation charges it"
+ },
+ {
+  "sha": "6546aafc69ef0e389d769431ecbd92785c82d2b4",
+  "key": [
+   42,
+   0
+  ],
+  "src": 66,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 20,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: saturate the read-only guard's claimable subtraction"
+ },
+ {
+  "sha": "7e9bbfd68e2cee76ff137dd626c2183ca1de0fe3",
+  "key": [
+   43,
+   0
+  ],
+  "src": 68,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 18,
+  "lines": 106,
+  "files": [
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/delalloc-space.h",
+   "fs/btrfs/file.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: charge the preallocation's stripe hold under the reservation lock"
+ },
+ {
+  "sha": "a223554eb2b013f175e3326fe16956f0ed2664f6",
+  "key": [
+   44,
+   0
+  ],
+  "src": 69,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 27,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: return a group's allocation cluster before scanning its stripes"
+ },
+ {
+  "sha": "230ac02c2f2abbe00c1b80b7e87dbf09968c7fef",
+  "key": [
+   45,
+   0
+  ],
+  "src": 72,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 47,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: release open stripe runs when a mount fails or an aborted filesystem unmounts"
+ },
+ {
+  "sha": "9432e750bc459ec02401e759ff8b41252b89930e",
+  "key": [
+   46,
+   0
+  ],
+  "src": 73,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 19,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let the property accept a cache-less filesystem like the mount option does"
+ },
+ {
+  "sha": "4ad4ecf6fc6075562bd7c2205424160aaf663e2a",
+  "key": [
+   47,
+   0
+  ],
+  "src": 74,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 46,
+  "files": [
+   "fs/btrfs/super.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: say at mount whether the policy is on"
+ },
+ {
+  "sha": "8c8da935331192124d21b3a23df7d763e39496bc",
+  "key": [
+   48,
+   0
+  ],
+  "src": 75,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 23,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: hold a reference on the rbio being parked"
+ },
+ {
+  "sha": "df7ad260cf1b9869fe2d2af0867919a216056074",
+  "key": [
+   49,
+   0
+  ],
+  "src": 76,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 74,
+  "files": [
+   "fs/btrfs/super.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: drop the mount options, the property is the interface"
+ },
+ {
+  "sha": "b8acca738af499ba268c06ca70463af917726222",
+  "key": [
+   51,
+   0
+  ],
+  "src": 80,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 44,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/messages.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not wait for stripe runs to drain on an errored filesystem"
+ },
+ {
+  "sha": "611b1c2553df2304957896a7cafe30af1cc821ac",
+  "key": [
+   52,
+   0
+  ],
+  "src": 81,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 13,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: end the commit-time and log drains on an errored filesystem too"
+ },
+ {
+  "sha": "88a005364239f102f644caa8b04b79eb892e3d25",
+  "key": [
+   53,
+   0
+  ],
+  "src": 88,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 62,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/fs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep relocation's stripe runs until relocation ends"
+ },
+ {
+  "sha": "e21e94c1968e5ee0376be88b1aafac31fda7b228",
+  "key": [
+   54,
+   0
+  ],
+  "src": 89,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 32,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let relocation allocate a data chunk before it fails"
+ },
+ {
+  "sha": "87291ad42095270a38ef54643d66afd278c4126c",
+  "key": [
+   55,
+   0
+  ],
+  "src": 90,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 23,
+  "lines": 296,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it"
+ },
+ {
+  "sha": "9fc0ea54c25528cd34f8fa6c8df2758ddb2dac20",
+  "key": [
+   56,
+   0
+  ],
+  "src": 91,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 13,
+  "lines": 66,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: pad a stripe's allocated sectors whose write is still to come"
+ },
+ {
+  "sha": "3f7ae53bc4a000bfb6dd2fd59325bd75c433e236",
+  "key": [
+   57,
+   0
+  ],
+  "src": 92,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 65,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/props.c",
+   "fs/btrfs/props.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: apply the property before tree-log replay"
+ },
+ {
+  "sha": "ab13c3242038bbcb7b5ce1e90b864577984d89c1",
+  "key": [
+   58,
+   0
+  ],
+  "src": 93,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 69,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count refused rbio pins and track rbio cache high water"
+ },
+ {
+  "sha": "01c8b3a5af0c0ae671931f1cb3194486160cd823",
+  "key": [
+   59,
+   0
+  ],
+  "src": 94,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 94,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/transaction.c"
+  ],
+  "why": [
+   "transfer into old 94"
+  ],
+  "subject": "btrfs: stripe_alloc: sweep stale rbio pins, and commit when live pins run low"
+ },
+ {
+  "sha": "edcc40fffc4887d3236542d5d77123bc1a2e8bae",
+  "key": [
+   60,
+   0
+  ],
+  "src": 97,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 26,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: don't make a parked rbio wait for sectors that will never be written"
+ },
+ {
+  "sha": "b68eaf63639cc5f3883431ecf22316fde935ab58",
+  "key": [
+   61,
+   0
+  ],
+  "src": 99,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let relocation allocate as many data chunks as its reservation needs"
+ },
+ {
+  "sha": "2401451d4be7453a4df7ac25bdbee26c441c0e0c",
+  "key": [
+   62,
+   0
+  ],
+  "src": 101,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 16,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not treat an allocation error as a found extent"
+ },
+ {
+  "sha": "cacb873d82601f061d9eda0800d2d7b93629599e",
+  "key": [
+   63,
+   0
+  ],
+  "src": 102,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 22,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/ordered-data.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: mark an ended ordered extent's sectors written"
+ },
+ {
+  "sha": "61ff93a92f4bfce1cf8ac966f39916e256fd48ba",
+  "key": [
+   64,
+   0
+  ],
+  "src": 104,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 42,
+  "files": [
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: remove only the set bits of a bitmap when claiming a split run"
+ },
+ {
+  "sha": "3333de9bd3bc077eba130d115efe02315494427b",
+  "key": [
+   65,
+   0
+  ],
+  "src": 106,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 108,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep the stripe totals consistent with the groups during the commit scan"
+ },
+ {
+  "sha": "3ee585a55b32b2265aa7b4640fe69f6c1b6c3397",
+  "key": [
+   66,
+   0
+  ],
+  "src": 107,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 27,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not delete an unused block group that still has stripe runs"
+ },
+ {
+  "sha": "b9e5c4eeface0db893e935fa0a1c7ca086e8b710",
+  "key": [
+   67,
+   0
+  ],
+  "src": 110,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 24,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: stop the park timer before destroying the raid56 workqueue"
+ },
+ {
+  "sha": "c1f37b0ffc5f015c33781ae0c3f2cc574c75c5a1",
+  "key": [
+   68,
+   0
+  ],
+  "src": 111,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 7,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: order the filesystem error before waking stripe drain waiters"
+ },
+ {
+  "sha": "1827827be4fbde53597752b8c43a433a74e559e8",
+  "key": [
+   69,
+   0
+  ],
+  "src": 112,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: set a padded rbio's data bitmap under bio_list_lock"
+ },
+ {
+  "sha": "a83bd479062f90c2cc7b8e8fa46c34b17fce1fb4",
+  "key": [
+   70,
+   0
+  ],
+  "src": 113,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: forget the failed-claim verdict when a cluster returns its space"
+ },
+ {
+  "sha": "5a93a979d6a732b29d507a2c7fdcefec4db7bb10",
+  "key": [
+   71,
+   0
+  ],
+  "src": 114,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/super.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not let a remount revert the stripe_alloc property"
+ },
+ {
+  "sha": "16933b1c39893ca3b7739bc13e61e1801461efce",
+  "key": [
+   72,
+   0
+  ],
+  "src": 116,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 29,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: keep the head of a claimed free space entry under the lock"
+ },
+ {
+  "sha": "16f62afbbf3358dbea5b6bf98597cbe67d0080d1",
+  "key": [
+   72,
+   0,
+   1,
+   126
+  ],
+  "src": 119,
+  "sub": 1,
+  "tag": "base",
+  "kind": "part",
+  "hunks": 29,
+  "lines": 363,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h"
+  ],
+  "why": [
+   "subtopic base"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (base part)"
+ },
+ {
+  "sha": "b92a80103ca4922b691bbc4de102f7dfb4a3a12e",
+  "key": [
+   72,
+   0,
+   1,
+   127
+  ],
+  "src": 120,
+  "sub": 1,
+  "tag": "base",
+  "kind": "part",
+  "hunks": 52,
+  "lines": 621,
+  "files": [
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/delalloc-space.c",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/file.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/ordered-data.c",
+   "fs/btrfs/props.c",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/super.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "subtopic base"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (base part)"
+ },
+ {
+  "sha": "df6a11be2683138509ae8208440a288fff80f28a",
+  "key": [
+   73,
+   0
+  ],
+  "src": 124,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 36,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/volumes.c",
+   "fs/btrfs/volumes.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3"
+ },
+ {
+  "sha": "46bbf0fdc6837b42d565c4b9f01e338243746b43",
+  "key": [
+   74,
+   0
+  ],
+  "src": 125,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 18,
+  "lines": 113,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count single-data-stripe groups' free space in write admission"
+ },
+ {
+  "sha": "43d66fd16683571ec27d4feadcd58b023b4317e1",
+  "key": [
+   75,
+   0
+  ],
+  "src": 127,
+  "sub": 1,
+  "tag": "base",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 72,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not refuse leftover v1 space cache inodes"
+ },
+ {
+  "sha": "c49b36ab01bc217bf8730be09f5b731a567e2138",
+  "key": [
+   76,
+   0
+  ],
+  "src": 19,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 17,
+  "lines": 104,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/direct-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/inode.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: isolate nodatacow and preallocated extents by stripe"
+ },
+ {
+  "sha": "85dabd17a9f81880ef6084e252b949cf0b35864c",
+  "key": [
+   76,
+   0,
+   1,
+   37
+  ],
+  "src": 61,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "uses BTRFS_STRIPE_RUN_NOCOW from old 19"
+  ],
+  "subject": "btrfs: stripe_alloc: count nocow run lifecycles and stranded stripes in sysfs (allow_rmw part)"
+ },
+ {
+  "sha": "cac5a94a07b07515b6498f7773e5c3a5efb34525",
+  "key": [
+   76,
+   0,
+   1,
+   55
+  ],
+  "src": 90,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "uses BTRFS_STRIPE_RUN_NOCOW from old 19"
+  ],
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it (allow_rmw part)"
+ },
+ {
+  "sha": "46af137e99fa02859b2121e7f8980405990d0327",
+  "key": [
+   76,
+   0,
+   1,
+   56
+  ],
+  "src": 91,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 1,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "uses BTRFS_STRIPE_RUN_NOCOW from old 19"
+  ],
+  "subject": "btrfs: stripe_alloc: pad a stripe's allocated sectors whose write is still to come (allow_rmw part)"
+ },
+ {
+  "sha": "07f323bc6dec8e72e03c14d609f6086528b2b2f6",
+  "key": [
+   77,
+   0
+  ],
+  "src": 20,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 23,
+  "lines": 371,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/file.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/props.c",
+   "fs/btrfs/super.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents"
+ },
+ {
+  "sha": "4770c743fd169290e427f6caf1b6cabea6d54a7d",
+  "key": [
+   77,
+   0,
+   1,
+   24
+  ],
+  "src": 34,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 26,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 20"
+  ],
+  "subject": "btrfs: stripe_alloc: track per-sector liveness and pad from the map (allow_rmw part)"
+ },
+ {
+  "sha": "b8b2b290cae3491800e8985822fb7504363fd79a",
+  "key": [
+   77,
+   0,
+   1,
+   24,
+   1,
+   126
+  ],
+  "src": 119,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 16,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 34"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part)"
+ },
+ {
+  "sha": "5f39d581705aa54e9d8750fa63c95ddc52c349a9",
+  "key": [
+   77,
+   0,
+   1,
+   49
+  ],
+  "src": 76,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 6,
+  "lines": 29,
+  "files": [
+   "fs/btrfs/super.c"
+  ],
+  "why": [
+   "deletes a line of old 20"
+  ],
+  "subject": "btrfs: stripe_alloc: drop the mount options, the property is the interface (allow_rmw part)"
+ },
+ {
+  "sha": "d9ebc6c0147fa78ba661442429f3a4a8155219a7",
+  "key": [
+   77,
+   0,
+   1,
+   50
+  ],
+  "src": 79,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 18,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "defines stripe_round_down for its first user, old 79",
+   "deletes a line of old 20"
+  ],
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros"
+ },
+ {
+  "sha": "89ad0bfd76765aa8ac2736cca42f23b4bb47664e",
+  "key": [
+   77,
+   0,
+   1,
+   50,
+   1,
+   126
+  ],
+  "src": 119,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 79"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part 2)"
+ },
+ {
+  "sha": "c8412f42f542edd3d1cc56bc1018cad9609dbd7c",
+  "key": [
+   78,
+   0
+  ],
+  "src": 21,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 18,
+  "lines": 299,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/inode.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: persist nocow runs across commits and remounts"
+ },
+ {
+  "sha": "6f6ee679355d89a5800b48b9c84595eb34e13f06",
+  "key": [
+   78,
+   0,
+   1,
+   16
+  ],
+  "src": 25,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 1,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "sits inside a block of old 21"
+  ],
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations (allow_rmw part)"
+ },
+ {
+  "sha": "394e8dc4c7ff4c69c8e980e6a1b490eabbb5f13d",
+  "key": [
+   78,
+   0,
+   1,
+   50
+  ],
+  "src": 79,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 21"
+  ],
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros (allow_rmw part 2)"
+ },
+ {
+  "sha": "a1adaaac8a70c3020ac694b5a44ddcf030c9f838",
+  "key": [
+   79,
+   0
+  ],
+  "src": 22,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 16,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: do not park sync writes into nocow runs"
+ },
+ {
+  "sha": "a843abd337fbf769fc45c1136727af5e3cc56cc4",
+  "key": [
+   79,
+   0,
+   1,
+   21
+  ],
+  "src": 31,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [
+   "deletes a line of old 22"
+  ],
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined (allow_rmw part)"
+ },
+ {
+  "sha": "0d19ad88e9d2cc6cc67dd38ce2c8694c2ac2727b",
+  "key": [
+   80,
+   0
+  ],
+  "src": 58,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 15,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not read an inline backref off a keyed-ref extent item"
+ },
+ {
+  "sha": "199420a36f15a7462dae881e2645382d015967ce",
+  "key": [
+   81,
+   0
+  ],
+  "src": 60,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 49,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: give nocow extents a private run only while they may be written in place"
+ },
+ {
+  "sha": "0ab77c218666df626230960441f9d8362acf16f0",
+  "key": [
+   82,
+   0
+  ],
+  "src": 78,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 8,
+  "lines": 96,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: close dead nocow stripe runs at commit"
+ },
+ {
+  "sha": "48c6ab8c7c5d655dcfd613027fc1b8187f0ba60a",
+  "key": [
+   83,
+   0
+  ],
+  "src": 100,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 28,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode"
+ },
+ {
+  "sha": "840af84d36fbf6033be3888563598aa8dc1617e8",
+  "key": [
+   84,
+   0
+  ],
+  "src": 105,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 70,
+  "files": [
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/tests/free-space-tests.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: claim a stripe tail in one free space lock section"
+ },
+ {
+  "sha": "1507483df45704c702d3e8df0f6fd7775f8da0da",
+  "key": [
+   85,
+   0
+  ],
+  "src": 115,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 13,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/inode.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not block a NOWAIT write in the nocow stripe check"
+ },
+ {
+  "sha": "ecfb2b365bf992b76b0f3f9e78c963e3e49041d8",
+  "key": [
+   86,
+   0
+  ],
+  "src": 118,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/fs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: remove the unused stripe_rmw_opt field"
+ },
+ {
+  "sha": "0b09a9d421f3753e867447929887afdf66f9a08e",
+  "key": [
+   86,
+   0,
+   1,
+   126
+  ],
+  "src": 119,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 9,
+  "lines": 136,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h"
+  ],
+  "why": [
+   "subtopic allow_rmw"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (allow_rmw part 3)"
+ },
+ {
+  "sha": "c7c60d5e1983a6c11f9d997b5c4c51cccd2ab878",
+  "key": [
+   86,
+   0,
+   1,
+   127
+  ],
+  "src": 120,
+  "sub": 2,
+  "tag": "allow_rmw",
+  "kind": "part",
+  "hunks": 6,
+  "lines": 82,
+  "files": [
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [
+   "subtopic allow_rmw"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (allow_rmw part)"
+ },
+ {
+  "sha": "535dc594db94935074674cdb4691137019f0356e",
+  "key": [
+   87,
+   0
+  ],
+  "src": 44,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 29,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: give a queued stripe group a chunk to relocate into when the supply is short"
+ },
+ {
+  "sha": "fa0871abcca9f022b7c0f594dc057d277affc541",
+  "key": [
+   88,
+   0
+  ],
+  "src": 48,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 128,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: hand groups full of trapped free space to the reclaim worker"
+ },
+ {
+  "sha": "ec72f899fa5a7477a4c277a7604b7bbbe80ceeae",
+  "key": [
+   88,
+   0,
+   1,
+   36
+  ],
+  "src": 59,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [
+   "deletes a line of old 48"
+  ],
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped (reclaim part)"
+ },
+ {
+  "sha": "c5772a3c2b5548f0c9dab698a39d8a9170d97ac7",
+  "key": [
+   89,
+   0
+  ],
+  "src": 49,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: relocate a queued stripe group even while it has reserved or pinned bytes"
+ },
+ {
+  "sha": "a8c0236ab2d7053cdec1fd2d84a1ddccab244543",
+  "key": [
+   90,
+   0
+  ],
+  "src": 84,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 40,
+  "lines": 528,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/relocation.h",
+   "fs/btrfs/sysfs.c",
+   "fs/btrfs/volumes.c",
+   "fs/btrfs/volumes.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: compact mostly live groups instead of skipping them"
+ },
+ {
+  "sha": "400467f937bfbd3cc2c22782b65b1cb161308c1d",
+  "key": [
+   90,
+   0,
+   1,
+   53
+  ],
+  "src": 88,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 84"
+  ],
+  "subject": "btrfs: stripe_alloc: keep relocation's stripe runs until relocation ends (reclaim part)"
+ },
+ {
+  "sha": "976cd78b55bc2d866e39b5c163fc47f63ab3ac25",
+  "key": [
+   91,
+   0
+  ],
+  "src": 85,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 36,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: compact a mostly live group by its trapped share of the group"
+ },
+ {
+  "sha": "44a7ddcf7f8c1abf2e70a835bdb38b59b8499191",
+  "key": [
+   91,
+   0,
+   1,
+   127
+  ],
+  "src": 120,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "part",
+  "hunks": 4,
+  "lines": 55,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [
+   "subtopic reclaim"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (reclaim part)"
+ },
+ {
+  "sha": "6ef83b6a827f7a836d318f5507ccc9d2b0185805",
+  "key": [
+   92,
+   0
+  ],
+  "src": 129,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 15,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: log block group reclaim at debug level"
+ },
+ {
+  "sha": "1024a01c2571edb690fa362f62dca974b40f5d5d",
+  "key": [
+   93,
+   0
+  ],
+  "src": 130,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 17,
+  "lines": 263,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/free-space-cache.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: add stripe_reclaim_now to reclaim stripes on demand"
+ },
+ {
+  "sha": "8c2a02d1d937a3f094dfccf546f7c1c2dc60cb0f",
+  "key": [
+   94,
+   0
+  ],
+  "src": 131,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 15,
+  "lines": 152,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: back off block group reclaim after repeated ENOSPC"
+ },
+ {
+  "sha": "5534996f541c55cb5a3b114888b8e08edf374464",
+  "key": [
+   95,
+   0
+  ],
+  "src": 132,
+  "sub": 3,
+  "tag": "reclaim",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 86,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/fs.c",
+   "fs/btrfs/fs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: let queued exclusive operations in between reclaims"
+ },
+ {
+  "sha": "4c272644f4706cb873d042e258249d9e86598d66",
+  "key": [
+   96,
+   0
+  ],
+  "src": 14,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 113,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/tree-log.c"
+  ],
+  "why": [
+   "folded into old 14: deletes a line of old 14"
+  ],
+  "subject": "btrfs: stripe_alloc: settle a logged extent's stripes at log commit"
+ },
+ {
+  "sha": "8214af6628d31c964a1a3443251f1935de3edcc4",
+  "key": [
+   96,
+   0,
+   1,
+   16
+  ],
+  "src": 25,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 14"
+  ],
+  "subject": "btrfs: stripe_alloc: count open stripe run remainders against data reservations (fsync part)"
+ },
+ {
+  "sha": "21b5abc1f5dde23b6581a505aa14f93156e59627",
+  "key": [
+   96,
+   0,
+   1,
+   52
+  ],
+  "src": 81,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 3,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 14"
+  ],
+  "subject": "btrfs: stripe_alloc: end the commit-time and log drains on an errored filesystem too (fsync part)"
+ },
+ {
+  "sha": "c69b11b80b2c3bfee9e5045259bc8b74ae5ee65d",
+  "key": [
+   96,
+   0,
+   1,
+   77
+  ],
+  "src": 20,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 15,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "sits inside a block of old 14"
+  ],
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (fsync part)"
+ },
+ {
+  "sha": "b88d9ffce79aa54f33a4862d120eb1764e1f62a3",
+  "key": [
+   97,
+   0
+  ],
+  "src": 16,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 21,
+  "lines": 308,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/defrag.c",
+   "fs/btrfs/defrag.h",
+   "fs/btrfs/file.c",
+   "fs/btrfs/inode.c",
+   "fs/btrfs/tree-log.c"
+  ],
+  "why": [
+   "folded into old 16: deletes a line of old 16",
+   "folded into old 16: sits inside a block of old 16"
+  ],
+  "subject": "btrfs: stripe_alloc: carry an inode's log tail forward at fsync"
+ },
+ {
+  "sha": "9fd4f251fece52ad239b9d525a73522b002685c0",
+  "key": [
+   97,
+   0,
+   1,
+   50
+  ],
+  "src": 79,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 9,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "defines stripe_is_aligned for its first user, old 79",
+   "deletes a line of old 16"
+  ],
+  "subject": "btrfs: stripe_alloc: do not round a full stripe with power-of-two macros (fsync part)"
+ },
+ {
+  "sha": "279c4f3e8b140e6154a4f0312301e38be8b687f7",
+  "key": [
+   97,
+   0,
+   1,
+   77
+  ],
+  "src": 20,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 3,
+  "files": [
+   "fs/btrfs/defrag.c"
+  ],
+  "why": [
+   "sits inside a block of old 16"
+  ],
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (fsync part 2)"
+ },
+ {
+  "sha": "2cf66d0889ae9d509b0717e38589aada3ac8c5f3",
+  "key": [
+   98,
+   0
+  ],
+  "src": 17,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 3,
+  "lines": 26,
+  "files": [
+   "fs/btrfs/file.c"
+  ],
+  "why": [
+   "folded into old 17: deletes a line of old 17"
+  ],
+  "subject": "btrfs: stripe_alloc: kick parked rbios before the fast fsync's writeback wait"
+ },
+ {
+  "sha": "2eb9e09278911c1d42cd04a2acd41af4d5a5ba3b",
+  "key": [
+   99,
+   0
+  ],
+  "src": 98,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 22,
+  "lines": 223,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/defrag.c",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "transfer into old 98"
+  ],
+  "subject": "btrfs: stripe_alloc: share LOG data runs per log transaction"
+ },
+ {
+  "sha": "96e28638bdb4d5f37f3b80264c637e6fbb159e54",
+  "key": [
+   99,
+   0,
+   1,
+   83
+  ],
+  "src": 100,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 7,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 98"
+  ],
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode (fsync part)"
+ },
+ {
+  "sha": "cfa6f4889fdd62e7633c02b7714e11c6dc64882a",
+  "key": [
+   100,
+   0
+  ],
+  "src": 103,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 12,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: read the shared LOG run mode once per log settle"
+ },
+ {
+  "sha": "eb666a2bfd3fb98d7868780c9d73c07dfc3c20b3",
+  "key": [
+   100,
+   0,
+   1,
+   126
+  ],
+  "src": 119,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 3,
+  "lines": 68,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "subtopic fsync"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (fsync part)"
+ },
+ {
+  "sha": "8be8f633ba7df90b4f3971ba91cc793b915e3fae",
+  "key": [
+   100,
+   0,
+   1,
+   127
+  ],
+  "src": 120,
+  "sub": 4,
+  "tag": "fsync",
+  "kind": "part",
+  "hunks": 7,
+  "lines": 72,
+  "files": [
+   "fs/btrfs/btrfs_inode.h",
+   "fs/btrfs/defrag.c",
+   "fs/btrfs/file.c",
+   "fs/btrfs/fs.h"
+  ],
+  "why": [
+   "subtopic fsync"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (fsync part)"
+ },
+ {
+  "sha": "045d603bb8e6e402cf6d6cd859bce4df2c46a093",
+  "key": [
+   101,
+   0
+  ],
+  "src": 6,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 80,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: add a write-hole invariant checker to the raid56 write path"
+ },
+ {
+  "sha": "6ce0164e2c5a06a5097d3452f1ea30602e570c8c",
+  "key": [
+   101,
+   0,
+   1,
+   20,
+   1,
+   20
+  ],
+  "src": 29,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 4,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "joined with its other hunks in the patch",
+   "uses meta_rmw from old 29"
+  ],
+  "subject": "btrfs: stripe_alloc: report read-modify-write of uncovered stripes (debug part)"
+ },
+ {
+  "sha": "47d273e586f62831949344bbf18b08c6e732bb49",
+  "key": [
+   101,
+   0,
+   1,
+   77
+  ],
+  "src": 20,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 3,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 6"
+  ],
+  "subject": "btrfs: stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents (debug part)"
+ },
+ {
+  "sha": "27521ca4a8601c09ab441d8145914db0ef38d11e",
+  "key": [
+   102,
+   0
+  ],
+  "src": 40,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 49,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: drain the legacy allocator's writes before arming the write-hole check at a runtime enable"
+ },
+ {
+  "sha": "042aeeb21cb29ef91b3b101b57e694b5113bce1d",
+  "key": [
+   102,
+   0,
+   1,
+   47
+  ],
+  "src": 74,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 12,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 40"
+  ],
+  "subject": "btrfs: stripe_alloc: say at mount whether the policy is on (debug part)"
+ },
+ {
+  "sha": "d0ee1e8e692ddf95bb88cb76144b60cdc2aa9bac",
+  "key": [
+   102,
+   0,
+   1,
+   47,
+   1,
+   126
+  ],
+  "src": 119,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 6,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 74"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (debug part)"
+ },
+ {
+  "sha": "9601e30f0d1ef3441319bbe3a2348af2170792a1",
+  "key": [
+   103,
+   0
+  ],
+  "src": 86,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 19,
+  "lines": 127,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: attribute each data read-modify-write to why padding declined"
+ },
+ {
+  "sha": "7a17f8e398ab34190e66c9a0c881fde33de32d60",
+  "key": [
+   104,
+   0
+  ],
+  "src": 87,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 16,
+  "lines": 402,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: optionally audit data read-modify-writes against the committed extent tree"
+ },
+ {
+  "sha": "2b1ef385d2eead23f67c51326832855ecb728126",
+  "key": [
+   105,
+   0
+  ],
+  "src": 95,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 10,
+  "lines": 98,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/raid56.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: break rbio pins and open stripe runs down by run class"
+ },
+ {
+  "sha": "3ed6e6f3d1b05099bcbd42c085e9c98961b9ce02",
+  "key": [
+   105,
+   0,
+   1,
+   126
+  ],
+  "src": 119,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 6,
+  "lines": 63,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "subtopic debug"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments (debug part 2)"
+ },
+ {
+  "sha": "8e7ae70a79d7b47d691033d122968af939e86388",
+  "key": [
+   105,
+   0,
+   1,
+   127
+  ],
+  "src": 120,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "part",
+  "hunks": 3,
+  "lines": 14,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "subtopic debug"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (debug part)"
+ },
+ {
+  "sha": "03576b1f8537e77ce3da7cd24cb800a2e6ee06da",
+  "key": [
+   106,
+   0
+  ],
+  "src": 123,
+  "sub": 5,
+  "tag": "debug",
+  "kind": "main",
+  "hunks": 8,
+  "lines": 50,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/ordered-data.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: count and log ordered extents that end with sectors unwritten"
+ },
+ {
+  "sha": "5a6aeba2e32b9f8008dae5dc87c30002b138a29d",
+  "key": [
+   107,
+   0
+  ],
+  "src": 39,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 37,
+  "lines": 487,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent_io.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/sysfs.c",
+   "fs/btrfs/transaction.c",
+   "fs/btrfs/tree-log.c"
+  ],
+  "why": [
+   "folded into old 39",
+   "folded into old 39: deletes a line of old 39"
+  ],
+  "subject": "btrfs: stripe_meta: allocate tree blocks by whole stripes"
+ },
+ {
+  "sha": "fe2f7ffd46a102bf97e3a064186b3c7cdf2c82a9",
+  "key": [
+   107,
+   0,
+   1,
+   49
+  ],
+  "src": 76,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 4,
+  "lines": 54,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "forced after old 39"
+  ],
+  "subject": "btrfs: stripe_alloc: drop the mount options, the property is the interface (stripe_meta part)"
+ },
+ {
+  "sha": "77980c99aae5984f984c538f0cfb861a86166ef7",
+  "key": [
+   107,
+   0,
+   1,
+   73
+  ],
+  "src": 124,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 3,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [
+   "deletes a line of old 39"
+  ],
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3 (stripe_meta part)"
+ },
+ {
+  "sha": "eb1786b5c5b1d6ebe4efc19d7a2fe22ae70ceadb",
+  "key": [
+   108,
+   0
+  ],
+  "src": 49.5,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "new",
+  "hunks": 19,
+  "lines": 44,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/free-space-cache.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/sysfs.c",
+   "fs/btrfs/volumes.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: extend stripe reclaim to metadata block groups",
+  "srcs": [
+   49.5,
+   132.5
+  ]
+ },
+ {
+  "sha": "061f51cbcccb71a9a4775756bd6cd65d03676623",
+  "key": [
+   111,
+   0
+  ],
+  "src": 50,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 21,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: maintain trapped free space for metadata groups like data"
+ },
+ {
+  "sha": "03b61a9077fe5e9f1d5b3ff7a807d668f4285e7c",
+  "key": [
+   112,
+   0
+  ],
+  "src": 51,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 33,
+  "files": [
+   "fs/btrfs/block-rsv.c",
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: back the global reserve with usable stripes, and say when a tree block finds none"
+ },
+ {
+  "sha": "df82d94f7b4bc08d4b9c08a626d29537d35d34a7",
+  "key": [
+   113,
+   0
+  ],
+  "src": 52,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 22,
+  "lines": 118,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: hold back whole stripes so tree blocks always land and trapped groups can be reclaimed"
+ },
+ {
+  "sha": "96140be66107b68e1aa29eed16c4466afd4ddeab",
+  "key": [
+   113,
+   0,
+   1,
+   36
+  ],
+  "src": 59,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 5,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [
+   "deletes a line of old 52"
+  ],
+  "subject": "btrfs: stripe_alloc: count whole stripes stranded behind live runs as trapped (stripe_meta part)"
+ },
+ {
+  "sha": "f5b1b6eb854376e924e0a1666c2392140947c6de",
+  "key": [
+   113,
+   0,
+   1,
+   65
+  ],
+  "src": 106,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "deletes a line of old 52"
+  ],
+  "subject": "btrfs: stripe_alloc: keep the stripe totals consistent with the groups during the commit scan (stripe_meta part)"
+ },
+ {
+  "sha": "fa00481614d568e6843eea708335179fce297368",
+  "key": [
+   113,
+   0,
+   1,
+   74
+  ],
+  "src": 125,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 5,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [
+   "deletes a line of old 52",
+   "joined with its other hunks in fs/btrfs/space-info.c"
+  ],
+  "subject": "btrfs: stripe_alloc: count single-data-stripe groups' free space in write admission (stripe_meta part)"
+ },
+ {
+  "sha": "579b06b5e4b328bb6ee4c0d18204f5a802b5c9f5",
+  "key": [
+   114,
+   0
+  ],
+  "src": 53,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 17,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: do not steal from the global reserve below the relocation reserve"
+ },
+ {
+  "sha": "633522ae90c4ee29ed08aa2d7783e768f4c899fe",
+  "key": [
+   115,
+   0
+  ],
+  "src": 54,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 14,
+  "files": [
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: let the transaction machinery's own reservations draw on the reserve"
+ },
+ {
+  "sha": "a478ae36eeaaf37fdc62ea0ca41ad00ec43e0178",
+  "key": [
+   116,
+   0
+  ],
+  "src": 55,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 9,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: let a group go read-only for relocation against the reserve"
+ },
+ {
+  "sha": "cfbf9b350fd8b6e8195a8f184d699eab6311bc5c",
+  "key": [
+   117,
+   0
+  ],
+  "src": 67,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 55,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: carry raid56 metadata groups through a runtime enable or disable"
+ },
+ {
+  "sha": "f0c6a1a11e40a256680e6cfe31fb05a90ef63b9a",
+  "key": [
+   118,
+   0
+  ],
+  "src": 70,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: sync the open-run remainder when the commit retires metadata runs"
+ },
+ {
+  "sha": "25919b2306b347cfebd77025424e60cc7bd44aeb",
+  "key": [
+   119,
+   0
+  ],
+  "src": 71,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 17,
+  "files": [
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: do not call a covered stripe_meta group uncovered"
+ },
+ {
+  "sha": "4d0fe90f3d8ae3bd105d7fc77952d926e2c81409",
+  "key": [
+   120,
+   0
+  ],
+  "src": 77,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 92,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: cover raid56 system chunks"
+ },
+ {
+  "sha": "46ab516d31a80c3068b00ec0ef1f2526ff8b39a4",
+  "key": [
+   121,
+   0
+  ],
+  "src": 82,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 4,
+  "lines": 11,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/relocation.c",
+   "fs/btrfs/space-info.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: grant the stripe_meta reserve to all of a relocation"
+ },
+ {
+  "sha": "39b5c3c058b3b22183cf283575f7072d26506024",
+  "key": [
+   122,
+   0
+  ],
+  "src": 83,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 27,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: let mount-time orphan cleanup steal from the global reserve"
+ },
+ {
+  "sha": "f8f4135cbda1fdc07805e070051084964880e3e4",
+  "key": [
+   123,
+   0
+  ],
+  "src": 96,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 25,
+  "lines": 285,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/extent-tree.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: give each log commit its own metadata stripe run"
+ },
+ {
+  "sha": "315a9d3f50c0b347bbfa3e9ffa161827b922aba3",
+  "key": [
+   123,
+   0,
+   1,
+   83
+  ],
+  "src": 100,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 1,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [
+   "sits inside a block of old 96"
+  ],
+  "subject": "btrfs: stripe_alloc: key private stripe runs by subvolume and inode (stripe_meta part)"
+ },
+ {
+  "sha": "ce6eca6126cba8e8adbcd72087bbf24e0d67c56c",
+  "key": [
+   123,
+   0,
+   1,
+   99
+  ],
+  "src": 98,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 3,
+  "lines": 19,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "deletes a line of old 96",
+   "sits inside a block of old 96"
+  ],
+  "subject": "btrfs: stripe_alloc: share LOG data runs per log transaction (stripe_meta part)"
+ },
+ {
+  "sha": "b53eccf0e929430e2acd95ded4c1239dc1442dfc",
+  "key": [
+   124,
+   0
+  ],
+  "src": 108,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 61,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: commit before waiting for metadata runs when making a group read-only"
+ },
+ {
+  "sha": "3f5e022bfc507b1b4cdcc859fabe8778761e5def",
+  "key": [
+   125,
+   0
+  ],
+  "src": 117,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 10,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: check the block group lookup when freeing an unwritten tree block"
+ },
+ {
+  "sha": "681a7dd25cc97ecabc29a011a5f5d7e1f19aa872",
+  "key": [
+   126,
+   0
+  ],
+  "src": 119,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 11,
+  "lines": 183,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: correct and trim the block group comments"
+ },
+ {
+  "sha": "d047c20346152f1e455c5302a9301c17475299a6",
+  "key": [
+   127,
+   0
+  ],
+  "src": 120,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 141,
+  "files": [
+   "fs/btrfs/disk-io.c",
+   "fs/btrfs/extent-tree.c",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/space-info.c",
+   "fs/btrfs/space-info.h",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code"
+ },
+ {
+  "sha": "4c0e7af1dac2fe5612ae9d46ffc93effb54d8123",
+  "key": [
+   127,
+   0,
+   1,
+   73
+  ],
+  "src": 124,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "part",
+  "hunks": 1,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/extent-tree.c"
+  ],
+  "why": [
+   "deletes a line of old 120"
+  ],
+  "subject": "btrfs: stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3 (stripe_meta part 2)"
+ },
+ {
+  "sha": "57406320b7088066062304534ac0ba157c177779",
+  "key": [
+   128,
+   0
+  ],
+  "src": 121,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 2,
+  "lines": 21,
+  "files": [
+   "fs/btrfs/block-group.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_meta: keep waiting for metadata runs that do not drain at commit"
+ },
+ {
+  "sha": "2a0c74e6042b37ef99ff12192a5685e477662629",
+  "key": [
+   129,
+   0
+  ],
+  "src": 126,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 13,
+  "lines": 160,
+  "files": [
+   "fs/btrfs/block-group.c",
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: account claimable stripes while a trim has them out"
+ },
+ {
+  "sha": "066e39b07e64f44f27dcf07bc6663df9087b8d73",
+  "key": [
+   130,
+   0
+  ],
+  "src": 128,
+  "sub": 6,
+  "tag": "stripe_meta",
+  "kind": "main",
+  "hunks": 1,
+  "lines": 9,
+  "files": [
+   "fs/btrfs/free-space-cache.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: do not miss bitmap free space when debiting a trim"
+ },
+ {
+  "sha": "60b5d4dd238919ddec767a4fb0d3f84c2eac42f2",
+  "key": [
+   130,
+   0,
+   2,
+   106
+  ],
+  "src": 123,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "deletes a line of old 98; after the stripe_meta subtopic"
+  ],
+  "subject": "btrfs: stripe_alloc: count and log ordered extents that end with sectors unwritten (debug_meta part)"
+ },
+ {
+  "sha": "22f3ecd8fe5421adf068ee7fac3f976a12eff444",
+  "key": [
+   131,
+   0
+  ],
+  "src": 30,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "main",
+  "hunks": 6,
+  "lines": 144,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: say whether a metadata read-modify-write is a write hole"
+ },
+ {
+  "sha": "4e154926ff3704d43340876f65c92d37985ed88f",
+  "key": [
+   131,
+   0,
+   1,
+   21
+  ],
+  "src": 31,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 30"
+  ],
+  "subject": "btrfs: stripe_alloc: tunable park deadlines, and say why padding declined (debug_meta part)"
+ },
+ {
+  "sha": "d2679761bd7b5ddb8728d2e3bcce32eca7b910bb",
+  "key": [
+   131,
+   0,
+   1,
+   21,
+   1,
+   22
+  ],
+  "src": 32,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 2,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 31"
+  ],
+  "subject": "btrfs: stripe_alloc: trace why padding declined, at the moment it declined (debug_meta part)"
+ },
+ {
+  "sha": "28cbb07e1ee1b32b324b6c94434f088cfc54eab9",
+  "key": [
+   131,
+   0,
+   1,
+   21,
+   1,
+   22,
+   1,
+   103
+  ],
+  "src": 86,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 28,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 32"
+  ],
+  "subject": "btrfs: stripe_alloc: attribute each data read-modify-write to why padding declined (debug_meta part)"
+ },
+ {
+  "sha": "26d435ee23b8a2f3dc08bd294ddd5ddfcb945fc8",
+  "key": [
+   131,
+   0,
+   1,
+   26
+  ],
+  "src": 36,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 8,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "deletes a line of old 30"
+  ],
+  "subject": "btrfs: raid56: adaptive park deadline from the parked-rbio backlog (debug_meta part)"
+ },
+ {
+  "sha": "75b65df00fe682cc26c26868f264044a2b056f3b",
+  "key": [
+   131,
+   0,
+   1,
+   26,
+   1,
+   55
+  ],
+  "src": 90,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 36"
+  ],
+  "subject": "btrfs: stripe_alloc: keep a stripe in the rbio cache until its run has written all of it (debug_meta part)"
+ },
+ {
+  "sha": "fe12f5d1407bbf66fecff7a324a660adc7242029",
+  "key": [
+   131,
+   0,
+   1,
+   26,
+   1,
+   55,
+   1,
+   58
+  ],
+  "src": 93,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 14,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 90"
+  ],
+  "subject": "btrfs: stripe_alloc: count refused rbio pins and track rbio cache high water (debug_meta part)"
+ },
+ {
+  "sha": "cd8b0ca3413b1c604ba07f2c3c4adfcfb40d34f4",
+  "key": [
+   131,
+   0,
+   1,
+   26,
+   1,
+   55,
+   1,
+   58,
+   1,
+   59
+  ],
+  "src": 94,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 2,
+  "lines": 4,
+  "files": [
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [
+   "sits inside an argument list of old 93"
+  ],
+  "subject": "btrfs: stripe_alloc: sweep stale rbio pins, and commit when live pins run low (debug_meta part)"
+ },
+ {
+  "sha": "860239e8e39b3121c7153ab690c4c7f3682fe6c5",
+  "key": [
+   132,
+   0
+  ],
+  "src": 57,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "main",
+  "hunks": 5,
+  "lines": 98,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: tell a dead tree block from a live one in the metadata RMW audit"
+ },
+ {
+  "sha": "13d98e81c8dded7c8fe5e39880c632084d2781af",
+  "key": [
+   133,
+   0
+  ],
+  "src": 109,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "main",
+  "hunks": 8,
+  "lines": 42,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: raid56: do not read tree blocks under the stripe lock in the metadata RMW audit"
+ },
+ {
+  "sha": "965d4c406681549df10bde46863f423abe87cabe",
+  "key": [
+   133,
+   0,
+   1,
+   127
+  ],
+  "src": 120,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "part",
+  "hunks": 4,
+  "lines": 58,
+  "files": [
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c"
+  ],
+  "why": [
+   "subtopic debug_meta"
+  ],
+  "subject": "btrfs: stripe_alloc: correct and trim the comments outside the block group code (debug_meta part)"
+ },
+ {
+  "sha": "1c579504322a7e4d51cf76d9d1449660fa711635",
+  "key": [
+   134,
+   0
+  ],
+  "src": 122,
+  "sub": 7,
+  "tag": "debug_meta",
+  "kind": "main",
+  "hunks": 9,
+  "lines": 47,
+  "files": [
+   "fs/btrfs/block-group.h",
+   "fs/btrfs/fs.h",
+   "fs/btrfs/raid56.c",
+   "fs/btrfs/sysfs.c"
+  ],
+  "why": [],
+  "subject": "btrfs: stripe_alloc: remove pad refusal reasons that no longer exist"
+ }
+]
\ No newline at end of file
diff --git a/scripts/sa-reorder/wreplay-y15.log b/scripts/sa-reorder/wreplay-y15.log
new file mode 100644 (file)
index 0000000..156df18
--- /dev/null
@@ -0,0 +1,248 @@
+nomatch: old20 fs/btrfs/block-group.c bool btrfs_stripe_in_open_run(struct btrfs_fs_info *fs_info, u64 logical)
+weave: 42 files
+rewrite: old44 fs/btrfs/block-group.c:                  * A stripe_alloc group's live extents can only | synth 49.5:            * A stripe_alloc / stripe_meta group's live extents can only
+rewrite: old49 fs/btrfs/block-group.c:                          * Not for a stripe_alloc group: under | synth 49.5:                     * Not for a stripe_alloc or stripe_meta group: under
+rewrite: old48 fs/btrfs/block-group.c:  * Periodic re-evaluation of stripe_alloc groups from the | synth 49.5:  * Periodic re-evaluation of stripe_alloc / stripe_meta groups from the
+rewrite: old130 fs/btrfs/block-group.c:  * /sys/fs/btrfs/<uuid>/stripe_reclaim_now: reclaim stripe_alloc | synth 132.5:  * /sys/fs/btrfs/<uuid>/stripe_reclaim_now: reclaim stripe_alloc / stripe_meta
+rewrite: old130 fs/btrfs/block-group.c:  * there; -EINVAL: not a stripe_alloc raid56 group (relocate | synth 132.5:  * there; -EINVAL: not a stripe_alloc / stripe_meta raid56 group (relocate
+rewrite in place: old48 del old120 fs/btrfs/free-space-cache.c:  * Does this stripe_alloc / stripe_meta group want the reclaim worker?  Like ->  * Does this stripe_alloc group want the reclaim worker?  Like
+rewrite: old120 fs/btrfs/free-space-cache.c:  * Does this stripe_alloc group want the reclaim worker?  As | synth 132.5:  * Does this stripe_alloc / stripe_meta group want the reclaim worker?  As
+rewrite in place: old84 del old85 fs/btrfs/fs.h:        * Let reclaim compact a mostly live stripe_alloc / stripe_meta group ->         * Let reclaim compact a mostly live stripe_alloc group
+rewrite: old85 fs/btrfs/fs.h:   * Reclaim compacts a mostly live stripe_alloc group once | synth 132.5:         * Reclaim compacts a mostly live stripe_alloc / stripe_meta group once
+rewrite: old84 fs/btrfs/block-group.c:                          * Too full to relocate whole.  A stripe_alloc | synth 132.5:                    * Too full to relocate whole.  A stripe_alloc /
+rewrite: old84 fs/btrfs/block-group.c:                          * group whose free space is trapped in | synth 132.5:                   * stripe_meta group whose free space is trapped in
+rewrite: old130 fs/btrfs/sysfs.c:  * Reclaim stripe_alloc raid56 block groups now: "all" (or "1") | synth 132.5:  * Reclaim stripe_alloc / stripe_meta raid56 block groups now: "all" (or "1")
+rewrite: old84 fs/btrfs/volumes.c:  * Compact a stripe_alloc group: relocate only the extents in | synth 132.5:  * Compact a stripe_alloc / stripe_meta group: relocate only the extents in
+rewrite: old84 fs/btrfs/relocation.c:  * Stripe compaction.  A stripe_alloc group whose free space is | synth 132.5:  * Stripe compaction.  A stripe_alloc / stripe_meta group whose free space is
+rewrite: old44 fs/btrfs/block-group.c:                 if (btrfs_is_stripe_alloc_bg(bg)) { | synth 49.5:               if (btrfs_is_stripe_alloc_bg(bg) || btrfs_is_stripe_meta_bg(bg)) {
+rewrite: old48 fs/btrfs/block-group.c:                 if (!(sinfo->flags & BTRFS_BLOCK_GROUP_DATA)) | synth 49.5:             if (!(sinfo->flags & (BTRFS_BLOCK_GROUP_DATA |
+rewrite: old48 fs/btrfs/block-group.c: None | synth 49.5:                                    BTRFS_BLOCK_GROUP_METADATA))) (del old77)
+rewrite: old49 fs/btrfs/block-group.c:                      !btrfs_is_stripe_alloc_bg(bg))) { | synth 49.5:                 !btrfs_is_stripe_alloc_bg(bg) &&
+rewrite: old49 fs/btrfs/block-group.c: None | synth 49.5:                   !btrfs_is_stripe_meta_bg(bg))) {
+rewrite: old84 fs/btrfs/relocation.c:  * again instead of removed. | synth 132.5:  * again instead of removed.  A tree block never spans a stripe, so for a
+rewrite: old84 fs/btrfs/relocation.c: None | synth 132.5:  * metadata group the closure is the partial stripes themselves.
+rewrite: old84 fs/btrfs/relocation.c: None | synth 132.5:              else if (key.type == BTRFS_METADATA_ITEM_KEY)
+rewrite: old84 fs/btrfs/relocation.c: None | synth 132.5:                      len = fs_info->nodesize;
+rewrite: old84 fs/btrfs/relocation.c: None | synth 132.5:      struct btrfs_fs_info *fs_info = bg->fs_info;
+rewrite: old130 fs/btrfs/block-group.c:                } else if (!btrfs_is_stripe_alloc_bg(bg)) { | synth 132.5:              } else if (!btrfs_is_stripe_alloc_bg(bg) &&
+rewrite: old130 fs/btrfs/block-group.c: None | synth 132.5:                       !btrfs_is_stripe_meta_bg(bg)) {
+rewrite: old130 fs/btrfs/block-group.c:                                if (!btrfs_is_stripe_alloc_bg(bg)) | synth 132.5:                               if (!btrfs_is_stripe_alloc_bg(bg) &&
+rewrite: old130 fs/btrfs/block-group.c: None | synth 132.5:                                !btrfs_is_stripe_meta_bg(bg))
+rewrite: old95 fs/btrfs/sysfs.c:               "cow", "reloc", "log", "nocow", | synth 95.5:           "cow", "reloc", "log", "nocow", "meta", (del old96)
+hunks: 1339
+transfer: old6 fs/btrfs/raid56.c #include "block-group.h" -> old11
+transfer: old39 fs/btrfs/transaction.c #include "raid56.h" -> old94
+transfer: old98 fs/btrfs/disk-io.c fs_info->stripe_log_data_shared = true; -> old98
+split stmt: old29 fs/btrfs/raid56.c atomic64_inc(&fs_info->stripe_park_stats.meta_rmw);
+force: old76 fs/btrfs/block-group.c hunk with /^static void warn_stripe_alloc_uncovered\(/ -> after old39
+force: old76 fs/btrfs/block-group.c hunk with /^static void warn_stripe_alloc_uncovered\(/ -> after old39
+force: old76 fs/btrfs/block-group.c hunk with /^\twarn_stripe_alloc_uncovered\((fs_)?info\);/ -> after old39
+force: old76 fs/btrfs/block-group.c hunk with /^\twarn_stripe_alloc_uncovered\((fs_)?info\);/ -> after old39
+force: old29 fs/btrfs/fs.h hunk with /atomic64_t meta_rmw;/ -> after old6
+force: old29 fs/btrfs/sysfs.c hunk with /meta_rmw/ -> after old6
+force: old29 fs/btrfs/sysfs.c hunk with /meta_rmw/ -> after old6
+name split: old90 fs/btrfs/block-group.c 2l: if (run->class == BTRFS_STRIPE_RUN_NOCOW)
+name split: old91 fs/btrfs/block-group.c 1l: run->class != BTRFS_STRIPE_RUN_NOCOW &&
+names: 521 new to the tree, 2 statements split out
+static function definitions tracked: 118
+def move: old79 stripe_is_aligned (50, 0) -> (97, 0, 1, 50) (user old79)
+def move: old79 stripe_round_down (50, 0) -> (77, 0, 1, 50) (user old79)
+fixpoint rounds: 4
+  1 S1 old1   main cafb9bcb65fc h=6 l=376 
+  2 S1 old2   main ba7a11d90baa h=15 l=519 
+  3 S1 old3   main 91a0d5fbb185 h=42 l=434 
+  4 S1 old4   main 4160a0b745ff h=18 l=173 
+  5 S1 old5   main 1b1019c4c784 h=27 l=290 
+  6 S1 old7   main e3d3fff7c4d3 h=6 l=105 
+  7 S1 old8   main 7525e3a5ca48 h=31 l=419 
+  8 S1 old9   main a0765de28eb2 h=24 l=243 
+  9 S1 old10  main fb82fd869c75 h=9 l=105 
+ 10 S1 old11  main 2283f041d5b6 h=23 l=316 transfer into old 11
+ 11 S1 old12  main e69804de43b0 h=4 l=43 
+ 12 S1 old13  main dc3b2bfc9def h=11 l=202 
+ 13 S1 old15  main ab73e027d08b h=24 l=265 
+ 14 S1 old18  main ca493ee0f514 h=6 l=141 
+ 15 S1 old23  main 8d8e5ea40292 h=12 l=54 
+ 16 S1 old24  main 7983e5f8f264 h=4 l=25 
+ 17 S1 old25  main 3f52774611e7 h=16 l=70 
+ 18 S1 old26  main 911bf629005d h=19 l=204 
+ 19 S1 old27  main a3a8aed553c6 h=6 l=217 
+ 20 S1 old28  main 46798a53a5a3 h=2 l=21 
+ 21 S1 old29  main e591400a1f09 h=2 l=40 
+ 22 S1 old31  main bb27525adb1e h=15 l=128 
+ 23 S1 old32  main d3c47d97b3a9 h=11 l=133 
+ 24 S1 old33  main afbabf7c96bc h=21 l=164 
+ 25 S1 old34  main 2c937f1f391d h=42 l=477 
+ 26 S1 old35  main 990b38d1c563 h=24 l=144 
+ 27 S1 old36  main 1b651efb421f h=7 l=32 
+ 28 S1 old37  main 64cca995f349 h=3 l=39 
+ 29 S1 old38  main 687e7bd37eac h=5 l=50 
+ 30 S1 old41  main 03a9e494ed6b h=2 l=16 
+ 31 S1 old42  main 7800828b9bc1 h=1 l=13 
+ 32 S1 old43  main defefff7ee88 h=6 l=28 
+ 33 S1 old45  main 15aa910f27b6 h=4 l=25 
+ 34 S1 old46  main e85b96f90afa h=12 l=71 
+ 35 S1 old47  main eb77ce16eadd h=1 l=19 
+ 36 S1 old56  main 3a148f81c3e3 h=1 l=6 
+ 37 S1 old59  main c75b6d1856bf h=11 l=77 
+ 38 S1 old61  main 4c46b6c5201a h=7 l=43 
+ 39 S1 old62  main f15601fb5623 h=1 l=17 
+ 40 S1 old63  main 1ab2fc220fd7 h=1 l=14 
+ 41 S1 old64  main 4d52e2f4f0c2 h=17 l=58 
+ 42 S1 old65  main 687b299965f5 h=20 l=60 
+ 43 S1 old66  main 6546aafc69ef h=1 l=20 
+ 44 S1 old68  main 7e9bbfd68e2c h=18 l=106 
+ 45 S1 old69  main a223554eb2b0 h=3 l=27 
+ 46 S1 old72  main 230ac02c2f2a h=4 l=47 
+ 47 S1 old73  main 9432e750bc45 h=1 l=19 
+ 48 S1 old74  main 4ad4ecf6fc60 h=5 l=46 
+ 49 S1 old75  main 8c8da9353311 h=3 l=23 
+ 50 S1 old76  main df7ad260cf1b h=6 l=74 
+ 51 S1 old80  main b8acca738af4 h=5 l=44 
+ 52 S1 old81  main 611b1c2553df h=1 l=13 
+ 53 S1 old88  main 88a005364239 h=10 l=62 
+ 54 S1 old89  main e21e94c1968e h=2 l=32 
+ 55 S1 old90  main 87291ad42095 h=23 l=296 
+ 56 S1 old91  main 9fc0ea54c255 h=13 l=66 
+ 57 S1 old92  main 3f7ae53bc4a0 h=6 l=65 
+ 58 S1 old93  main ab13c3242038 h=9 l=69 
+ 59 S1 old94  main 01c8b3a5af0c h=10 l=94 transfer into old 94
+ 60 S1 old97  main edcc40fffc48 h=2 l=26 
+ 61 S1 old99  main b68eaf63639c h=1 l=10 
+ 62 S1 old101 main 2401451d4be7 h=4 l=16 
+ 63 S1 old102 main cacb873d8260 h=4 l=22 
+ 64 S1 old104 main 61ff93a92f4b h=2 l=42 
+ 65 S1 old106 main 3333de9bd3bc h=9 l=108 
+ 66 S1 old107 main 3ee585a55b32 h=3 l=27 
+ 67 S1 old110 main b9e5c4eeface h=4 l=24 
+ 68 S1 old111 main c1f37b0ffc5f h=1 l=7 
+ 69 S1 old112 main 1827827be4fb h=1 l=8 
+ 70 S1 old113 main a83bd479062f h=1 l=2 
+ 71 S1 old114 main 5a93a979d6a7 h=1 l=10 
+ 72 S1 old116 main 16933b1c3989 h=3 l=29 
+ 73 S1 old119 part 16f62afbbf33 h=29 l=363 subtopic base
+ 74 S1 old120 part b92a80103ca4 h=52 l=621 subtopic base
+ 75 S1 old124 main df6a11be2683 h=6 l=36 
+ 76 S1 old125 main 46bbf0fdc683 h=18 l=113 
+ 77 S1 old127 main 43d66fd16683 h=5 l=72 
+ 78 S2 old19  main c49b36ab01bc h=17 l=104 
+ 79 S2 old61  part 85dabd17a9f8 h=1 l=2 uses BTRFS_STRIPE_RUN_NOCOW from old 19
+ 80 S2 old90  part cac5a94a07b0 h=1 l=2 uses BTRFS_STRIPE_RUN_NOCOW from old 19
+ 81 S2 old91  part 46af137e99fa h=1 l=1 uses BTRFS_STRIPE_RUN_NOCOW from old 19
+ 82 S2 old20  main 07f323bc6dec h=23 l=371 
+ 83 S2 old34  part 4770c743fd16 h=1 l=26 deletes a line of old 20
+ 84 S2 old119 part b8b2b290cae3 h=1 l=16 deletes a line of old 34
+ 85 S2 old76  part 5f39d581705a h=6 l=29 deletes a line of old 20
+ 86 S2 old79  main d9ebc6c0147f h=2 l=18 defines stripe_round_down for its first user, old 79;deletes a line of old 20
+ 87 S2 old119 part 89ad0bfd7676 h=1 l=10 deletes a line of old 79
+ 88 S2 old21  main c8412f42f542 h=18 l=299 
+ 89 S2 old25  part 6f6ee679355d h=1 l=1 sits inside a block of old 21
+ 90 S2 old79  part 394e8dc4c7ff h=1 l=2 deletes a line of old 21
+ 91 S2 old22  main a1adaaac8a70 h=2 l=16 
+ 92 S2 old31  part a843abd337fb h=1 l=2 deletes a line of old 22
+ 93 S2 old58  main 0d19ad88e9d2 h=1 l=15 
+ 94 S2 old60  main 199420a36f15 h=6 l=49 
+ 95 S2 old78  main 0ab77c218666 h=8 l=96 
+ 96 S2 old100 main 48c6ab8c7c5d h=9 l=28 
+ 97 S2 old105 main 840af84d36fb h=4 l=70 
+ 98 S2 old115 main 1507483df457 h=4 l=13 
+ 99 S2 old118 main ecfb2b365bf9 h=2 l=4 
+100 S2 old119 part 0b09a9d421f3 h=9 l=136 subtopic allow_rmw
+101 S2 old120 part c7c60d5e1983 h=6 l=82 subtopic allow_rmw
+102 S3 old44  main 535dc594db94 h=1 l=29 
+103 S3 old48  main fa0871abcca9 h=9 l=128 
+104 S3 old59  part ec72f899fa5a h=1 l=8 deletes a line of old 48
+105 S3 old49  main c5772a3c2b55 h=2 l=10 
+106 S3 old84  main a8c0236ab2d7 h=40 l=528 
+107 S3 old88  part 400467f937bf h=2 l=4 sits inside an argument list of old 84
+108 S3 old85  main 976cd78b55bc h=5 l=36 
+109 S3 old120 part 44a7ddcf7f8c h=4 l=55 subtopic reclaim
+110 S3 old129 main 6ef83b6a827f h=3 l=15 
+111 S3 old130 main 1024a01c2571 h=17 l=263 
+112 S3 old131 main 8c2a02d1d937 h=15 l=152 
+113 S3 old132 main 5534996f541c h=10 l=86 
+114 S4 old14  main 4c272644f470 h=6 l=113 folded into old 14: deletes a line of old 14
+115 S4 old25  part 8214af6628d3 h=1 l=4 deletes a line of old 14
+116 S4 old81  part 21b5abc1f5dd h=1 l=3 deletes a line of old 14
+117 S4 old20  part c69b11b80b2c h=2 l=15 sits inside a block of old 14
+118 S4 old16  main b88d9ffce79a h=21 l=308 folded into old 16: deletes a line of old 16;folded into old 16: sits inside a block of old 16
+119 S4 old79  part 9fd4f251fece h=2 l=9 defines stripe_is_aligned for its first user, old 79;deletes a line of old 16
+120 S4 old20  part 279c4f3e8b14 h=1 l=3 sits inside a block of old 16
+121 S4 old17  main 2cf66d0889ae h=3 l=26 folded into old 17: deletes a line of old 17
+122 S4 old98  main 2eb9e0927891 h=22 l=223 transfer into old 98
+123 S4 old100 part 96e28638bdb4 h=2 l=7 deletes a line of old 98
+124 S4 old103 main cfa6f4889fdd h=5 l=12 
+125 S4 old119 part eb666a2bfd3f h=3 l=68 subtopic fsync
+126 S4 old120 part 8be8f633ba7d h=7 l=72 subtopic fsync
+127 S5 old6   main 045d603bb8e6 h=5 l=80 
+128 S5 old29  part 6ce0164e2c5a h=4 l=8 joined with its other hunks in the patch;uses meta_rmw from old 29
+129 S5 old20  part 47d273e586f6 h=1 l=3 deletes a line of old 6
+130 S5 old40  main 27521ca4a860 h=10 l=49 
+131 S5 old74  part 042aeeb21cb2 h=1 l=12 deletes a line of old 40
+132 S5 old119 part d0ee1e8e692d h=1 l=6 deletes a line of old 74
+133 S5 old86  main 9601e30f0d1e h=19 l=127 
+134 S5 old87  main 7a17f8e398ab h=16 l=402 
+135 S5 old95  main 2b1ef385d2ee h=10 l=98 
+136 S5 old119 part 3ed6e6f3d1b0 h=6 l=63 subtopic debug
+137 S5 old120 part 8e7ae70a79d7 h=3 l=14 subtopic debug
+138 S5 old123 main 03576b1f8537 h=8 l=50 
+139 S6 old39  main 5a6aeba2e32b h=37 l=487 folded into old 39;folded into old 39: deletes a line of old 39
+140 S6 old76  part fe2f7ffd46a1 h=4 l=54 forced after old 39
+141 S6 old124 part 77980c99aae5 h=1 l=3 deletes a line of old 39
+142 S6 old49.5 new  9068184d0715 h=6 l=14 
+142 S6 synth132.5 merged into the previous commit eb1786b5c5b1 l=44
+143 S6 old50  main 061f51cbcccb h=4 l=21 
+144 S6 old51  main 03b61a9077fe h=2 l=33 
+145 S6 old52  main df82d94f7b4b h=22 l=118 
+146 S6 old59  part 96140be66107 h=1 l=5 deletes a line of old 52
+147 S6 old106 part f5b1b6eb8543 h=1 l=8 deletes a line of old 52
+148 S6 old125 part fa00481614d5 h=2 l=5 deletes a line of old 52;joined with its other hunks in fs/btrfs/space-info.c
+149 S6 old53  main 579b06b5e4b3 h=1 l=17 
+150 S6 old54  main 633522ae90c4 h=1 l=14 
+151 S6 old55  main a478ae36eeaa h=1 l=9 
+152 S6 old67  main cfbf9b350fd8 h=4 l=55 
+153 S6 old70  main f0c6a1a11e40 h=1 l=8 
+154 S6 old71  main 25919b2306b3 h=2 l=17 
+155 S6 old77  main 4d0fe90f3d8a h=11 l=92 
+156 S6 old82  main 46ab516d31a8 h=4 l=11 
+157 S6 old83  main 39b5c3c058b3 h=6 l=27 
+158 S6 old96  main f8f4135cbda1 h=25 l=285 
+159 S6 old100 part 315a9d3f50c0 h=1 l=1 sits inside a block of old 96
+160 S6 old98  part ce6eca6126cb h=3 l=19 deletes a line of old 96;sits inside a block of old 96
+161 S6 old108 main b53eccf0e929 h=6 l=61 
+162 S6 old117 main 3f5e022bfc50 h=1 l=10 
+163 S6 old119 main 681a7dd25cc9 h=11 l=183 
+164 S6 old120 main d047c2034615 h=9 l=141 
+165 S6 old124 part 4c0e7af1dac2 h=1 l=4 deletes a line of old 120
+166 S6 old121 main 57406320b708 h=2 l=21 
+167 S6 old126 main 2a0c74e6042b h=13 l=160 
+168 S6 old128 main 066e39b07e64 h=1 l=9 
+169 S7 old123 part 60b5d4dd2389 h=2 l=8 deletes a line of old 98; after the stripe_meta subtopic
+170 S7 old30  main 22f3ecd8fe54 h=6 l=144 
+171 S7 old31  part 4e154926ff37 h=2 l=8 sits inside an argument list of old 30
+172 S7 old32  part d2679761bd7b h=2 l=2 sits inside an argument list of old 31
+173 S7 old86  part 28cbb07e1ee1 h=2 l=28 sits inside an argument list of old 32
+174 S7 old36  part 26d435ee23b8 h=2 l=8 deletes a line of old 30
+175 S7 old90  part 75b65df00fe6 h=2 l=4 sits inside an argument list of old 36
+176 S7 old93  part fe12f5d1407b h=2 l=14 sits inside an argument list of old 90
+177 S7 old94  part cd8b0ca3413b h=2 l=4 sits inside an argument list of old 93
+178 S7 old57  main 860239e8e39b h=5 l=98 
+179 S7 old109 main 13d98e81c8dd h=8 l=42 
+180 S7 old120 part 965d4c406681 h=4 l=58 subtopic debug_meta
+181 S7 old122 main 1c579504322a h=9 l=47 
+DONE 1c579504322a7e4d51cf76d9d1449660fa711635 tree a87304c553d7c9c45bec62a44c17a01aba024afa
+torn blocks: 14
+TORN old91 fs/btrfs/block-group.c [{] S1:13l | S2:1l
+TORN old106 fs/btrfs/block-group.c [{] S1:38l | S6:8l
+TORN old119 fs/btrfs/block-group.h [enum btrfs_stripe_run_class {] S1:9l | S6:23l
+TORN old120 fs/btrfs/btrfs_inode.h [struct btrfs_inode {] S1:11l | S4:9l
+TORN old120 fs/btrfs/extent-tree.c [{] S1:15l | S2:15l
+TORN old120 fs/btrfs/extent-tree.c [{] S2:20l | S6:10l
+TORN old120 fs/btrfs/file.c [{] S1:4l | S4:11l
+TORN old120 fs/btrfs/free-space-cache.c [{] S1:12l | S3:8l
+TORN old120 fs/btrfs/fs.h [struct btrfs_fs_info {] S1:33l | S4:6l | S5:4l | S6:5l | S7:5l
+TORN old31 fs/btrfs/raid56.c [{] S1:12l | S2:2l
+TORN old120 fs/btrfs/raid56.c [{] S1:31l | S2:8l
+TORN old120 fs/btrfs/raid56.c [{] S1:6l | S6:11l
+TORN old120 fs/btrfs/space-info.h [struct btrfs_space_info {] S1:14l | S6:39l
+TORN old93 fs/btrfs/sysfs.c [{] S1:2l | S7:14l
diff --git a/scripts/sa-reorder/wspec13.py b/scripts/sa-reorder/wspec13.py
new file mode 100644 (file)
index 0000000..412af50
--- /dev/null
@@ -0,0 +1,100 @@
+TAGS = {1: 'base', 2: 'allow_rmw', 3: 'reclaim', 4: 'fsync', 5: 'debug', 6: 'stripe_meta', 7: 'debug_meta'}
+TRANSFER_INS = [(7, 'fs/btrfs/raid56.c', '#include "block-group.h"\n', 11),
+                (38, 'fs/btrfs/transaction.c', '#include "raid56.h"\n', 79),
+                (83, 'fs/btrfs/disk-io.c', '\tfs_info->stripe_log_data_shared = true;\n', 83)]
+PERSUB = [104, 105]
+FORCE = [(28, 'fs/btrfs/fs.h', r'atomic64_t meta_rmw;', 7),
+         (28, 'fs/btrfs/sysfs.c', r'meta_rmw', 7)]
+SPLIT_STMT = [(28, 'fs/btrfs/raid56.c', r'atomic64_inc\(&fs_info->stripe_park_stats\.meta_rmw\);')]
+FOLD = [(32, 13), (25, 15), (32, 16), (81, 80), (73, 38)]
+JOIN = [(28, None, [r'meta_rmw']),
+        (110, 'fs/btrfs/space-info.c', [r'unmanaged_free=%lld', r'bytes_unmanaged_free\)\);'])]
+DEFER = (5, 6, 7)
+NOMATCH = [(19, 'fs/btrfs/block-group.c', r'^bool btrfs_stripe_in_open_run\(')]
+
+# Ruling (A): reclaim is data-only in its subtopic; one stripe_meta commit
+# extends it to metadata block groups.
+EXT_MSG = """btrfs: stripe_meta: extend stripe reclaim to metadata block groups
+
+The stripe reclaim of the reclaim subtopic handles stripe_alloc data block
+groups only.  stripe_meta allocates tree blocks in whole stripes too, so
+its block groups trap free space in partially used stripes the same way,
+and that space comes back only by moving the live tree blocks out of those
+stripes.  Metadata needs it more than data: a metadata reservation that
+finds no claimable stripe aborts the transaction instead of failing one
+write, so trapped metadata space that is never reclaimed ends in a forced
+read-only filesystem.
+
+Extend each reclaim mechanism to stripe_meta block groups:
+
+ - btrfs_reclaim_block_group(): allocate a chunk to relocate into when the
+   other groups' claimable stripes cannot take the group's live bytes, and
+   relocate the group even while it has reserved or pinned bytes.  Under
+   COW, a metadata group always has tree blocks reserved or pinned, so the
+   generic bail-out would defer it forever.
+
+ - The cleaner's periodic re-evaluation scans the metadata space_info as
+   well as the data one.
+
+ - Compaction counts metadata extent items: a tree block is nodesize long
+   and never spans a stripe, so for a metadata group the closure is the
+   partial stripes themselves.
+
+ - stripe_reclaim_now accepts stripe_meta block groups, for one group or
+   for all of them.
+
+The comments that name the groups reclaim handles now name both.
+
+Assisted-by: Claude:claude-opus-5-5
+"""
+ZYGO = ('Zygo Blaxell', 'ce3g8jdj@umail.furryterror.org')
+NOW = '1792702025 -0400'
+SYNTH = [dict(id=64.5, cls=6, place=38.5, msg=EXT_MSG, author=ZYGO, date=NOW, group='reclaim-meta'),
+         dict(id=116.5, cls=6, place=38.6, msg=EXT_MSG, author=ZYGO, date=NOW, group='reclaim-meta')]
+_BG = 'fs/btrfs/block-group.c'
+_CMT = (42, 46, 47, 70, 104, 105, 113, 114, 115, 116)
+REWRITE = [
+    # comments
+    (_BG, {42, 46, 47}, r'stripe_alloc (/|or) stripe_meta', 'stripe_alloc', 64.5),
+    (_BG, {70, 104, 105, 113, 114, 115, 116}, r'stripe_alloc (/|or) stripe_meta', 'stripe_alloc', 116.5),
+    ('fs/btrfs/free-space-cache.c', set(_CMT), r'stripe_alloc (/|or) stripe_meta', 'stripe_alloc', 116.5),
+    ('fs/btrfs/fs.h', {70}, r'stripe_alloc / stripe_meta', 'stripe_alloc', 116.5),
+    ('fs/btrfs/sysfs.c', {114}, r'stripe_alloc / stripe_meta', 'stripe_alloc', 116.5),
+    ('fs/btrfs/volumes.c', {70}, r'stripe_alloc / stripe_meta', 'stripe_alloc', 116.5),
+    ('fs/btrfs/relocation.c', {70}, r'stripe_alloc / stripe_meta', 'stripe_alloc', 116.5),
+    # 42: the chunk for relocating a trapped group
+    (_BG, {42}, r' \|\| btrfs_is_stripe_meta_bg\(bg\)', '', 64.5),
+    # 46: the cleaner's tick
+    (_BG, {46}, r'^(\t\tif \(!\(sinfo->flags & )\(BTRFS_BLOCK_GROUP_DATA \|$', r'\1BTRFS_BLOCK_GROUP_DATA))', 64.5),
+    (_BG, {46}, r'^\t+      BTRFS_BLOCK_GROUP_METADATA\)\)\)$', None, 64.5, 'split_dead'),
+    # 47: the reserved/pinned bail-out
+    (_BG, {47}, r'^(\t     !btrfs_is_stripe_alloc_bg\(bg\)) &&$', r'\1)) {', 64.5),
+    (_BG, {47}, r'^\t     !btrfs_is_stripe_meta_bg\(bg\)\)\) \{$', None, 64.5),
+    # 70: compaction's closure
+    ('fs/btrfs/relocation.c', {70}, r'^( \* again instead of removed\.)  A tree block never spans a stripe, so for a$', r'\1', 116.5),
+    ('fs/btrfs/relocation.c', {70}, r'^ \* metadata group the closure is the partial stripes themselves\.$', None, 116.5),
+    ('fs/btrfs/relocation.c', {70}, r'^\t\telse if \(key\.type == BTRFS_METADATA_ITEM_KEY\)$', None, 116.5),
+    ('fs/btrfs/relocation.c', {70}, r'^\t\t\tlen = fs_info->nodesize;$', None, 116.5),
+    # compact_plan()'s fs_info is used only by the metadata extent length
+    ('fs/btrfs/relocation.c', {70}, r'^\tstruct btrfs_fs_info \*fs_info = bg->fs_info;$', None, 116.5,
+     r'prev:^static int compact_plan\('),
+    # 114: stripe_reclaim_now
+    (_BG, {114}, r'^(\t+\} else if \(!btrfs_is_stripe_alloc_bg\(bg\)) &&$', r'\1) {', 116.5),
+    (_BG, {114}, r'^\t+   !btrfs_is_stripe_meta_bg\(bg\)\) \{$', None, 116.5),
+    (_BG, {114}, r'^(\t+if \(!btrfs_is_stripe_alloc_bg\(bg\)) &&$', r'\1)', 116.5),
+    (_BG, {114}, r'^\t+    !btrfs_is_stripe_meta_bg\(bg\)\)$', None, 116.5),
+]
+JOIN = JOIN + [(64.5, None, ['']), (116.5, None, [''])]
+
+# 80 counts the meta run class, which comes with stripe_meta (38): 38 adds
+# its name, or 80's BUILD_BUG_ON on the array size fails.
+X80_MSG = """btrfs: stripe_alloc: break rbio pins and open stripe runs down by run class (stripe_meta part)
+
+Split from "btrfs: stripe_alloc: break rbio pins and open stripe runs down by run class"
+for the subtopic reorder: the name of the meta run class, which
+"btrfs: stripe_meta: allocate tree blocks by whole stripes" adds.
+
+Assisted-by: Claude:claude-opus-5-5
+"""
+SYNTH.append(dict(id=80.5, cls=6, place=38.7, into=38, msg=X80_MSG, author=ZYGO, date='1791150379 -0400', group='x80'))
+REWRITE.append(('fs/btrfs/sysfs.c', {80}, r'^(\t\t"cow", "reloc", "log", "nocow"), "meta",$', r'\1,', 80.5, 'split_dead'))
diff --git a/scripts/sa-reorder/wspec5.py b/scripts/sa-reorder/wspec5.py
new file mode 100644 (file)
index 0000000..3617bf7
--- /dev/null
@@ -0,0 +1,8 @@
+TRANSFER_INS = [(7, 'fs/btrfs/raid56.c', '#include "block-group.h"\n', 11),
+                (38, 'fs/btrfs/transaction.c', '#include "raid56.h"\n', 79),
+                (83, 'fs/btrfs/disk-io.c', '\tfs_info->stripe_log_data_shared = true;\n', 83)]
+PERSUB = [104, 105]
+FORCE = []
+FOLD = [(32, 13), (25, 15), (32, 16), (81, 80)]
+JOIN = [(110, 'fs/btrfs/space-info.c', [r'unmanaged_free=%lld', r'bytes_unmanaged_free\)\);'])]
+NOMATCH = [(19, 'fs/btrfs/block-group.c', r'^bool btrfs_stripe_in_open_run\(')]
diff --git a/scripts/sa-reorder/wspec618.py b/scripts/sa-reorder/wspec618.py
new file mode 100644 (file)
index 0000000..090789f
--- /dev/null
@@ -0,0 +1,9 @@
+TRANSFER_INS = [(6, 'fs/btrfs/raid56.c', '#include "block-group.h"\n', 11),
+                (39, 'fs/btrfs/transaction.c', '#include "raid56.h"\n', 94),
+                (98, 'fs/btrfs/disk-io.c', '\tfs_info->stripe_log_data_shared = true;\n', 98)]
+PERSUB = [119, 120]
+FORCE = [(76, 'fs/btrfs/block-group.c', r'^static void warn_stripe_alloc_uncovered\(', 39),
+         (76, 'fs/btrfs/block-group.c', r'^\twarn_stripe_alloc_uncovered\((fs_)?info\);', 39)]
+FOLD = [(33, 14), (33, 17), (65, 16), (96, 95)]
+JOIN = [(125, 'fs/btrfs/space-info.c', [r'unmanaged_free=%lld', r'bytes_unmanaged_free\)\);'])]
+NOMATCH = [(20, 'fs/btrfs/block-group.c', r'^bool btrfs_stripe_in_open_run\(')]
diff --git a/scripts/sa-reorder/wspec618b.py b/scripts/sa-reorder/wspec618b.py
new file mode 100644 (file)
index 0000000..75e8746
--- /dev/null
@@ -0,0 +1,62 @@
+# 6.18 lane, rulings A and C (misc-next wspec13.py, renumbered).
+TAGS = {1: 'base', 2: 'allow_rmw', 3: 'reclaim', 4: 'fsync', 5: 'debug', 6: 'stripe_meta', 7: 'debug_meta'}
+TRANSFER_INS = [(6, 'fs/btrfs/raid56.c', '#include "block-group.h"\n', 11),
+                (39, 'fs/btrfs/transaction.c', '#include "raid56.h"\n', 94),
+                (98, 'fs/btrfs/disk-io.c', '\tfs_info->stripe_log_data_shared = true;\n', 98)]
+PERSUB = [119, 120]
+FORCE = [(76, 'fs/btrfs/block-group.c', r'^static void warn_stripe_alloc_uncovered\(', 39),
+         (76, 'fs/btrfs/block-group.c', r'^\twarn_stripe_alloc_uncovered\((fs_)?info\);', 39),
+         (29, 'fs/btrfs/fs.h', r'atomic64_t meta_rmw;', 6),
+         (29, 'fs/btrfs/sysfs.c', r'meta_rmw', 6)]
+SPLIT_STMT = [(29, 'fs/btrfs/raid56.c', r'atomic64_inc\(&fs_info->stripe_park_stats\.meta_rmw\);')]
+FOLD = [(33, 14), (33, 17), (65, 16), (96, 95), (88, 39)]
+JOIN = [(29, None, [r'meta_rmw']),
+        (125, 'fs/btrfs/space-info.c', [r'unmanaged_free=%lld', r'bytes_unmanaged_free\)\);'])]
+DEFER = (5, 6, 7)
+NOMATCH = [(20, 'fs/btrfs/block-group.c', r'^bool btrfs_stripe_in_open_run\(')]
+
+exec(open('/home/aigendu/.claude/jobs/f89f1ecd/tmp/osord/post/ext.py').read())
+ZYGO = ('Zygo Blaxell', 'ce3g8jdj@umail.furryterror.org')
+NOW = '1792702025 -0400'
+SYNTH = [dict(id=49.5, cls=6, place=39.5, msg=EXT_MSG, author=ZYGO, date=NOW, group='reclaim-meta'),
+         dict(id=132.5, cls=6, place=39.6, msg=EXT_MSG, author=ZYGO, date=NOW, group='reclaim-meta')]
+_BG = 'fs/btrfs/block-group.c'
+_CMT = (44, 48, 49, 84, 85, 119, 120, 129, 130, 131, 132)
+REWRITE = [
+    (_BG, {44, 48, 49}, r'stripe_alloc (/|or) stripe_meta', 'stripe_alloc', 49.5),
+    (_BG, {84, 85, 119, 120, 129, 130, 131, 132}, r'stripe_alloc (/|or) stripe_meta', 'stripe_alloc', 132.5),
+    ('fs/btrfs/free-space-cache.c', set(_CMT), r'stripe_alloc (/|or) stripe_meta', 'stripe_alloc', 132.5),
+    ('fs/btrfs/fs.h', {84, 85}, r'stripe_alloc / stripe_meta', 'stripe_alloc', 132.5),
+    (_BG, {84}, r'^(\t+ \* Too full to relocate whole\.  A stripe_alloc) /$', r'\1', 132.5),
+    (_BG, {84}, r'^(\t+ \* )stripe_meta (group whose free space is trapped in)$', r'\1\2', 132.5),
+    ('fs/btrfs/sysfs.c', {130}, r'stripe_alloc / stripe_meta', 'stripe_alloc', 132.5),
+    ('fs/btrfs/volumes.c', {84}, r'stripe_alloc / stripe_meta', 'stripe_alloc', 132.5),
+    ('fs/btrfs/relocation.c', {84}, r'stripe_alloc / stripe_meta', 'stripe_alloc', 132.5),
+    (_BG, {44}, r' \|\| btrfs_is_stripe_meta_bg\(bg\)', '', 49.5),
+    (_BG, {48}, r'^(\t\tif \(!\(sinfo->flags & )\(BTRFS_BLOCK_GROUP_DATA \|$', r'\1BTRFS_BLOCK_GROUP_DATA))', 49.5),
+    (_BG, {48}, r'^\t+      BTRFS_BLOCK_GROUP_METADATA\)\)\)$', None, 49.5, 'split_dead'),
+    (_BG, {49}, r'^(\t+     !btrfs_is_stripe_alloc_bg\(bg\)) &&$', r'\1)) {', 49.5),
+    (_BG, {49}, r'^\t+     !btrfs_is_stripe_meta_bg\(bg\)\)\) \{$', None, 49.5),
+    ('fs/btrfs/relocation.c', {84}, r'^( \* again instead of removed\.)  A tree block never spans a stripe, so for a$', r'\1', 132.5),
+    ('fs/btrfs/relocation.c', {84}, r'^ \* metadata group the closure is the partial stripes themselves\.$', None, 132.5),
+    ('fs/btrfs/relocation.c', {84}, r'^\t\telse if \(key\.type == BTRFS_METADATA_ITEM_KEY\)$', None, 132.5),
+    ('fs/btrfs/relocation.c', {84}, r'^\t\t\tlen = fs_info->nodesize;$', None, 132.5),
+    # compact_plan()'s fs_info is used only by the metadata extent length
+    ('fs/btrfs/relocation.c', {84}, r'^\tstruct btrfs_fs_info \*fs_info = bg->fs_info;$', None, 132.5,
+     r'prev:^static int compact_plan\('),
+    (_BG, {130}, r'^(\t+\} else if \(!btrfs_is_stripe_alloc_bg\(bg\)) &&$', r'\1) {', 132.5),
+    (_BG, {130}, r'^\t+   !btrfs_is_stripe_meta_bg\(bg\)\) \{$', None, 132.5),
+    (_BG, {130}, r'^(\t+if \(!btrfs_is_stripe_alloc_bg\(bg\)) &&$', r'\1)', 132.5),
+    (_BG, {130}, r'^\t+    !btrfs_is_stripe_meta_bg\(bg\)\)$', None, 132.5),
+]
+JOIN = JOIN + [(49.5, None, ['']), (132.5, None, [''])]
+X80_MSG = """btrfs: stripe_alloc: break rbio pins and open stripe runs down by run class (stripe_meta part)
+
+Split from "btrfs: stripe_alloc: break rbio pins and open stripe runs down by run class"
+for the subtopic reorder: the name of the meta run class, which
+"btrfs: stripe_meta: allocate tree blocks by whole stripes" adds.
+
+Assisted-by: Claude:claude-opus-5-5
+"""
+SYNTH.append(dict(id=95.5, cls=6, place=39.7, into=39, msg=X80_MSG, author=ZYGO, date='1791150384 -0400', group='x80'))
+REWRITE.append(('fs/btrfs/sysfs.c', {95}, r'^(\t\t"cow", "reloc", "log", "nocow"), "meta",$', r'\1,', 95.5, 'split_dead'))
index dc86fe598e618b79c80753758a1fb3a846cf3341..d4beb8cb7f836d2c991ac2107de4843ac89cb66e 100644 (file)
 # stripe-alloc: plan to reorder the series by subtopic
 
-o-sord, 2026-10-22.  Not committed; for the lead's review.
-
-Source: misc-next/topics/stripe-alloc bcadbfc8ac02 (114 patches on
-0c48d26d46bd).  Zygo's requested order:
-
-[Lead, 2026-10-22: since this plan was written, two patches were appended
-(topic a23064467620, 116 patches).  Both are subtopic 3 and go after old
-114: 115 "back off block group reclaim after repeated ENOSPC" and 116 "let
-queued exclusive operations in between reclaims".  They touch only reclaim
-code (block-group.c/.h, free-space-cache.c, fs.c, fs.h, space-info.h, sysfs.c) and have no dependency
-on subtopics 4-6.]
-
-1. Activation by xattr, basic no-RMW function
-2. xattr to allow RMW for some operations
-3. Stripe-only reclaim for data block groups
-4. Competing fsync implementations
-5. stripe_meta
-6. Debugging code not for upstream
-
-## Result in one paragraph
-
-Every patch has a subtopic (table below).  A pure reorder does not work.
-The series grew in the original order, and the later patches edit code
-that the new order puts after them.  The trial replays the first 13 patches
-of subtopic 1 with context-only resolutions.  It stops at old 24, which
-edits code that old 14 (subtopic 4) and old 20 (subtopic 2) introduce.  Per
-the brief, it stops there.  There is no `refs/cand/sa-reorder/mn/topic`, no
-boundary build, and no 6.18 run.  A build of the 13-patch prefix failed.  That
-exposed an include-level dependency on the debug checker (D11), which the
-static analysis had missed.  The work that blocks it is structural.
-Section 2 lists eleven dependencies (D1-D11) and the move or split that
-removes each.  Five of them need code that no existing patch contains:
-D1, D4, D5, the semantic part of D6, and D10.  A mechanical experiment
-(section 3) shows why hunk-moving alone is not enough.  Zygo needs to decide
-D1 and D4 before a rebuild can be planned in detail.
-
-## Method
-
-- `git blame base..P^` on the old side of every hunk of every patch finds
-  which series patch wrote each context line or removed line.  177
-  (patch, earlier patch) pairs cross subtopics backwards under the
-  proposed classification.
-- Identifiers new in the series (absent from the base tree), with the
-  first patch that adds each, give about 40 more backward uses: a patch
-  uses a symbol that a later-placed patch defines.
-- The trial is a checkout-free replay.  It cherry-picks with `git
-  merge-tree --write-tree --merge-base=P^`.  When merge-tree reports a
-  conflict, the trial retries with a line-level 3-way merge.  That merge
-  accepts edits that are adjacent but do not overlap.  It orders two
-  insertions at the same point by their order in the final tree.  For
-  every patch it resolves, the +/- lines are byte-identical to the
-  original patch.  The trial stops at the first overlap.
-- A tool check: the replay in the original order reproduces bcadbfc8ac02's
-  tree exactly (d39cc792e5e6).
-
-Scripts and logs are in the job tmp dir: `osord/bin/{replay.py,replay3.py,zmerge.py,blamedeps.py,tokdeps.py}`,
-`osord/{blamedeps.json,tokdeps.json,replay-v3ctx.log,replay3-v3.log,residuals-v3.txt}`.
-
-## 1. Classification
-
-The new numbers are for the order with no splits: S1 1-61, S2 62-72,
-S3 73-77, S4 78-83, S5 84-98, S6 99-114.  Within each subtopic the
-original order is kept.  Every split in section 2 adds commits and moves
-these numbers.
-
-Summary by subtopic (old numbers):
-
-- S1 (61): 1-6 8-12 17 23-27 30 32-37 40 41 43-45 54 57 60 62-64 67-69
-  73-77 79 82 84 86 87 89 91 92 95-99 101 109-112
-- S2 (11): 18-21 56 58 66 85 90 100 103
-- S3 (5): 42 46 47 70 114
-- S4 (6): 13-16 83 88
-- S5 (15): 38 48-53 61 65 81 93 102 104 105 106
-- S6 (16): 7 22 28 29 31 39 55 59 71 72 78 80 94 107 108 113
-
-Classification calls worth a second look:
-
-- Relocation under the gate (40, 41, 43-45, 60, 73, 74, 84) is in S1, not
-  S3.  Balance, device remove and shrink relocate on every filesystem.
-  Only the reclaim trigger and worker (42, 46, 47), compaction (70) and
-  stripe_reclaim_now (114) are reclaim-specific.
-- 57 (whole stripes stranded behind live runs) is in S1.  It applies to
-  any live run, although NOCOW runs motivated it.  In S2 it is replayed
-  after S1 patches that later rewrote the same scan code (91), and it
-  conflicts.
-- 81 (META_LOG runs, one per log commit) is in S5.  It exists only under
-  raid56 metadata and serves both fsync modes, so it does not belong to
-  the competing implementations.
-- 54 (per-group trapped bytes in the space_info dump) is in S1.  It is a
-  line in the existing enospc_debug dump, which is an upstream production
-  diagnostic.
-- 104/105 (comment-only cleanup of the whole series) are at the end of
-  S5, after all upstream code (D7).
-- 27 (mount warning: raid56 metadata not covered) is in S1, where it is
-  true.  38 narrows it and 65 removes it, so the subtopics stay
-  consistent.
-- 113 (dyndbg reclaim log) is in S6, as the brief defines S6.  It needs 70
-  (compaction), which is already earlier.
-- S6 follows the brief's definition: stats files (22, 59, 78, 80), the
-  tracepoint (31), audits (29, 55, 72, 94), attribution (71, 107), the
-  checker (7, 39), the unwritten log (108) and the reclaim log (113).
-  This strict reading is what makes D4 expensive.
-
-Debug code wired into production paths:
-
-- 7: the checker is CONFIG_BTRFS_DEBUG only.  Its
-  `BLOCK_GROUP_FLAG_STRIPE_RELOC_USED` set_bit sits in
-  do_allocation_stripe() on every build.  19 adds NOCOW_USED next to it,
-  and 20, 24, 32, 38, 58 and 90 edit the checker.
-- 39: its drain worker runs on every runtime enable.  It exists only for
-  the checker.  61 extends it with a commit.
-- 28: the "write hole applies" rate-limited warning prints on production
-  kernels.  Its counter goes into 22's file.
-- 8: `stripe_unusable_rescan` is a CONFIG_BTRFS_DEBUG sysfs trigger inside
-  a core patch.
-- 30, 35: production tunables (stripe_park_timeout_ms,
-  stripe_park_sync_timeout_ms, stripe_park_congestion) ship in the same
-  patches as debug counters.
-- 31: the pad oracle's return type (`struct btrfs_stripe_pad_info`, the
-  pad-reason enum) is introduced for the tracepoint.  It then becomes the
-  oracle's API: 33, 71 and 76 build on it, and 71 records the verdict on
-  every rbio.
-
-### Table
-
-| old | new | S | subject | note |
-|---:|---:|:-:|---|---|
-| 1 | 1 | 1 | add btrfs_claim_free_stripe_run() for stripe-exclusive allocation |  |
-| 2 | 2 | 1 | add open stripe run tracking for stripe-exclusive allocation |  |
-| 3 | 3 | 1 | add the stripe_alloc allocation policy for raid56 data |  |
-| 4 | 4 | 1 | stripe_alloc: control the policy with a filesystem property | activation: the btrfs.stripe_alloc property |
-| 5 | 5 | 1 | report stripe run data IO through the ordered extent lifecycle |  |
-| 6 | 6 | 1 | retire stripe runs at commit and gate stripe_alloc |  |
-| 7 | 99 | 6 | add a write-hole invariant checker to the raid56 write path | debug: CONFIG_BTRFS_DEBUG checker; its STRIPE_RELOC_USED set_bit sits in do_allocation_stripe() (production path, flag only read by the checker) |
-| 8 | 7 | 1 | account stripe_alloc trapped free space for honest statfs | includes the debug-only sysfs trigger stripe_unusable_rescan and a tracepoint; core is statfs/admission accounting |
-| 9 | 8 | 1 | stripe_alloc: keep an open run per size band to trap less |  |
-| 10 | 9 | 1 | stripe_alloc: grow the frontier run instead of stranding its tail |  |
-| 11 | 10 | 1 | raid56: batch stripe_alloc partial writes into full-stripe writes | parking is core no-RMW function; its flushes are wired into ordered-extent waits and retirement |
-| 12 | 11 | 1 | stripe_alloc: never claim stripes covered by a live run |  |
-| 13 | 78 | 4 | stripe_alloc: settle a logged extent's stripes at log commit | fsync: log-commit settle (shared by both fsync modes) |
-| 14 | 79 | 4 | stripe_alloc: private per-inode stripe runs for log-active inodes | fsync: private LOG runs; also carries the generic private-run machinery S2 needs (see D1) |
-| 15 | 80 | 4 | stripe_alloc: carry an inode's log tail forward at fsync |  |
-| 16 | 81 | 4 | stripe_alloc: kick parked rbios before the fast fsync's writeback wait | fsync: parked-rbio kick before the fast fsync's writeback wait |
-| 17 | 12 | 1 | raid56: pad sub-stripe writes to full stripes in open runs |  |
-| 18 | 62 | 2 | stripe_alloc: isolate nodatacow and preallocated extents by stripe | allow-rmw: NOCOW class exists only so in-place writes can be confined; reuses old 14's private-run machinery |
-| 19 | 63 | 2 | stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents | allow-rmw; its "fsync" word belongs to S4 (see D2); also touches the S6 checker |
-| 20 | 64 | 2 | stripe_alloc: persist nocow runs across commits and remounts |  |
-| 21 | 65 | 2 | raid56: do not park sync writes into nocow runs | parking edge for NOCOW runs only |
-| 22 | 100 | 6 | raid56: expose parking statistics in sysfs | debug: stats file; later core patches add counters to it (D4) |
-| 23 | 13 | 1 | raid56: skip parking for sync rbios finished by their unplug batch | parking edge, generic |
-| 24 | 14 | 1 | stripe_alloc: count open stripe run remainders against data reservations |  |
-| 25 | 15 | 1 | stripe_alloc: pessimistic data reservation margin |  |
-| 26 | 16 | 1 | stripe_alloc: claim fully-free stripes that span free space entries |  |
-| 27 | 17 | 1 | stripe_alloc: warn when raid56 metadata is not covered | user-facing mount warning; superseded by 38 and removed by 65 |
-| 28 | 101 | 6 | stripe_alloc: report read-modify-write of uncovered stripes | debug/observability: rate-limited "write hole applies" warning plus meta_rmw counter; the warning is production-visible |
-| 29 | 102 | 6 | raid56: say whether a metadata read-modify-write is a write hole | debug: metadata RMW audit (reads headers under the stripe lock) |
-| 30 | 18 | 1 | stripe_alloc: tunable park deadlines, and say why padding declined | mixed: park-deadline tunables (production knobs) + data_rmw and pad_decline counters (debug) |
-| 31 | 103 | 6 | stripe_alloc: trace why padding declined, at the moment it declined | debug: tracepoint; but it also creates btrfs_stripe_pad_info and the pad-reason enum that 33, 71, 76 build the pad oracle on (see D4) |
-| 32 | 19 | 1 | stripe_alloc: complete parked writes on allocation coverage, not clocks | core parking; edits the fsync kick (16) and settle (13) too |
-| 33 | 20 | 1 | stripe_alloc: track per-sector liveness and pad from the map | core liveness map; moved out of old 38; edits 31's pad_info API |
-| 34 | 21 | 1 | stripe_alloc: count claimable whole-stripe supply directly |  |
-| 35 | 22 | 1 | raid56: adaptive park deadline from the parked-rbio backlog | production knob stripe_park_congestion (default off) + counters |
-| 36 | 23 | 1 | stripe_alloc: gate data admission on claimable whole-stripe supply |  |
-| 37 | 24 | 1 | stripe_alloc: cache a failed stripe run scan per block group |  |
-| 38 | 84 | 5 | stripe_meta: allocate tree blocks by whole stripes |  |
-| 39 | 104 | 6 | stripe_alloc: drain the legacy allocator's writes before arming the write-hole check at a runtime enable | debug: exists only to keep the write-hole checker quiet; the drain worker runs on every runtime enable (production path) |
-| 40 | 25 | 1 | stripe_alloc: keep the admitted bytes placeable when a group goes read-only | admission correctness; read-only transitions come from scrub and balance too |
-| 41 | 26 | 1 | stripe_alloc: never let relocation wait on the whole-stripe gate | relocation (balance) correctness under the gate, not reclaim-specific |
-| 42 | 73 | 3 | stripe_alloc: give a queued stripe group a chunk to relocate into when the supply is short | reclaim worker chunk preallocation; tests btrfs_is_stripe_meta_bg (D5) |
-| 43 | 27 | 1 | stripe_alloc: charge relocation a margin per reservation, not per extent | relocation admission, used by balance |
-| 44 | 28 | 1 | stripe_alloc: keep the relocation group's stripes out of the admission supply | relocation admission, used by balance |
-| 45 | 29 | 1 | stripe_alloc: let a data write fall back to the relocation group rather than drop | relocation fallback, used by balance |
-| 46 | 74 | 3 | stripe_alloc: hand groups full of trapped free space to the reclaim worker | reclaim trigger |
-| 47 | 75 | 3 | stripe_alloc: relocate a queued stripe group even while it has reserved or pinned bytes | reclaim worker; tests btrfs_is_stripe_meta_bg (D5) |
-| 48 | 85 | 5 | stripe_meta: maintain trapped free space for metadata groups like data |  |
-| 49 | 86 | 5 | stripe_meta: back the global reserve with usable stripes, and say when a tree block finds none |  |
-| 50 | 87 | 5 | stripe_meta: hold back whole stripes so tree blocks always land and trapped groups can be reclaimed |  |
-| 51 | 88 | 5 | stripe_meta: do not steal from the global reserve below the relocation reserve |  |
-| 52 | 89 | 5 | stripe_meta: let the transaction machinery's own reservations draw on the reserve |  |
-| 53 | 90 | 5 | stripe_meta: let a group go read-only for relocation against the reserve |  |
-| 54 | 30 | 1 | stripe_alloc: show per-group trapped bytes in the space info dump | space_info dump (enospc_debug) line; production diagnostic, kept upstream-side |
-| 55 | 105 | 6 | stripe_alloc: tell a dead tree block from a live one in the metadata RMW audit | debug: RMW audit refinement |
-| 56 | 66 | 2 | stripe_alloc: do not read an inline backref off a keyed-ref extent item | fix to 20's stripe_extents_owned_by() |
-| 57 | 31 | 1 | stripe_alloc: count whole stripes stranded behind live runs as trapped | generic admission accounting (stranded behind any live run); motivated by NOCOW runs; touches 46's reclaim predicate |
-| 58 | 67 | 2 | stripe_alloc: give nocow extents a private run only while they may be written in place | NOCOW run lifecycle under the allow_rmw policy |
-| 59 | 106 | 6 | stripe_alloc: count nocow run lifecycles and stranded stripes in sysfs | debug: stripe_run_stats; later core patches add counters to it (D4) |
-| 60 | 32 | 1 | stripe_alloc: hold a stripe of margin across a preallocation | admission: preallocation margin (fallocate, relocation, encoded write) |
-| 61 | 91 | 5 | stripe_meta: carry raid56 metadata groups through a runtime enable or disable | stripe_meta runtime enable/disable; touches 39's drain worker |
-| 62 | 33 | 1 | stripe_alloc: return a group's allocation cluster before scanning its stripes | runtime-enable scan fix (data groups under ssd_spread, metadata groups) |
-| 63 | 34 | 1 | stripe_alloc: release open stripe runs when a mount fails or an aborted filesystem unmounts | teardown; motivated by metadata runs but releases every class |
-| 64 | 35 | 1 | stripe_alloc: say at mount whether the policy is on | mount message; touches 39's worker comment |
-| 65 | 92 | 5 | stripe_meta: cover raid56 system chunks | stripe_meta system chunks |
-| 66 | 68 | 2 | stripe_alloc: close dead nocow stripe runs at commit | NOCOW dead-run close; adds btrfs_stripe_run_note_free() on the free path |
-| 67 | 36 | 1 | stripe_alloc: do not round a full stripe with power-of-two macros | helper used by 19/20 (nocow writable, re-adoption) and 13/15 (settle); fixes code of several subtopics |
-| 68 | 37 | 1 | stripe_alloc: do not wait for stripe runs to drain on an errored filesystem | errored-fs drain; also stops reclaim on an errored fs |
-| 69 | 38 | 1 | stripe_alloc: end the commit-time and log drains on an errored filesystem too | errored-fs drain; one hunk is in the fsync settle wait (S4) |
-| 70 | 76 | 3 | stripe_alloc: compact mostly live groups instead of skipping them | compaction |
-| 71 | 107 | 6 | stripe_alloc: attribute each data read-modify-write to why padding declined | debug: RMW attribution counters; records the pad verdict on the rbio |
-| 72 | 108 | 6 | stripe_alloc: optionally audit data read-modify-writes against the committed extent tree | debug: CONFIG_BTRFS_DEBUG audit |
-| 73 | 39 | 1 | stripe_alloc: keep relocation's stripe runs until relocation ends | relocation runs retained (balance); tests BTRFS_STRIPE_RUN_META (D5) |
-| 74 | 40 | 1 | stripe_alloc: let relocation allocate a data chunk before it fails |  |
-| 75 | 41 | 1 | stripe_alloc: keep a stripe in the rbio cache until its run has written all of it | core: rbio pin; data correctness under strip faults |
-| 76 | 42 | 1 | stripe_alloc: pad a stripe's allocated sectors whose write is still to come | core: pad unwritten sectors; edits 71's attribution |
-| 77 | 43 | 1 | stripe_alloc: apply the property before tree-log replay | activation: property applied before log replay |
-| 78 | 109 | 6 | stripe_alloc: count refused rbio pins and track rbio cache high water | debug: pin counters |
-| 79 | 44 | 1 | stripe_alloc: sweep stale rbio pins, and commit when live pins run low | core: stale-pin sweep + commit request; counters ride along |
-| 80 | 110 | 6 | stripe_alloc: break rbio pins and open stripe runs down by run class | debug: per-class pin/run counters; refactors btrfs_stripe_run_incomplete() into a wrapper |
-| 81 | 93 | 5 | stripe_alloc: give each log commit its own metadata stripe run | stripe_meta: META_LOG runs (log tree metadata); serves fsync under raid56 metadata for both fsync modes |
-| 82 | 45 | 1 | stripe_alloc: don't make a parked rbio wait for sectors that will never be written | core parking |
-| 83 | 82 | 4 | stripe_alloc: share LOG data runs per log transaction | fsync: shared LOG runs per log transaction (the default mode) |
-| 84 | 46 | 1 | stripe_alloc: let relocation allocate as many data chunks as its reservation needs |  |
-| 85 | 69 | 2 | stripe_alloc: key private stripe runs by subvolume and inode | fixes 18/19/20 (NOCOW) and 83 (LOG) and 81 (META_LOG owner); S4/S5 hunks go with them |
-| 86 | 47 | 1 | stripe_alloc: do not treat an allocation error as a found extent | fixes 3, 14, 38 |
-| 87 | 48 | 1 | stripe_alloc: mark an ended ordered extent's sectors written | fixes 83 (S4), 75, 76; marking is generic |
-| 88 | 83 | 4 | stripe_alloc: read the shared LOG run mode once per log settle | fsync: shared-mode knob read once |
-| 89 | 49 | 1 | stripe_alloc: remove only the set bits of a bitmap when claiming a split run |  |
-| 90 | 70 | 2 | stripe_alloc: claim a stripe tail in one free space lock section |  |
-| 91 | 50 | 1 | stripe_alloc: keep the stripe totals consistent with the groups during the commit scan |  |
-| 92 | 51 | 1 | stripe_alloc: do not delete an unused block group that still has stripe runs | fixes 3, 20, 38 |
-| 93 | 94 | 5 | stripe_meta: commit before waiting for metadata runs when making a group read-only | stripe_meta read-only commit |
-| 94 | 111 | 6 | raid56: do not read tree blocks under the stripe lock in the metadata RMW audit | debug: fix to 29/55 audits |
-| 95 | 52 | 1 | raid56: stop the park timer before destroying the raid56 workqueue | teardown: park timer vs workqueue |
-| 96 | 53 | 1 | stripe_alloc: order the filesystem error before waking stripe drain waiters | errored-fs wake ordering |
-| 97 | 54 | 1 | raid56: set a padded rbio's data bitmap under bio_list_lock |  |
-| 98 | 55 | 1 | stripe_alloc: forget the failed-claim verdict when a cluster returns its space |  |
-| 99 | 56 | 1 | stripe_alloc: do not let a remount revert the stripe_alloc property | activation: remount must not revert the property |
-| 100 | 71 | 2 | stripe_alloc: do not block a NOWAIT write in the nocow stripe check | fix to 19 |
-| 101 | 57 | 1 | stripe_alloc: keep the head of a claimed free space entry under the lock |  |
-| 102 | 95 | 5 | stripe_meta: check the block group lookup when freeing an unwritten tree block | fix to 38 |
-| 103 | 72 | 2 | stripe_alloc: remove the unused stripe_rmw_opt field | removes 19's dead field |
-| 104 | 96 | 5 | stripe_alloc: correct and trim the block group comments | comment-only, all of block-group.[ch]; placed after all upstream code (end of S5); its hunks in S6 code must move to S6 (D7) |
-| 105 | 97 | 5 | stripe_alloc: correct and trim the comments outside the block group code | comment-only, rest of the series; same treatment as 104 |
-| 106 | 98 | 5 | stripe_meta: keep waiting for metadata runs that do not drain at commit | fix to 38 |
-| 107 | 112 | 6 | stripe_alloc: remove pad refusal reasons that no longer exist | debug: removes dead pad reasons/counters (71/30/31) |
-| 108 | 113 | 6 | stripe_alloc: count and log ordered extents that end with sectors unwritten | debug: counter + rate-limited log; the marking it counts is 87's |
-| 109 | 58 | 1 | stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3 | generic; tests stripe_meta too |
-| 110 | 59 | 1 | stripe_alloc: count single-data-stripe groups' free space in write admission | admission; prints bytes_stripe_reserve (50, S5) in the dump |
-| 111 | 60 | 1 | stripe_alloc: account claimable stripes while a trim has them out | admission vs trim; tests btrfs_is_stripe_meta_bg (D5) |
-| 112 | 61 | 1 | stripe_alloc: do not miss bitmap free space when debiting a trim |  |
-| 113 | 114 | 6 | log block group reclaim at debug level | debug: dyndbg reclaim log the harness reads |
-| 114 | 77 | 3 | stripe_alloc: add stripe_reclaim_now to reclaim stripes on demand | reclaim on demand; tests btrfs_is_stripe_meta_bg (D5) |
-
-## 2. Dependencies and the moves or splits that remove them
-
-"Mechanical" means the split only divides a patch's own +/- lines.  The
-part that edits later-subtopic code moves to right after the patch that
-introduces that code, as a follow-up commit or folded into it.  "Needs
-code" means the split creates an intermediate state that no existing
-commit contains, such as a changed signature, a shortened condition, or
-code at a different place.  Zygo or the lead should approve those.
-
-**D1. S2 is built on old 14 (S4).  Needs code.**
-14 ("private per-inode stripe runs for log-active inodes") introduces the
-machinery that all of S2 uses:
-- the run `owner` field and btrfs_alloc_from_inode_stripe_run();
-- owner lookup under stripe_run_lock;
-- the `inode` parameter of btrfs_reserve_extent() and all its callers;
-- the commit-time retirement that walks the run list instead of the band
-  slots.  Private runs are never in a slot, so without the walk they are
-  never closed.
-
-18 parameterises all of this by class to add NOCOW.  20, 58, 66, 85, 90
-and 100 build on 18.  The experiment moved 86 lines of 18 and 75 of 20
-into S4.  Nothing of S2 works before then.
-- Proposed split: 14a "private per-inode stripe runs" goes into S2 before
-  18 (or at the end of S1).  It contains the owner field, the
-  class-parameterised allocator in the form 18 gives it, the list-walk
-  retirement and the reserve_extent plumbing.  14b "steer log-active
-  inodes into private LOG runs" stays in S4: the LOG class,
-  BTRFS_INODE_LOG_ALLOC set at fsync entry, log_run_hint, and the
-  for_log_inode steering.  18 shrinks to the NOCOW class and its
-  steering.  14a has no exact counterpart in any existing commit.
-- Alternative with no new code: move 14 whole into S2 just before 18.
-  S2 then contains LOG steering with nothing that settles it.  That is
-  harmless at runtime: fsync'd inodes get private runs, and commit
-  retirement closes them.  It contradicts the brief's definition of S4.
-
-**D2. The "fsync" word of old 19's allow_rmw.  Mechanical.**
-19 parses `fsync` and checks BTRFS_STRIPE_RMW_FSYNC in four places:
-- the settle (13);
-- the carry (15, defrag.c);
-- btrfs_sync_file's LOG flag (14);
-- the reserve_extent steering (14).
-
-Move the word into S4 as its own patch after 15: the parser branch, the
-mask bit, the four checks and the show side.  S2 keeps nodatacow and
-prealloc.  The parser loses one `else if`, and the S4 patch adds it back.
-
-**D3. Edits to the write-hole checker (old 7, S6).  Mechanical.**
-19, 20, 24, 32, 38, 58 and 90 change the checker's skip conditions, or
-set flags that only the checker reads (NOCOW_USED, RELOC_USED).  These
-hunks follow 7 into S6.  The set_bit calls they move are in production
-allocation paths, so S1-S5 lose dead code and nothing else.
-
-**D4. Observability that later core code builds on (22, 31, 59).  Needs code.**
-Two parts:
-- Counters.  stripe_park_stats (22) is bumped in 30, 32, 33, 35, 75, 76
-  and 79.  stripe_run_stats (59) is bumped in 66, 67, 69, 70, 73, 75, 81,
-  83, 88 and 92.  Moving each increment, field and sysfs line to S6 is
-  mechanical.  It is about 25 S6 follow-up commits.
-- The pad API.  31 created `btrfs_stripe_pad_info` and the pad-reason
-  enum for its tracepoint.  33 (liveness map, btrfs_stripe_run_pad_mask)
-  and 76 (pad unwritten sectors) are written against that API, and 71
-  records the verdict on the rbio.  With 31 in S6 the experiment moved
-  122 lines of 33 and 35 lines of 76 into S6.  That means S1 would keep
-  the frontier-based pad oracle from 17 and lose the liveness map, which
-  is a correctness piece.  Keeping 31 in S6 needs 33 and 76 rewritten
-  without `info`.  That is new code in two core patches.
-- Recommendation, for Zygo to decide:
-  - (a) S1 keeps 22, 30, 31 and 59 as "observability" (the files, the
-    struct and the enum), and S6 keeps only the self-contained debug
-    features: 7, 28, 29, 39, 55, 71, 72, 78, 80, 94, 107, 108, 113.  A
-    final S6 patch can delete the stats files and the tracepoint if
-    upstream review wants them gone.
-  - (b) Take the strict reading, and rewrite 33 and 76 plus about 25
-    counter splits.
-
-  Under (a), D4 disappears except for the 71/72/78/80 hunks inside 73,
-  75, 76, 79, 83, 85 and 88.  Those are counters and attribution, and
-  splitting them is mechanical.
-
-**D5. stripe_meta (old 38) terms inside S1 and S3 patches.  Needs code (one line each).**
-- 42, 47, 111 and 114 test `|| btrfs_is_stripe_meta_bg(bg)` or
-  `&& !btrfs_is_stripe_meta_bg(bg)`.
-- 73 tests `run->class != BTRFS_STRIPE_RUN_META && !run->retained`.
-
-Each needs a data-only form of the line in S1/S3, and a one-line S5 patch
-that adds the metadata term back.  Deferring the hunks whole does not
-work: the experiment moved 73's entire retained-run logic (20 lines) into
-S5, because it sits next to the META line.  63 releases runs of every
-class at teardown and moves unchanged.
-
-Two more hunks are mechanical and simply follow their target into S5:
-109 edits btrfs_is_stripe_meta_bg() itself, and 75 adds a declaration
-next to 38's.
-
-**D6. S1 edits to settle and carry code (old 13/15, S4).  Mostly mechanical.**
-- 24 adds stripe_open_remainder_sync() calls in the private-run and settle
-  paths (14 lines).
-- 25's margin touches the carry re-dirty in defrag.c.
-- 32 and 33 edit the settle walk.
-- 67 replaces round_down() in btrfs_log_settle_stripes().
-- 69 adds the errored-fs term to the settle wait.
-
-These hunks follow 13/15 into S4.  Two are semantic and not just
-textual: 33's settle hunk uses the liveness map, and 32 edits 16's
-fast-fsync kick.  Both are fine once 33 itself is in S1 (D4).
-
-**D7. Comment-only cleanups 104 and 105.  Mechanical.**
-They touch every subtopic.  Place them at the end of S5, after all
-upstream code, and move their hunks in S6 code into one S6 comment patch:
-the RMW audit, the debug sysfs attributes, the checker and the drain
-worker.  Do not spread them over the subtopics.  The experiment did that,
-and it produced 25 residual commits for these two patches alone.
-
-**D8. old 83 (S4) and old 81 (S5).  Mechanical.**
-- 83 adds `log_run_opened` and other counters beside 81's in fs.h and
-  sysfs.c.
-- 85 (subvolume keying) edits LOG (14/83, S4) and META_LOG (81, S5) owner
-  matching.
-
-These hunks follow 83 and 81.  85's NOCOW part stays in S2.
-
-**D9. S3 and S5 code inside S1 patches.  Mechanical.**
-- 57 changes btrfs_stripe_bg_wants_reclaim() (46, S3): stranded bytes
-  are excluded from the trapped bytes reclaim counts.  57 also adds
-  `stripe_stranded` to the space_info dump format, whose
-  `stripe_reserve` field comes from 50 (S5).
-- 91 adds `&& btrfs_test_opt(STRIPE_ALLOC)` to 50's reserve-clearing
-  branch (S5).
-- 110 prints `bytes_stripe_reserve` (50, S5).
-
-Each hunk follows its target into S3 or S5.
-
-**D10. Fixes moved ahead of the code they meet.  Needs re-resolution.**
-In the original order some S2/S5 patches came before an S1 fix to the same
-lines.  In the new order the S1 fix is replayed first, and the S2/S5
-patch then meets text it was never written against.  Seen:
-- 90 (S2, claim a stripe tail) against 101 (S1, claim head under the
-  lock), in free-space-cache.c.
-- 57 against 91 in the stripe_unusable scan.
-- 104 against 57/59.
-
-Each needs one merge written by hand.  The final tree gives the target
-text, but the intermediate state is new.
-
-**D11. The `#include "block-group.h"` in raid56.c comes from old 7 (S6).  Mechanical.**
-11 (parking) calls btrfs_stripe_in_open_run() from raid56.c, and 17
-calls btrfs_stripe_run_pad_start().  raid56.c gets the header from 7's
-checker.  Neither blame nor the identifier scan sees this, and the
-prefix build found it (section 6).  Move the include line into 11.  This
-also shows that blame and identifier analysis miss include-level
-dependencies.  Every boundary tree of a real rebuild has to be built,
-not just checked by analysis.
-
-What D1-D11 leave: with D4 (a), the subtopics stay as classified.  The
-splits are 14→14a/14b, 19→19 + fsync-word, 104 and 105 each →
-upstream + S6 part, five or six one-line meta re-additions, and about 15
-mechanical follow-ups (D3, D6, D8, D9, D11, and the remaining D4
-counters/attribution).  The series grows from 114 to about 135 commits,
-unless the follow-ups are folded into the patches they follow.  Folding
-is cleaner for review but changes those patches.
-
-## 3. The deferral experiment: why moving hunks is not enough
-
-To measure D1-D10 rather than guess them, a second replay
-(`osord/bin/replay3.py`, order = the classification above) ran without
-stopping at overlaps.  When a patch's hunk overlapped code from a patch
-not yet applied, it held that hunk back.  It then emitted the hunk as a
-"fixup! <subject>" commit right after the patch that introduces the code,
-with the original author.  This is not a proposal.  It shows where each
-patch's lines want to live.
-
-- The replay got through 118 of 137 items: 95 original patches and 23
-  fixups.
-- It stopped at old 104 (S5).  104's comment rewrite in block-group.c
-  overlaps lines that 57 (S1) wrote, and no later patch owns them.  This
-  is D10's kind of conflict and needs a hand merge.
-- Ref: `refs/cand/sa-reorder/mn/experiment-deferral` = c113d49f9228.
-  Every hunk is a cherry-picked original hunk, but the intermediate trees
-  were not built.  Do not use it as a series.
-
-Where the held-back hunks went (66 groups; the full diffs are in
-`osord/residuals-v3.txt`):
-
-| from | to after | lines | what |
-|---|---|---:|---|
-| S2 old18 | S4 old14 | 86 | the NOCOW class inside 14's private-run code (D1) |
-| S2 old20 | S4 old14 | 75 | nocow-run persistence inside 14's code (D1) |
-| S2 old20 | S6 old7 | 109 | checker skips for NOCOW groups (D3) |
-| S1 old33 | S6 old31 | 122 | the liveness-map pad oracle written on 31's pad_info (D4) |
-| S1 old33 | S4 old15 | 14 | settle walk uses the liveness map (D6) |
-| S1 old33 | S2 old19 | 26 | pad mask beside NOCOW-run checks |
-| S1 old75 | S2 old19 | 131 | the written map (pure insertion anchored in 19's nocow helpers; placing it elsewhere is a context-only change) |
-| S1 old76 | S6 old31 / old71 | 35 + 22 | pad-unwritten written against the pad API and attribution (D4) |
-| S1 old79 | S6 old78 | 75 | stale-pin sweep inside 78's counter code (D4) |
-| S4 old83 | S6 old59 | 132 | shared LOG runs' seal_log_stripe() and settle code, anchored next to 59's carry counter (D4/D8) |
-| S1 old73 | S5 old38 | 20 | relocation's retained runs, next to the META line (D5) |
-| S1 old30/32/35 | S6 old22/29/31 | ~75 | counter fields and sysfs lines (D4) |
-| S2 old19 | S4 old14/15 | 23 | the "fsync" allow_rmw word (D2) |
-| S1 old24 | S4 old14/15, S6 old7 | 19 | remainder sync in private-run and settle code (D6) |
-| S1 old57 | S3 old46, S5 old50 | 10 | reclaim predicate, dump format (D9, D5) |
-| S1 old91 | S5 old50 | 8 | reserve-clearing condition in 50's code |
-| others | | small | counters, comments (104/105 placement), declarations |
-
-The biggest moves would gut S1: the liveness-map oracle (33), the
-written map (75), pad-unwritten (76) and the pin sweep (79).  The same is
-true of S2 (18 and 20).  That is the evidence for D1 (split 14) and D4
-(a) (keep 22/31/59 in S1).  Once those two decisions are made, the
-remaining moves are small and mechanical.
-
-## 4. Conflict log (trial `refs/cand/sa-reorder/mn/partial-s1`)
-
-Replay in the classified order, with context-only resolutions:
-
-| new | old | result | resolution |
-|---:|---:|---|---|
-| 1-6 | 1-6 | clean | |
-| 7 | 8 | conflict in block-group.h | 8's runtime flag goes in the enum next to the slot of 7's `BLOCK_GROUP_FLAG_STRIPE_RELOC_USED`, which is absent here.  Adjacency only; +/- lines identical to the original. |
-| 8-11 | 9-12 | clean | |
-| 12 | 17 | conflict in block-group.c, block-group.h | 17's pad helpers and prototypes are inserted where 13/15's settle functions and prototypes sit in the original.  Adjacency only; +/- lines identical; insertion order taken from the final tree. |
-| 13 | 23 | conflict in raid56.c | 23's unplug-batch check is next to 21's NOCOW sync-write test and 22's stats increments.  Adjacency only; +/- lines identical. |
-| 14 | 24 | **STOP** | 24 ("count open stripe run remainders against data reservations") changes lines in btrfs_alloc_from_inode_stripe_run() (old 14, S4), the settle path (13/15, S4), and the run-tail code that 20 (S2) rewrote.  This is not context.  Resolving it means writing 24 without those hunks and re-adding them later (D6, D1).  The brief says to stop here. |
-
-## 5. Candidate refs and oracle
-
-In ~/share/linux:
-
-| ref | SHA | what | oracle |
+o-sord, 2026-10-23, revision 3.  Revision 1 (committed as ffc1fc40e82e)
+stopped at a hand replay.  Revision 2 had a candidate that only moved
+original lines.  This revision follows Zygo's rulings (A) and (C) of
+2026-10-22, which allow a small amount of new code.  Not committed.
+
+Source: misc-next/topics/stripe-alloc a23064467620 (116 patches on
+0c48d26d46bd, tree 4b52f5d67846) and 6.18/topics/stripe-alloc
+6602cb54b8e2 (132 patches on v6.18.57 2ff600d29ee4, tree a87304c553d7).
+The lane heads have moved since (misc-next zb64 03fd98a3ff17, 6.18 zb64
+db1814ba6c9a), with no stripe-alloc change.
+
+Zygo's subtopics, and the order of the rebuilt series (ruling C1):
+
+| order | subtopic | tag in part titles |
+|:-:|---|---|
+| 1 | S1 Activation by xattr, basic no-RMW function | `base` |
+| 2 | S2 xattr to allow RMW for some operations | `allow_rmw` |
+| 3 | S3 Stripe-only reclaim for data block groups | `reclaim` |
+| 4 | S4 Competing fsync implementations | `fsync` |
+| 5 | S6a Debugging code, minus its metadata parts | `debug` |
+| 6 | S5 stripe_meta | `stripe_meta` |
+| 7 | S6b The metadata parts of the debugging code (29, 55, 94, the parts that need stripe_meta, and 107) | `debug_meta` |
+
+The engine numbers these classes 1, 2, 3, 4, 5, 6, 7 in that order
+(`class.v13`); this document uses Zygo's names.
+
+## Result
+
+| lane | ref | commits | tree |
 |---|---|---|---|
-| refs/cand/sa-reorder/mn/partial-s1 | 0a5df3ca5081 | new 1-13 (old 1-6, 8-12, 17, 23) on 0c48d26d46bd | authorship (name, email, date) and subjects match the 13 originals exactly; final-tree oracle not applicable (prefix); does not compile without D11's include move (section 6) |
-| refs/cand/sa-reorder/mn/experiment-deferral | c113d49f9228 | section 3's experiment, 118 items, stops at old 104 | none; evidence only |
-| refs/cand/sa-reorder/mn/topic | not created | | final tree == d39cc792e5e6 not reached |
-| refs/cand/sa-reorder/618/topic | not created | brief: only if mn succeeds | |
+| misc-next | `refs/tmp/o-sord/p16` = f4cfb9869a7d | 164 on 0c48d26d46bd: 116 originals, 47 parts, 1 new | d6df042c87d4 = lane tip + the residual (section A6) |
+| 6.18 | `refs/tmp/o-sord/q16` = 0d329b02edc8 | 180 on 2ff600d29ee4: 132 originals, 47 parts, 1 new | c821ac92ab6e = lane tip + the residual |
 
-Tool check: the same replay code in the original order reproduced tree
-d39cc792e5e6 exactly.
+These are not yet in `refs/cand/sa-reorder/{mn,618}/topic`, which still
+hold revision 2: both lanes are being rebased (6.18 onto v6.18.58,
+misc-next onto btrfs/for-next 0713fa6a4356), and the reorder will be
+replayed onto the rebased topics before the refs move.  Revision 2's
+candidates are also kept as
+`refs/backup/sa-reorder-2026-10-22/rev2-{mn,618}-topic` (5b4847cb8f7a,
+487ff1c5a439).
 
-## 6. Builds
+misc-next boundaries (builds: W=1 fs/btrfs + bzImage, config-r5fix-mn-kasan):
+
+| subtopic | commits | boundary | tree |
+|---|---|---|---|
+| S1 base | #1-#66 (66) | d24269da3167 | aa85994a8b60 |
+| S2 allow_rmw | #67-#89 (23) | e2d9e382146f | edbc35cb6344 |
+| S3 reclaim | #90-#101 (12) | 82594bb41152 | 926c61ef2f07 |
+| S4 fsync | #102-#114 (13) | 94228b0ee7e2 | e02db7908314 |
+| S6a debug | #115-#126 (12) | 629f454670c4 | f9e4431e8ab4 |
+| S5 stripe_meta | #127-#151 (25) | 34d3d865ed98 | 5992ee46927e |
+| S6b debug_meta | #152-#164 (13) | f4cfb9869a7d | d6df042c87d4 |
+
+6.18 boundaries (each merged with raid56-disguise for the build, see section 9;
+config-review-618ffe-kasan):
+
+| subtopic | commits | boundary | tree |
+|---|---|---|---|
+| S1 base | #1-#77 (77) | dce806a39427 | e114929fad3c |
+| S2 allow_rmw | #78-#101 (24) | 494c81b90d4e | bf9f5f93318b |
+| S3 reclaim | #102-#113 (12) | 2d2d7926b5eb | 48deb18bd432 |
+| S4 fsync | #114-#126 (13) | 938994da00db | 8c4db94fe920 |
+| S6a debug | #127-#138 (12) | 7be4b9cd9743 | 8fa39ccd9791 |
+| S5 stripe_meta | #139-#167 (29) | 15c75f2a0cb7 | 33ef33d4ee6d |
+| S6b debug_meta | #168-#180 (13) | 0d329b02edc8 | c821ac92ab6e |
+
+What changed since revision 2:
+
+- Ruling A: reclaim is data-only in S3.  42, 46, 47, 70 and 114 are
+  written in their data-only form; one new S5 commit, "btrfs:
+  stripe_meta: extend stripe reclaim to metadata block groups", adds the
+  metadata parts (section A).  42, 47, 114 and 115 are back in S3.
+- Ruling A: 73 is whole without S5: three `&& !run->retained` tests,
+  from 73 until 38 replaces those lines (section A3).
+- Ruling C1: the order is S1, S2, S3, S4, S6a, S5, S6b.  80's "meta"
+  class name is written by 38, so 80 sits in S6a; 107 is the last
+  commit, in S6b, after the stats lines that read the counters it removes
+  (section A4).
+- 115's call of btrfs_can_overcommit() takes 50's `reloc` argument from
+  50 on (section A3b).
+- Ruling C2 (6.18): S1 warns at mount about uncovered raid56 metadata
+  again (section C2).
+- Ruling C3 (6.18): no commit or boundary adds a W=1 warning (section 6).
+- Ruling C4: the message fixes of 6, 13 and 28, the dead
+  btrfs_show_stripe_rmw(), and the btrfs_parse_stripe_rmw() comment.
+  The warning of 28 is in S1; its meta_rmw counter is a debug part.
+  4 had a stray cherry-pick line too; it is removed the same way.
+- The final trees are the lane tips plus exactly the residual in section
+  A6: the dead code removal and the comment fix.  Everything else nets to
+  zero at the tip.
+
+Checks (section 6 has the details):
+- `bin/oracle3.py`: ORACLE PASS on both lanes (A7).
+- The S3 reclaim review against the tip minus metadata (A5).
+- Builds: every boundary, both lanes; every commit from S3 to the end,
+  both lanes (W=1 fs/btrfs).
+
+
+## A. Rulings (A) and (C)
+
+### A1. Reclaim on data first, extended to metadata in S5
+
+Ruling A: "rearrange the code in the patches so reclaim on data comes
+first, then is extended later in the series to cover metadata".  The S3
+code is the final code with metadata support removed.
+
+The engine does this per line (SYNTH and REWRITE, Method).  A line of a
+reclaim patch that names metadata gets a data-only form.  The reclaim
+patch inserts the data-only form.  A synthetic patch, placed after 38,
+replaces it with the final line.  A metadata-only line has no data-only
+form: the synthetic patch inserts it.  The synthetic commits make up one
+new S5 commit:
+
+- mn #129, 6.18 #141: "btrfs: stripe_meta: extend stripe
+  reclaim to metadata block groups", author Zygo Blaxell
+  <ce3g8jdj@umail.furryterror.org>, 2026-10-22, `Assisted-by:
+  Claude:claude-opus-5-5` only.  It comes right after 38 (and 109's
+  part), before 48.
+
+What each patch's S3 form leaves out, and the extension adds back
+(misc-next numbers; 6.18 numbers in section 9):
+
+| old | S3 (data-only form) | the S5 extension adds |
+|---:|---|---|
+| 42 | btrfs_reclaim_block_group(): the chunk for relocating a trapped group, `if (btrfs_is_stripe_alloc_bg(bg))`; comment "A stripe_alloc group's live extents ..." | `\|\| btrfs_is_stripe_meta_bg(bg)`; "stripe_alloc / stripe_meta" |
+| 46 | btrfs_stripe_reclaim_tick() scans the space_info with `BTRFS_BLOCK_GROUP_DATA`; comment "Periodic re-evaluation of stripe_alloc groups" | the METADATA flag in the scan (65, later in S5, adds SYSTEM); the comment |
+| 47 | the reserved/pinned bail-out exempts `btrfs_is_stripe_alloc_bg(bg)`; comment "Not for a stripe_alloc group" | `&& !btrfs_is_stripe_meta_bg(bg)`; the comment |
+| 70 | compact_plan() counts EXTENT_ITEM keys only; comments in relocation.c, volumes.c, fs.h, block-group.c name stripe_alloc groups | METADATA_ITEM keys as nodesize extents, with compact_plan()'s `fs_info` local (its only use; in S3 it would be unused, -Wunused-variable), and "A tree block never spans a stripe, so for a metadata group the closure is the partial stripes themselves"; the comments |
+| 105 | its S3 piece's comment on btrfs_stripe_bg_wants_reclaim() names stripe_alloc groups | the comment |
+| 114 | stripe_reclaim_now accepts stripe_alloc groups, for one group and for "all"; comments in block-group.c and sysfs.c | `&& !btrfs_is_stripe_meta_bg(bg)` twice; the comments |
+| 113, 115, 116 | unchanged: they have no metadata code | nothing |
+
+115's stripe_reclaim_meta_room() stays in S3.  It checks that the
+metadata space_info can hold relocation's metadata reservation, which
+relocating a data group needs too.
+
+111 and 112 (the trim debit) stay in S5.  They are not reclaim.
+
+The data-only edits change no logic beyond the metadata tests: the S3
+functions are the tip's minus metadata (A5).  The comments are edited
+in place, mostly without rewrapping, so the extension's comment changes
+are the words it adds.
+
+The extension's message (both lanes):
+
+```
+btrfs: stripe_meta: extend stripe reclaim to metadata block groups
+
+The stripe reclaim of the reclaim subtopic handles stripe_alloc data block
+groups only.  stripe_meta allocates tree blocks in whole stripes too, so
+its block groups trap free space in partially used stripes the same way,
+and that space comes back only by moving the live tree blocks out of those
+stripes.  Metadata needs it more than data: a metadata reservation that
+finds no claimable stripe aborts the transaction instead of failing one
+write, so trapped metadata space that is never reclaimed ends in a forced
+read-only filesystem.
+
+Extend each reclaim mechanism to stripe_meta block groups:
+
+ - btrfs_reclaim_block_group(): allocate a chunk to relocate into when the
+   other groups' claimable stripes cannot take the group's live bytes, and
+   relocate the group even while it has reserved or pinned bytes.  Under
+   COW, a metadata group always has tree blocks reserved or pinned, so the
+   generic bail-out would defer it forever.
+
+ - The cleaner's periodic re-evaluation scans the metadata space_info as
+   well as the data one.
+
+ - Compaction counts metadata extent items: a tree block is nodesize long
+   and never spans a stripe, so for a metadata group the closure is the
+   partial stripes themselves.
+
+ - stripe_reclaim_now accepts stripe_meta block groups, for one group or
+   for all of them.
+
+The comments that name the groups reclaim handles now name both.
+
+Assisted-by: Claude:claude-opus-5-5
+```
+
+Its diff on misc-next (6.18 makes the same changes; there the first
+three sit in the reclaim loop, one indent deeper):
+
+```diff
+diff --git a/fs/btrfs/block-group.c b/fs/btrfs/block-group.c
+--- a/fs/btrfs/block-group.c
++++ b/fs/btrfs/block-group.c
+@@ -5131,14 +5131,14 @@ static int btrfs_reclaim_block_group(struct btrfs_block_group *bg, int *reclaime
+       bool compacted = false;
+ 
+       /*
+-       * A stripe_alloc group's live extents can only move into
++       * A stripe_alloc / stripe_meta group's live extents can only move into
+        * whole free stripes.  When the rest of the space_info has too few
+        * claimable bytes for them, allocate a chunk to relocate into, once per
+        * attempt.  Done here rather than in the reservation path so that a
+        * device shrink, which relocates without spare room by design, still
+        * fails cleanly.
+        */
+-      if (btrfs_is_stripe_alloc_bg(bg)) {
++      if (btrfs_is_stripe_alloc_bg(bg) || btrfs_is_stripe_meta_bg(bg)) {
+               u64 elsewhere = READ_ONCE(space_info->bytes_stripe_claimable);
+               u64 need = READ_ONCE(bg->used);
+ 
+@@ -5171,14 +5171,15 @@ static int btrfs_reclaim_block_group(struct btrfs_block_group *bg, int *reclaime
+       bg->stripe_reclaim_forced = STRIPE_RECLAIM_NONE;
+       if (bg->ro ||
+           ((bg->reserved || bg->pinned) &&
+-           !btrfs_is_stripe_alloc_bg(bg))) {
++           !btrfs_is_stripe_alloc_bg(bg) &&
++           !btrfs_is_stripe_meta_bg(bg))) {
+               /*
+                * We want to bail if we made new allocations or have
+                * outstanding allocations in this block group.  We do
+                * the ro check in case balance is currently acting on
+                * this block group.
+                *
+-               * Not for a stripe_alloc group: under
++               * Not for a stripe_alloc or stripe_meta group: under
+                * COW churn it always has blocks reserved or pinned,
+                * so the bail-out would defer it forever, while the
+                * trapped free space it was queued for only grows.
+@@ -5225,7 +5226,7 @@ static int btrfs_reclaim_block_group(struct btrfs_block_group *bg, int *reclaime
+               compact = (forced == STRIPE_RECLAIM_COMPACT);
+       } else if (!should_reclaim_block_group(bg, bg->length)) {
+               /*
+-               * Too full to relocate whole.  A stripe_alloc
++               * Too full to relocate whole.  A stripe_alloc / stripe_meta
+                * group whose free space is trapped in partially used stripes
+                * can still be compacted: only the extents in those stripes
+                * move.
+@@ -5554,7 +5555,7 @@ void btrfs_reclaim_bgs_work(struct work_struct *work)
+ }
+ 
+ /*
+- * Periodic re-evaluation of stripe_alloc groups from the
++ * Periodic re-evaluation of stripe_alloc / stripe_meta groups from the
+  * cleaner.  The commit-time rescan only sees groups whose free space changed
+  * in that transaction, and only when there is a transaction: a mark that
+  * did not land (the group was on another list) or a group the worker dropped
+@@ -5571,7 +5572,8 @@ static void btrfs_stripe_reclaim_tick(struct btrfs_fs_info *fs_info)
+       list_for_each_entry(sinfo, &fs_info->space_info, list) {
+               int raid;
+ 
+-              if (!(sinfo->flags & BTRFS_BLOCK_GROUP_DATA))
++              if (!(sinfo->flags & (BTRFS_BLOCK_GROUP_DATA |
++                                    BTRFS_BLOCK_GROUP_METADATA)))
+                       continue;
+               if (READ_ONCE(sinfo->bg_reclaim_threshold) <= 0)
+                       continue;
+@@ -5671,7 +5673,7 @@ static bool stripe_reclaim_now_queue(struct btrfs_block_group *bg,
+ }
+ 
+ /*
+- * /sys/fs/btrfs/<uuid>/stripe_reclaim_now: reclaim stripe_alloc
++ * /sys/fs/btrfs/<uuid>/stripe_reclaim_now: reclaim stripe_alloc / stripe_meta
+  * raid56 block groups now, e.g. from an idle-time job, rather than waiting
+  * for the commit-time rescan and its five-minute hysteresis.  The threshold
+  * is the space_info's bg_reclaim_threshold, or BTRFS_DEFAULT_RECLAIM_THRESH
+@@ -5684,7 +5686,7 @@ static bool stripe_reclaim_now_queue(struct btrfs_block_group *bg,
+  * Otherwise @start names one group (its logical start): it is reclaimed
+  * whatever the trapped minimums say, compacted if it is above the threshold
+  * and has trapped stripes, relocated otherwise.  -ENOENT: no group starts
+- * there; -EINVAL: not a stripe_alloc raid56 group (relocate
++ * there; -EINVAL: not a stripe_alloc / stripe_meta raid56 group (relocate
+  * any other group with balance's vrange filter); -EBUSY: the group is
+  * read-only (balance or scrub hold it); -EAGAIN: it is already on a list
+  * (queued, unused or new); -ENOSPC: the other groups' claimable stripes plus
+@@ -5722,7 +5724,8 @@ int btrfs_stripe_reclaim_now(struct btrfs_fs_info *fs_info, bool all, u64 start)
+                       return -ENOENT;
+               if (bg->start != start) {
+                       ret = -ENOENT;
+-              } else if (!btrfs_is_stripe_alloc_bg(bg)) {
++              } else if (!btrfs_is_stripe_alloc_bg(bg) &&
++                         !btrfs_is_stripe_meta_bg(bg)) {
+                       ret = -EINVAL;
+               } else if (READ_ONCE(bg->ro)) {
+                       ret = -EBUSY;
+@@ -5757,7 +5760,8 @@ int btrfs_stripe_reclaim_now(struct btrfs_fs_info *fs_info, bool all, u64 start)
+                             BTRFS_BLOCK_GROUP_RAID56_MASK))
+                               continue;
+                       list_for_each_entry(bg, &sinfo->block_groups[raid], list) {
+-                              if (!btrfs_is_stripe_alloc_bg(bg))
++                              if (!btrfs_is_stripe_alloc_bg(bg) &&
++                                  !btrfs_is_stripe_meta_bg(bg))
+                                       continue;
+                               kind = btrfs_stripe_bg_reclaim_now_kind(bg, thresh,
+                                               false, stripe_reclaim_chunk_room(bg));
+diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
+--- a/fs/btrfs/free-space-cache.c
++++ b/fs/btrfs/free-space-cache.c
+@@ -2290,7 +2290,7 @@ void btrfs_block_group_disarm_stripe_unusable(struct btrfs_block_group *bg)
+ 
+ 
+ /*
+- * Does this stripe_alloc group want the reclaim worker?  As
++ * Does this stripe_alloc / stripe_meta group want the reclaim worker?  As
+  * with zoned's zone_unusable, reclaim once enough of the group's free space
+  * is trapped.  A group whose live data is below the threshold is relocated
+  * whole; a fuller one is compacted (btrfs_compact_chunk()), moving only the
+diff --git a/fs/btrfs/fs.h b/fs/btrfs/fs.h
+--- a/fs/btrfs/fs.h
++++ b/fs/btrfs/fs.h
+@@ -984,7 +984,7 @@ struct btrfs_fs_info {
+       /* BTRFS_STRIPE_RMW_* masks; see btrfs_stripe_allow_rmw(). */
+       u32 stripe_rmw_prop;
+       /*
+-       * Reclaim compacts a mostly live stripe_alloc group once
++       * Reclaim compacts a mostly live stripe_alloc / stripe_meta group once
+        * this percent of its length is trapped; 0 = never (sysfs
+        * stripe_compact, default 10).  See btrfs_compact_chunk().
+        */
+diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
+--- a/fs/btrfs/relocation.c
++++ b/fs/btrfs/relocation.c
+@@ -190,14 +190,15 @@ struct reloc_control {
+ };
+ 
+ /*
+- * Stripe compaction.  A stripe_alloc group whose free space is
++ * Stripe compaction.  A stripe_alloc / stripe_meta group whose free space is
+  * trapped in partially used stripes, but whose live data mostly fills whole
+  * ones, does not need all of that data moved to get the space back: only the
+  * extents in the partial stripes, and -- since moving an extent frees its
+  * bytes in every stripe it spans -- the extents sharing a stripe with those,
+  * transitively.  compact_plan() selects that closure, find_next_extent()
+  * skips every extent outside it, and the group is kept and made writable
+- * again instead of removed.
++ * again instead of removed.  A tree block never spans a stripe, so for a
++ * metadata group the closure is the partial stripes themselves.
+  */
+ static bool compact_selected(const struct reloc_control *rc, u64 start, u64 len)
+ {
+@@ -5498,6 +5499,7 @@ static u32 compact_root(u32 *parent, u32 x)
+ static int compact_plan(struct reloc_control *rc, u64 *moved, u64 *nsel)
+ {
+       struct btrfs_block_group *bg = rc->block_group;
++      struct btrfs_fs_info *fs_info = bg->fs_info;
+       const u64 fsl = bg->full_stripe_len;
+       const u64 end = bg->start + bg->length;
+       BTRFS_PATH_AUTO_FREE(path);
+@@ -5565,6 +5567,8 @@ static int compact_plan(struct reloc_control *rc, u64 *moved, u64 *nsel)
+                       break;
+               if (key.type == BTRFS_EXTENT_ITEM_KEY)
+                       len = key.offset;
++              else if (key.type == BTRFS_METADATA_ITEM_KEY)
++                      len = fs_info->nodesize;
+               else
+                       continue;
+               if (key.objectid < bg->start || !len)
+diff --git a/fs/btrfs/sysfs.c b/fs/btrfs/sysfs.c
+--- a/fs/btrfs/sysfs.c
++++ b/fs/btrfs/sysfs.c
+@@ -1353,7 +1353,7 @@ BTRFS_ATTR_RW(, stripe_compact, btrfs_stripe_compact_show,
+             btrfs_stripe_compact_store);
+ 
+ /*
+- * Reclaim stripe_alloc raid56 block groups now: "all" (or "1")
++ * Reclaim stripe_alloc / stripe_meta raid56 block groups now: "all" (or "1")
+  * queues every group the reclaim predicate picks, a block group's logical
+  * start forces that group.  See btrfs_stripe_reclaim_now().
+  */
+diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
+--- a/fs/btrfs/volumes.c
++++ b/fs/btrfs/volumes.c
+@@ -3797,7 +3797,7 @@ int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset, bool v
+ }
+ 
+ /*
+- * Compact a stripe_alloc group: relocate only the extents in
++ * Compact a stripe_alloc / stripe_meta group: relocate only the extents in
+  * its partially used stripes (and those sharing a stripe with them) and keep
+  * it.  When that would move more than half its live bytes the group is
+  * relocated and removed as by btrfs_relocate_chunk() instead; @compacted
+```
+
+The rewritten originals keep their author, date and message.  Each
+message is edited where it describes metadata, and gets the line
+"The stripe_meta block group part of this change moved to "btrfs:
+stripe_meta: extend stripe reclaim to metadata block groups"." and an
+`Assisted-by: Claude:claude-opus-5-5` where it had none (A6 has the
+diffs).
+
+### A2. Placement
+
+misc-next S3 is #90-#101: 42, 46, 57's part, 47, 70, 73's part, 104's
+and 105's reclaim pieces, 113, 114, 115, 116.  No hunk of a reclaim
+patch is placed outside S3 (A5).  Revision 2 had 42, 47, 114 and 115 in
+S5.
+
+### A3. 73 without S5
+
+73 (keep relocation's stripe runs until relocation ends) put its
+retained test in run_freed_on_drain(), which 38 adds.  In S1-S4 the three
+write-done report sites freed any drained run.  Ruling A: add
+`&& !run->retained` there.  The overlay `retained-glue` writes it at:
+
+- btrfs_open_stripe_write_abandoned();
+- btrfs_open_stripe_write_done();
+- btrfs_open_stripe_write_done_run().
+
+73's own test on the close path (close_open_stripe_run()) is original
+code and is in its main commit.
+
+It applies from 73's main commit (mn #43, 6.18 #53) up to 38
+(mn #127, 6.18 #139), which replaces the three sites with
+open_stripe_run_drain_reported().  73's own test in run_freed_on_drain()
+is folded into 38 (FOLD 73 into 38), so 73 has no S5 part.  S1-S4 then
+keep a retained run until relocation releases it.
+
+### A3b. 115's metadata room check without S5
+
+115's stripe_reclaim_meta_room() calls `btrfs_can_overcommit(meta,
+bytes, BTRFS_RESERVE_FLUSH_ALL, true)`.  The last argument (`reloc`: a
+relocation may count the stripe_meta relocation reserve) comes from 50
+(S5), which changes the function's signature and every caller.  In
+the original order 50 came before 115; with 115 in S3, the S3 boundary
+failed to build ("too many arguments", first build of this revision).
+The data-only form is the three-argument call, which is the final code
+without the stripe_meta reserve.  The overlay `reclaim-room-call` writes
+it from 115's main commit (mn #100, 6.18 #112) up to 50's main commit
+(mn #132, 6.18 52's, #144), whose diff then also updates this call, as it
+updates the other callers.  50's message is unchanged.
+
+### A4. Ruling C1: the order
+
+S6a holds the debug code that does not need stripe_meta: 7, 39, 71, 72,
+80, 108, their parts, 28's meta_rmw counter and 64's mount-message
+part.  S6b holds 29, 55 and 94, the debug lines that sit in stripe_meta
+code or in 29's stats format (DEFER, Method), and 107.
+
+107 (remove dead pad reasons) deletes counters whose stats-file lines
+are added by 30's, 31's and 71's S6b parts, which sit in 29's format.
+In S6a it removed the fields before those lines arrived, and the per-commit
+build failed at the three parts ("no member named pad_decline_live").
+So 107 is classified debug_meta and is the last commit of the series.
+
+80 (per-class pin and run breakdown) has a `class_names` table with a
+BUILD_BUG_ON on its size.  Its "meta" entry needs 38's META class.  The
+engine writes the four data classes in 80 and adds "meta" in 38's commit
+(synthetic 80.5, folded into 38): with 80 before 38, 38's commit is the
+one that grows the class enum.
+
+### A5. S3 review against the tip minus metadata
+
+`bin/review4.py` reads the weave and lists, for every function a reclaim
+patch wrote code in, each hunk placed after S3.
+
+| | misc-next | 6.18 |
+|---|---|---|
+| reclaim hunks placed outside S3 | 0 | 0 |
+| functions the reclaim patches wrote code in | 40 | 38 |
+| unchanged after S3 | 32 | 30 |
+| changed after S3 | 8 | 8 |
+
+What changes them after S3:
+
+- the S5 extension (btrfs_reclaim_block_group(),
+  btrfs_stripe_reclaim_tick(), btrfs_stripe_reclaim_now(), compact_plan();
+  on 6.18 the first is btrfs_reclaim_bgs_work(), which holds the
+  reclaim body there);
+- 65 (stripe_meta system chunks): SYSTEM in btrfs_stripe_reclaim_tick();
+- 50 (stripe_meta relocation reserve): the `reloc` argument in
+  stripe_reclaim_meta_room() (A3b; an overlay, so review4, which reads
+  the weave, does not list it);
+- stripe_meta and fsync code that shares a function with reclaim code:
+  48 in btrfs_block_group_rescan_stripe_unusable(), 50's reloc_owner in
+  btrfs_relocate_block_group(), 39 and 81/83/105's init comments in
+  btrfs_init_fs_info(), and stripe_run_stats lines (81, 83, 108) in
+  btrfs_stripe_run_stats_show().
+
+So the S3 trees' reclaim functions are the tip's, minus the extension
+and minus later subtopics' unrelated lines.  The listings are
+`review4-mn.txt` and `review4-618.txt`.
+
+### A6. Residual and message edits
+
+The final tree of each candidate is the lane tip plus exactly this diff
+(ruling C4, both lanes).  Everything else (data-first reclaim, the 73
+glue, the 6.18 warning move, 80's name) nets to zero at the tip.
+
+misc-next, `git diff a23064467620 f4cfb9869a7d`:
+
+```diff
+diff --git a/fs/btrfs/block-group.c b/fs/btrfs/block-group.c
+index d596cf1b563ea..1a5b326b2e643 100644
+--- a/fs/btrfs/block-group.c
++++ b/fs/btrfs/block-group.c
+@@ -1608,12 +1608,10 @@ bool btrfs_stripe_run_strands(struct btrfs_block_group *bg, u64 stripe)
+ }
+ 
+ /*
+- * Parse a stripe_alloc_allow_rmw word list ("nodatacow",
+- * "prealloc", "fsync") into its mask.  Words are separated by comma,
+- * space or colon; the mount option form must use colon, since mount
+- * itself splits options at commas.  An empty value yields an empty
+- * mask.  Returns -EINVAL on any unknown word.  Shared by the mount
+- * option and the filesystem property.
++ * Parse the value of the btrfs.stripe_alloc_allow_rmw property, a word list
++ * ("nodatacow", "prealloc", "fsync"), into its mask.  Words are separated by
++ * comma, space or colon.  An empty value yields an empty mask.  Returns
++ * -EINVAL on any unknown word.
+  */
+ int btrfs_parse_stripe_rmw(const char *value, size_t len, u32 *mask)
+ {
+@@ -1643,22 +1641,6 @@ int btrfs_parse_stripe_rmw(const char *value, size_t len, u32 *mask)
+       return 0;
+ }
+ 
+-void btrfs_show_stripe_rmw(struct seq_file *seq, u32 mask)
+-{
+-      const char *sep = "";
+-
+-      if (mask & BTRFS_STRIPE_RMW_NODATACOW) {
+-              seq_printf(seq, "%snodatacow", sep);
+-              sep = ":";
+-      }
+-      if (mask & BTRFS_STRIPE_RMW_PREALLOC) {
+-              seq_printf(seq, "%sprealloc", sep);
+-              sep = ":";
+-      }
+-      if (mask & BTRFS_STRIPE_RMW_FSYNC)
+-              seq_printf(seq, "%sfsync", sep);
+-}
+-
+ /*
+  * Does every committed extent in [start, start + len) belong solely to
+  * @ino in @root_id -- exactly one reference, a plain data ref, count 1?
+diff --git a/fs/btrfs/block-group.h b/fs/btrfs/block-group.h
+index 115d8fa7369af..bb3af6ea7aa08 100644
+--- a/fs/btrfs/block-group.h
++++ b/fs/btrfs/block-group.h
+@@ -609,7 +609,6 @@ bool btrfs_stripe_run_pad_mask(struct btrfs_fs_info *fs_info, u64 stripe_start,
+ bool btrfs_stripe_nocow_writable(struct btrfs_inode *inode, u64 start,
+                                u64 num_bytes, u32 which, bool nowait);
+ int btrfs_parse_stripe_rmw(const char *value, size_t len, u32 *mask);
+-void btrfs_show_stripe_rmw(struct seq_file *seq, u32 mask);
+ void btrfs_log_settle_stripes(struct btrfs_inode *inode, u64 file_start,
+                             u64 file_len, u64 bytenr, u64 num_bytes);
+ int btrfs_stripe_alloc_check_support(struct btrfs_fs_info *fs_info);
+```
+
+6.18, `git diff 6602cb54b8e2 0d329b02edc8`:
+
+```diff
+diff --git a/fs/btrfs/block-group.c b/fs/btrfs/block-group.c
+index 1b18a0a4f3a85..41931c2152b4b 100644
+--- a/fs/btrfs/block-group.c
++++ b/fs/btrfs/block-group.c
+@@ -1580,12 +1580,10 @@ bool btrfs_stripe_run_strands(struct btrfs_block_group *bg, u64 stripe)
+ }
+ 
+ /*
+- * Parse a stripe_alloc_allow_rmw word list ("nodatacow",
+- * "prealloc", "fsync") into its mask.  Words are separated by comma,
+- * space or colon; the mount option form must use colon, since mount
+- * itself splits options at commas.  An empty value yields an empty
+- * mask.  Returns -EINVAL on any unknown word.  Shared by the mount
+- * option and the filesystem property.
++ * Parse the value of the btrfs.stripe_alloc_allow_rmw property, a word list
++ * ("nodatacow", "prealloc", "fsync"), into its mask.  Words are separated by
++ * comma, space or colon.  An empty value yields an empty mask.  Returns
++ * -EINVAL on any unknown word.
+  */
+ int btrfs_parse_stripe_rmw(const char *value, size_t len, u32 *mask)
+ {
+@@ -1615,22 +1613,6 @@ int btrfs_parse_stripe_rmw(const char *value, size_t len, u32 *mask)
+       return 0;
+ }
+ 
+-void btrfs_show_stripe_rmw(struct seq_file *seq, u32 mask)
+-{
+-      const char *sep = "";
+-
+-      if (mask & BTRFS_STRIPE_RMW_NODATACOW) {
+-              seq_printf(seq, "%snodatacow", sep);
+-              sep = ":";
+-      }
+-      if (mask & BTRFS_STRIPE_RMW_PREALLOC) {
+-              seq_printf(seq, "%sprealloc", sep);
+-              sep = ":";
+-      }
+-      if (mask & BTRFS_STRIPE_RMW_FSYNC)
+-              seq_printf(seq, "%sfsync", sep);
+-}
+-
+ /*
+  * Does every committed extent in [start, start + len) belong solely to
+  * @ino in @root_id -- exactly one reference, a plain data ref, count 1?
+diff --git a/fs/btrfs/block-group.h b/fs/btrfs/block-group.h
+index fa0c0a4d6229d..1defe8f297f85 100644
+--- a/fs/btrfs/block-group.h
++++ b/fs/btrfs/block-group.h
+@@ -599,7 +599,6 @@ bool btrfs_stripe_run_pad_mask(struct btrfs_fs_info *fs_info, u64 stripe_start,
+ bool btrfs_stripe_nocow_writable(struct btrfs_inode *inode, u64 start,
+                                u64 num_bytes, u32 which, bool nowait);
+ int btrfs_parse_stripe_rmw(const char *value, size_t len, u32 *mask);
+-void btrfs_show_stripe_rmw(struct seq_file *seq, u32 mask);
+ void btrfs_log_settle_stripes(struct btrfs_inode *inode, u64 file_start,
+                             u64 file_len, u64 bytenr, u64 num_bytes);
+ int btrfs_stripe_alloc_check_support(struct btrfs_fs_info *fs_info);
+```
+
+The dead code removal and the comment fix start at 19's main commit
+(misc-next #71, 6.18 #82), which adds both, so no commit has the dead
+function.  The overlay `allow-rmw-cleanup` carries them to the end.
+
+Ruling C4's message fixes:
+
+- 6: the message said retirement runs right after
+  TRANS_STATE_COMMIT_DOING stops accepting joins.  The code runs it before,
+  while joins are still accepted, and its comment says why.  The first
+  paragraph now says that, and the second says that joins are still
+  accepted between the retirement and TRANS_STATE_COMMIT_DOING.
+- 13: the cherry-pick line is removed.  "The drain is bounded" is
+  replaced: the drain has no timeout, and the default shared mode's
+  settle (83) is not bounded either.
+- 28: the warning stays in S1; the message no longer says the counter
+  comes with it.  The counter's debug part says what it is.
+- 4: a cherry-pick line like 13's, removed (only that).
+
+Every edited message, as a diff against the original (misc-next; the
+6.18 edits are the same text, plus 76's, section C2):
+
+**#4** (old 4, main): btrfs: stripe_alloc: control the policy with a filesystem property
+
+```diff
+@@ -51 +50,0 @@
+-(cherry picked from commit ecd4d3de8a0493f7c406d919d533f88e8b45390c)
+```
+
+**#6** (old 6, main): btrfs: retire stripe runs at commit and gate stripe_alloc
+
+```diff
+@@ -3,11 +3,13 @@
+-Hook stripe run retirement into the transaction commit, right after
+-TRANS_STATE_COMMIT_DOING stops accepting joins with a single writer
+-left.  At that point every data extent the transaction references was
+-inserted by an ordered extent completion that joined earlier, implying
+-its own data IO is done; the retirement drain waits out in-flight
+-neighbour writes in the same stripes (a pure data-IO wait, never an
+-ordered extent wait, which would deadlock on the blocked join).  After
+-the drain, no stripe this transaction references can ever be written
+-again, so a crash after the superblock write cannot tear it -- closing
+-the raid56 write hole for stripe-allocated block groups without
+-requiring flushoncommit.  A defensive retirement in
++Hook stripe run retirement into the transaction commit, after the wait
++for pending ordered extents and before TRANS_STATE_COMMIT_DOING stops
++accepting joins.  The retirement drain waits out in-flight data writes
++into the stripes of the transaction's runs: a pure data-IO wait, never
++an ordered extent wait.  It must run while the transaction still
++accepts joins: a task holding unreported stripe run bytes (a reserved
++extent whose bio has not completed) can block on a transaction join,
++for example for a chunk allocation while walking a delalloc range, and
++the drain waits for those bytes, so retiring after joins are blocked
++would deadlock.  After the drain, no stripe this transaction references
++can ever be written again, so a crash after the superblock write cannot
++tear it -- closing the raid56 write hole for stripe-allocated block
++groups without requiring flushoncommit.  A defensive retirement in
+@@ -16,4 +18,6 @@
+-An ordered extent whose stripe run was opened after the committing
+-transaction's retire point cannot insert its file extent into that
+-transaction, so btrfs_finish_one_ordered() ends its handle and waits
+-for the commit's critical section to end.  That wait must not be taken
++Joins are still accepted between the retirement and
++TRANS_STATE_COMMIT_DOING.  An ordered extent whose stripe run was opened
++after the committing transaction's retire point cannot insert its file
++extent into that transaction, so btrfs_finish_one_ordered() ends its
++handle and waits for the commit's critical section to end.  That wait
++must not be taken
+@@ -100,0 +105 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#20** (old 28, main): btrfs: stripe_alloc: report read-modify-write of uncovered stripes
+
+```diff
+@@ -13,3 +13,3 @@
+-is to make the exposure visible rather than to fill the log, and paired
+-with a meta_rmw counter in the existing stripe_park_stats sysfs file so
+-the rate can be read off without grepping dmesg.
++is to make the exposure visible rather than to fill the log.  (A
++meta_rmw counter in stripe_park_stats, to read the rate off without
++grepping dmesg, is debug code and is added in the debug subtopic.)
+@@ -20,0 +21 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#90** (old 42, main): btrfs: stripe_alloc: give a queued stripe group a chunk to relocate into when the supply is short
+
+```diff
+@@ -21,0 +22,3 @@
++The stripe_meta block group part of this change moved to
++"btrfs: stripe_meta: extend stripe reclaim to metadata block groups".
++
+@@ -22,0 +26 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#91** (old 46, main): btrfs: stripe_alloc: hand groups full of trapped free space to the reclaim worker
+
+```diff
+@@ -42,0 +43,3 @@
++The stripe_meta block group part of this change moved to
++"btrfs: stripe_meta: extend stripe reclaim to metadata block groups".
++
+@@ -44,0 +48 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#93** (old 47, main): btrfs: stripe_alloc: relocate a queued stripe group even while it has reserved or pinned bytes
+
+```diff
+@@ -5,6 +5,7 @@
+-and may be about to go empty on its own.  A stripe_alloc or stripe_meta
+-group is queued for the opposite reason -- free space trapped in
+-partially used stripes, which no amount of waiting frees -- and under
+-COW churn a metadata group has blocks reserved or pinned at every
+-moment, so the worker skipped every one of seven queued metadata
+-groups for the whole of a fill-to-the-edge test and relocated none.
++and may be about to go empty on its own.  A stripe_alloc group is
++queued for the opposite reason -- free space trapped in partially used
++stripes, which no amount of waiting frees -- and under COW churn it can
++have blocks reserved or pinned at any moment, so the worker can defer it
++indefinitely.  Metadata showed it: under stripe_meta, the worker skipped
++every one of seven queued metadata groups for the whole of a
++fill-to-the-edge test and relocated none.
+@@ -13,0 +15,3 @@
++The stripe_meta block group part of this change moved to
++"btrfs: stripe_meta: extend stripe reclaim to metadata block groups".
++
+@@ -14,0 +19 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#94** (old 70, main): btrfs: stripe_alloc: compact mostly live groups instead of skipping them
+
+```diff
+@@ -3,9 +3,9 @@
+-Reclaim only takes a stripe_alloc / stripe_meta group whose live data is
+-below bg_reclaim_threshold: moving everything out of a fuller group costs
+-nearly a group's worth of writes and needs that much claimable space
+-elsewhere.  But trapped free space is not confined to emptyish groups.
+-Under steady COW churn the metadata groups stay mostly live while every
+-commit leaves partially used stripes behind, and on a raid6 metadata fill
+-the trapped share of the metadata free space reached 88% with no group
+-ever falling below the threshold: reclaim never ran, and the space never
+-came back.
++Reclaim only takes a stripe_alloc group whose live data is below
++bg_reclaim_threshold: moving everything out of a fuller group costs nearly
++a group's worth of writes and needs that much claimable space elsewhere.
++But trapped free space is not confined to emptyish groups.  Under steady
++COW churn a group can stay mostly live while every commit leaves
++partially used stripes behind.  Metadata under stripe_meta showed it
++first: on a raid6 metadata fill the trapped share of the metadata free
++space reached 88% with no group ever falling below the threshold:
++reclaim never ran, and the space never came back.
+@@ -18,2 +18 @@
+-partial stripes under "shares an extent with".  A tree block never spans a
+-stripe, so for a metadata group it is just the partial stripes.
++partial stripes under "shares an extent with".
+@@ -56,0 +56,3 @@
++The stripe_meta block group part of this change moved to
++"btrfs: stripe_meta: extend stripe reclaim to metadata block groups".
++
+```
+
+**#99** (old 114, main): btrfs: stripe_alloc: add stripe_reclaim_now to reclaim stripes on demand
+
+```diff
+@@ -3 +3 @@
+-Background reclaim of stripe_alloc / stripe_meta raid56 groups runs when a
++Background reclaim of stripe_alloc raid56 groups runs when a
+@@ -13 +13 @@
+-      Queue every stripe_alloc / stripe_meta raid56 group that the
++      Queue every stripe_alloc raid56 group that the
+@@ -37 +37 @@
+-stripe_alloc / stripe_meta raid56 group (balance's vrange filter relocates
++stripe_alloc raid56 group (balance's vrange filter relocates
+@@ -63,0 +64,3 @@
++The stripe_meta block group part of this change moved to
++"btrfs: stripe_meta: extend stripe reclaim to metadata block groups".
++
+```
+
+**#102** (old 13, main): btrfs: stripe_alloc: settle a logged extent's stripes at log commit
+
+```diff
+@@ -26,6 +26,10 @@
+-The drain is bounded and join-free: run inflight is counted from
+-allocation, which happens during writeback with submission following in
+-the same pass, so the wait is bio flight time plus the parked-write
+-deadline that the flush short-circuits; write_done reporting needs no
+-transaction join, so waiting under the inode log mutex and a running
+-transaction handle is safe.
++The drain is join-free: write_done reporting needs no transaction join,
++so waiting under the inode log mutex and a running transaction handle is
++safe.  It is not bounded: it has no timeout and waits for data IO to
++complete.  Run inflight is counted from allocation, which happens during
++writeback with submission following in the same pass, so in practice the
++wait is bio flight time plus the parked-write deadline that the flush
++short-circuits.  (A later patch shares LOG runs per log transaction and
++makes that the default; its settle waits until every allocated sector in
++the logged extent's stripes is written, other writers' sectors included,
++and is not bounded either.)
+@@ -42 +46 @@
+-(cherry picked from commit 53c44fdbca58bd1fa267a5648e236ed4238d99ed)
++Assisted-by: Claude:claude-opus-5-5
+```
+
+**#116** (old 28, part): btrfs: stripe_alloc: report read-modify-write of uncovered stripes (debug part)
+
+```diff
+@@ -4,3 +4,2 @@
+-for the subtopic reorder: its hunks that need code from
+-"btrfs: add a write-hole invariant checker to the raid56 write path",
+-which comes later in the new order.
++for the subtopic reorder: the meta_rmw counter in stripe_park_stats, which
++is debug code.  The warning stays in the base subtopic.
+```
+
+6.18 only:
+
+**#50** (old 76, main): btrfs: stripe_alloc: drop the mount options, the property is the interface
+
+```diff
+@@ -37 +37 @@
+-The "does not cover raid56 system chunks" warning moves from
++The warning about the raid56 groups stripe_alloc does not cover moves from
+@@ -44,0 +45 @@
++Assisted-by: Claude:claude-opus-5-5
+```
+
+### A7. Oracle
+
+`bin/oracle3.py REPO BASE REF ORDER TIP WPOST.json SPEC RESIDUAL`.  Its
+subtopic labels are the engine's classes: S5 is S6a, S6 is S5, S7 is S6b.
+The stripe_meta lines before S5 are the comments of section 4.
+
+```
+PASS 164 commits match the wpost json, linear on base
+PASS final tree = a23064467620 + exactly residual-mn.diff (56 lines)
+PASS author name/email/date equal the source patch for every old patch's commit ([])
+     new commit 9a8bbe5a53a5 Zygo Blaxell <ce3g8jdj@umail.furryterror.org> 1792702025 -0400 btrfs: stripe_meta: extend stripe reclaim to metadata block groups
+PASS each original patch has exactly one main commit
+PASS messages: original verbatim, or with exactly the spec's edits ([]); edited: ('main', 4), ('main', 6), ('main', 28), ('main', 42), ('main', 46), ('main', 47), ('main', 70), ('main', 114), ('main', 13), ('part', 28, 1)
+PASS no Signed-off-by/Co-Authored-By/cherry-pick line anywhere; one opus Assisted-by on parts and new commits, at most one on edited ones ([])
+PASS no empty commits (0)
+PASS subtopics contiguous and in order: S1:#1-66 S2:#67-89 S3:#90-101 S4:#102-114 S5:#115-126 S6:#127-151 S7:#152-164
+     before the stripe_meta subtopic (629f454670c4): lines naming stripe_meta per file:
+       fs/btrfs/block-group.c:1
+       fs/btrfs/block-group.h:2
+       fs/btrfs/extent-tree.c:1
+       fs/btrfs/raid56.c:1
+       fs/btrfs/space-info.h:1
+ORACLE PASS
+```
+
+6.18:
+
+```
+PASS 180 commits match the wpost json, linear on base
+PASS final tree = 6602cb54b8e2 + exactly residual-618.diff (56 lines)
+PASS author name/email/date equal the source patch for every old patch's commit ([])
+     new commit dd54cf6f46ae Zygo Blaxell <ce3g8jdj@umail.furryterror.org> 1792702025 -0400 btrfs: stripe_meta: extend stripe reclaim to metadata block groups
+PASS each original patch has exactly one main commit
+PASS messages: original verbatim, or with exactly the spec's edits ([]); edited: ('main', 5), ('main', 13), ('main', 29), ('main', 76), ('main', 44), ('main', 48), ('main', 49), ('main', 84), ('main', 130), ('main', 14), ('part', 29, 1)
+PASS no Signed-off-by/Co-Authored-By/cherry-pick line anywhere; one opus Assisted-by on parts and new commits, at most one on edited ones ([])
+PASS no empty commits (0)
+PASS subtopics contiguous and in order: S1:#1-77 S2:#78-101 S3:#102-113 S4:#114-126 S5:#127-138 S6:#139-167 S7:#168-180
+     before the stripe_meta subtopic (7be4b9cd9743): lines naming stripe_meta per file:
+       fs/btrfs/block-group.c:1
+       fs/btrfs/block-group.h:2
+       fs/btrfs/extent-tree.c:1
+       fs/btrfs/raid56.c:1
+       fs/btrfs/space-info.h:1
+ORACLE PASS
+```
+
+### C2. 6.18: the uncovered-metadata mount warning in S1
+
+On 6.18, lane patch 76 drops the mount options.  It moves
+warn_stripe_alloc_uncovered() from btrfs_read_block_groups(), where the
+property is not applied yet, to btrfs_enable_stripe_alloc().  In the
+lane the moved copy has the stripe_meta body (system chunks only).
+Revision 2 therefore forced the whole move after 39, and S1-S4 printed no
+warning.
+
+Now 76's main commit (6.18 #50) moves the function with its pre-stripe_meta
+body (it warns when metadata or system chunks are raid56).  At lane 39
+(mn 38, #139), which makes raid56 metadata covered, the body becomes the
+system-chunk one, in its new place.  76's stripe_meta part is then empty
+and is dropped.  The overlays are `uncovered-warning` (#50 to #139) and
+`uncovered-warning-meta` (#139).  76's message now says "The warning about
+the raid56 groups stripe_alloc does not cover moves from ...", since in
+S1 it is the metadata warning.
+
+The S1 copy:
+
+```c
+/*
+ * stripe_alloc covers raid56 *data* block groups only.  A filesystem whose
+ * metadata is also raid56 keeps the write hole there.  The data guarantee is
+ * easy to read as a filesystem-wide one, so say once, when the policy turns
+ * on, what is not covered.  That is btrfs_enable_stripe_alloc(): at mount the
+ * property applies after the block groups are read, so a report from
+ * btrfs_read_block_groups() would find the flag still clear.  (Mixed block
+ * groups cannot get here: the property refuses them.)
+ */
+static void warn_stripe_alloc_uncovered(struct btrfs_fs_info *info)
+{
+       const u64 meta_bits = info->avail_metadata_alloc_bits |
+                             info->avail_system_alloc_bits;
+
+       if (!btrfs_test_opt(info, STRIPE_ALLOC))
+               return;
+
+       if (meta_bits & BTRFS_BLOCK_GROUP_RAID56_MASK)
+               btrfs_warn(info,
+"stripe_alloc does not cover raid56 metadata: the write hole remains for metadata, consider converting it to raid1c3/raid1c4");
+}
+```
+
+misc-next does not need this: 4 brings the property and 27 puts the
+warning in the enable path from the start.
+
+### C3. 6.18: no added W=1 warning
+
+The need/tried warning (set but not used) of an earlier 6.18 run came
+from 131 (115's equivalent): its backoff trigger edits a line of 129
+(113's equivalent), and with 129 placed after 131 the trigger was a part
+that came later, leaving `need` and `tried` unused in between.  129, 130,
+131 and 132 are all in S3 now, in their original order, and 131 is whole.
+
+This revision's first builds found one added W=1 warning, on both lanes:
+`unused variable 'fs_info'` in compact_plan() from 70's commit to the
+extension, because the data-only form dropped the metadata extent
+length, the variable's only use.  The declaration now moves to the
+extension too (a REWRITE with the new `prev:` option, which picks the
+declaration in compact_plan() and not 70's other one).  The builds (section 6) show no W=1 warning added by any
+commit or boundary.
 
-There are no subtopic boundaries to build, because the reorder did not
-complete.  One extra build of the only consistent prefix shows that the
-three adjacency resolutions compile.  17 normally sits after 13-16, and
-here it compiles without them.
 
-Build setup: ahive (idle on #5, never rebooted).  Scratch worktree
-/mnt/linux/wt-osord-mn, which was registered (harness map row 02cd4e7)
-and removed afterwards (1a64411).  Config config-r5fix-mn-kasan plus
-olddefconfig.  Each build ran `make W=1 fs/btrfs/` and then `make
-bzImage` (bzImage only).
+## Method
 
-| tree | W=1 fs/btrfs | bzImage |
-|---|---|---|
-| partial-s1 0a5df3ca5081 (new 1-13) | **FAIL**: `raid56.c:790 implicit declaration of btrfs_stripe_in_open_run`, `raid56.c:2737 implicit declaration of btrfs_stripe_run_pad_start` | FAIL (same) |
-| partial-s1 + `#include "block-group.h"` in raid56.c (scratch 6ca27b5ae550, deleted) | PASS | PASS (39383552 bytes) |
+A weave replay, `bin/wreplay.py`, rebuilds the series.  Every line
+that was ever present in a file of the series carries the patch that
+inserted it and the patch that deleted it.  A patch is cut into hunks:
+the weave lines it touches, clustered as diff -U3 would.  The new series
+applies hunks in the new order.  At any point, a file is the weave
+projected on the hunks applied so far.  So each commit is a subset of
+weave lines, and the last tree equals the original tip by construction.
+
+Each hunk starts at its patch's place in the new order: subtopic, then
+original order.  A fixpoint then moves a hunk to just after a later-placed
+hunk when one of these holds.  The moved hunk becomes a follow-up commit
+of its own patch, the "part".
+
+1. It deletes a line that the later hunk inserts.
+2. Its first inserted line sits inside a `{` block or a `/*` comment that
+   the later hunk opens.  An opener the later hunk only rewrote does not
+   count.
+3. It sits inside a multi-line argument list (a format string and its
+   arguments) between two later-placed lines.
+4. It uses a name that is new to the tree (absent from the base's fs/btrfs
+   and include/), and every declaration of that name comes later.  Before
+   the fixpoint, statements that use such names are split out of their
+   hunk as single statements, or as single `&&`/`||` operand lines.  Only
+   those statements wait.
+5. It defines a new static function whose users all come later.  The
+   definition moves into its first user's commit.
+
+New in this revision, for ruling A:
+
+- SYNTH: synthetic patches with fractional numbers, which have their own
+  class and place in the order.  On misc-next: 64.5 and 116.5 (the
+  metadata parts of the S3 reclaim patches, placed after 38 and grouped
+  into one commit), and 80.5 (80's "meta" class name, folded into 38's
+  commit with `into`).  On 6.18: 49.5, 132.5 and 95.5.
+- REWRITE (patch, old patches, regex, replacement, synthetic): a line that
+  one of the old patches inserts and that matches the regex gets a
+  data-only form.  The weave gets a new line with the replacement, inserted
+  by the old patch and deleted by the synthetic patch; the synthetic
+  patch inserts the original line.  A replacement of None means the old
+  patch does not insert the line at all.  A line that a later patch
+  deletes (split_dead) keeps that patch as its deleter, and `prev:REGEX`
+  limits a rule to lines just after a match (one declaration of two).  So the S3 commits
+  carry the data-only line, the extension commit swaps it for the final
+  line, and the final tree is unchanged.  The rules are in `wspec13.py`
+  (6.18: `wspec618b.py`); each must match at least once.
+
+After the engine, `bin/wpost.py` rewrites its commits where the rulings
+allow new code:
+
+- OVERLAYS: text edits carried in every tree from one commit up to
+  another, as replacements re-applied in each tree (with a three-way merge
+  as the fallback).  Where an overlay ends, the engine's own tree comes
+  back, so the ending commit absorbs its removal.  Used for 73's glue,
+  the C4 cleanup, and the 6.18 warning (sections A3, A6, C2).
+- DROPS: commits an overlay made empty (6.18: 76's stripe_meta part).
+- MSG_EDITS: text replacements in a message, each found exactly once
+  (`post/msgs.py`).
+- The extension commit's author and date are Zygo's and today's.  Every
+  other commit keeps the author, email and date of the patch it comes
+  from.
+
+Spec, `wspec13.py` (= revision 2's `wspec5.py`, plus):
+
+- PERSUB 104, 105 (ruling e): each hunk goes to the subtopic that owns the
+  code it edits.
+- TRANSFER_INS:
+  - 7's `#include "block-group.h"` in raid56.c moves into 11, which needs
+    it (D11).
+  - 38's `#include "raid56.h"` in transaction.c moves into 79.
+  - 83's `stripe_log_data_shared = true` init stays in 83's main commit.
+    Otherwise it would follow its comment block into S5, and the S4
+    default would flip.
+- NOMATCH: in 19's diff, the header line of btrfs_stripe_in_open_run()
+  counts as deleted and re-inserted, not as context.  19 turned old 11's
+  function into a wrapper and reused its header line.
+- FOLD: when a patch placed earlier changes an interface that a
+  later-placed patch's code uses, the earlier patch's edit of that code is
+  folded into the later patch's commit.  Five folds:
+  - 32 into 13 and 16: btrfs_flush_parked_rbios()'s new argument;
+  - 25 into 15: btrfs_check_data_free_space()'s margin probe in defrag;
+  - 81 into 80: the "meta_log" name in 80's class_names table.  Inert
+    now: 80 comes before 81, so 81's commit adds the name itself;
+  - 73 into 38 (new): 73's retained test in run_freed_on_drain().
+- JOIN: 110's two hunks in the space_info dump share one part; the
+  extension's hunks are one commit.
+- DEFER (5, 6, 7): a hunk of a class 5-7 patch that needs a later class
+  waits for it.  This is what splits S6a from S6b.
+
+Checks:
+
+- `bin/oracle3.py`: ORACLE PASS on both lanes (A7).
+- `bin/review4.py`: the S3 review (A5).
+- Grep of the S1-S4 trees for stripe_meta code (section 4).
+- Builds: W=1 fs/btrfs and bzImage at each boundary; W=1 fs/btrfs at
+  every commit from S3 to the end (section 6).
+
+Part commits are titled `<original subject> (<tag> part[ N])`.  The body
+names the patch whose code they need, or "its hunks in the <tag>
+subtopic's code" for 104/105.
+
+## 1. Classification and new positions
+
+misc-next numbers.  "new" is the position of the patch's main commit,
+"parts" its follow-up commits.  S is the subtopic of the main commit.
+
+| old | new | S | subject | parts | note |
+|---:|---:|:-:|---|---|---|
+| 1 | 1 | S1 | add btrfs_claim_free_stripe_run() for stripe-exclusive allocation |  |  |
+| 2 | 2 | S1 | add open stripe run tracking for stripe-exclusive allocation |  |  |
+| 3 | 3 | S1 | add the stripe_alloc allocation policy for raid56 data |  |  |
+| 4 | 4 | S1 | stripe_alloc: control the policy with a filesystem property |  | activation: the btrfs.stripe_alloc property |
+| 5 | 5 | S1 | report stripe run data IO through the ordered extent lifecycle |  |  |
+| 6 | 6 | S1 | retire stripe runs at commit and gate stripe_alloc |  |  |
+| 7 | 115 | S6a | add a write-hole invariant checker to the raid56 write path |  | debug: CONFIG_BTRFS_DEBUG checker (S6a). 19's edit of it follows it (#117); 38's edits of it are in 38's main commit, which now comes after it |
+| 8 | 7 | S1 | account stripe_alloc trapped free space for honest statfs |  | includes the debug-only sysfs trigger stripe_unusable_rescan and a tracepoint; core is statfs/admission accounting |
+| 9 | 8 | S1 | stripe_alloc: keep an open run per size band to trap less |  |  |
+| 10 | 9 | S1 | stripe_alloc: grow the frontier run instead of stranding its tail |  |  |
+| 11 | 10 | S1 | raid56: batch stripe_alloc partial writes into full-stripe writes |  | parking is core no-RMW function; its flushes are wired into ordered-extent waits and retirement |
+| 12 | 11 | S1 | stripe_alloc: never claim stripes covered by a live run |  |  |
+| 13 | 102 | S4 | stripe_alloc: settle a logged extent's stripes at log commit |  | fsync: log-commit settle (shared by both fsync modes) |
+| 14 | 12 | S1 | stripe_alloc: private per-inode stripe runs for log-active inodes |  | S1 whole (ruling a): generic private-run machinery and LOG steering. Without 13 (S4) its LOG runs are closed only by commit retirement, which is harmless. A generic/LOG split needs 18's class parameter, which is invented code |
+| 15 | 106 | S4 | stripe_alloc: carry an inode's log tail forward at fsync |  |  |
+| 16 | 109 | S4 | stripe_alloc: kick parked rbios before the fast fsync's writeback wait |  | fsync: parked-rbio kick before the fast fsync's writeback wait |
+| 17 | 13 | S1 | raid56: pad sub-stripe writes to full stripes in open runs |  |  |
+| 18 | 67 | S2 | stripe_alloc: isolate nodatacow and preallocated extents by stripe |  | allow-rmw: NOCOW class; builds on 14's private runs (S1) |
+| 19 | 71 | S2 | stripe_alloc: allow-rmw policy, and write-in-place for isolated nocow extents | #105 S4, #108 S4, #117 S6a | allow-rmw; its "fsync" word checks sit in 13's and 15's code and go to S4 (#105, #108); its checker edit goes to S6a (#117) |
+| 20 | 76 | S2 | stripe_alloc: persist nocow runs across commits and remounts |  |  |
+| 21 | 79 | S2 | raid56: do not park sync writes into nocow runs |  | parking edge for NOCOW runs only |
+| 22 | 14 | S1 | raid56: expose parking statistics in sysfs |  | stats file (stripe_park_stats). Counter infrastructure stays with the patches that bump it (ruling c); test-only. Counters printed after 28's format change are printed from S6 |
+| 23 | 15 | S1 | raid56: skip parking for sync rbios finished by their unplug batch |  | parking edge, generic |
+| 24 | 16 | S1 | stripe_alloc: count open stripe run remainders against data reservations | #77 S2, #103 S4 |  |
+| 25 | 17 | S1 | stripe_alloc: pessimistic data reservation margin |  | its edit of 15's defrag call (the margin probe) is folded into 15 (#100) |
+| 26 | 18 | S1 | stripe_alloc: claim fully-free stripes that span free space entries |  |  |
+| 27 | 19 | S1 | stripe_alloc: warn when raid56 metadata is not covered |  | user-facing mount warning ("stripe_alloc does not cover raid56 metadata"); narrowed by 38 and removed by 65, both in S5 |
+| 28 | 20 | S1 | stripe_alloc: report read-modify-write of uncovered stripes | #116 S6a | ruling C4: the rate-limited "write hole applies" warning stays in S1 (main commit); the meta_rmw counter (fs.h field, sysfs line, increment) is one debug part, #116 S6a. Message edited (the counter) |
+| 29 | 153 | S6b | raid56: say whether a metadata read-modify-write is a write hole |  | debug: metadata RMW audit (reads headers under the stripe lock); S6b, after S5 |
+| 30 | 21 | S1 | stripe_alloc: tunable park deadlines, and say why padding declined | #80 S2, #154 S6b | mixed: park-deadline tunables (production knobs) + data_rmw and pad_decline counters (debug) |
+| 31 | 22 | S1 | stripe_alloc: trace why padding declined, at the moment it declined | #155 S6b | tracepoint, plus btrfs_stripe_pad_info and the pad-reason enum that 33, 71 and 76 build on; S1 |
+| 32 | 23 | S1 | stripe_alloc: complete parked writes on allocation coverage, not clocks |  | core parking; its edits of 13's and 16's flush calls (the new argument) are folded into 13 (#96) and 16 (#103) |
+| 33 | 24 | S1 | stripe_alloc: track per-sector liveness and pad from the map | #72 S2 | liveness map; its comment and restructure of btrfs_stripe_open_run_class() (19's) go to S2 (#71); the logic is unchanged in S1 |
+| 34 | 25 | S1 | stripe_alloc: count claimable whole-stripe supply directly |  |  |
+| 35 | 26 | S1 | raid56: adaptive park deadline from the parked-rbio backlog | #157 S6b | production knob stripe_park_congestion (default off) + counters |
+| 36 | 27 | S1 | stripe_alloc: gate data admission on claimable whole-stripe supply |  |  |
+| 37 | 28 | S1 | stripe_alloc: cache a failed stripe run scan per block group |  |  |
+| 38 | 127 | S5 | stripe_meta: allocate tree blocks by whole stripes |  | stripe_meta main commit. Folds in 73's retained test in run_freed_on_drain() (FOLD 73 into 38) and the "meta" name in 80's class_names table (synthetic 80.5, `into` 38); 80's BUILD_BUG_ON on the table size needs the name in the commit that adds the class |
+| new | 129 | S5 | stripe_meta: extend stripe reclaim to metadata block groups |  | ruling A: the metadata parts of 42, 46, 47, 70 and 114 (author Zygo, today; Assisted-by only) |
+| 39 | 118 | S6a | stripe_alloc: drain the legacy allocator's writes before arming the write-hole check at a runtime enable |  | debug: exists only to keep the write-hole checker quiet; the drain worker runs on every runtime enable (production path). S6a |
+| 40 | 29 | S1 | stripe_alloc: keep the admitted bytes placeable when a group goes read-only |  | admission correctness; read-only transitions come from scrub and balance too |
+| 41 | 30 | S1 | stripe_alloc: never let relocation wait on the whole-stripe gate |  | relocation (balance) correctness under the gate, not reclaim-specific |
+| 42 | 90 | S3 | stripe_alloc: give a queued stripe group a chunk to relocate into when the supply is short |  | ruling A: data-only form in S3 (`if (btrfs_is_stripe_alloc_bg(bg))`, comment names stripe_alloc only); the stripe_meta test is in #129. Message: moved line |
+| 43 | 31 | S1 | stripe_alloc: charge relocation a margin per reservation, not per extent |  | relocation admission, used by balance |
+| 44 | 32 | S1 | stripe_alloc: keep the relocation group's stripes out of the admission supply |  | relocation admission, used by balance |
+| 45 | 33 | S1 | stripe_alloc: let a data write fall back to the relocation group rather than drop |  | relocation fallback, used by balance |
+| 46 | 91 | S3 | stripe_alloc: hand groups full of trapped free space to the reclaim worker |  | reclaim trigger. Ruling A: the cleaner tick scans the data space_info only (`BTRFS_BLOCK_GROUP_DATA`); the metadata scan is in #129. Message: moved line |
+| 47 | 93 | S3 | stripe_alloc: relocate a queued stripe group even while it has reserved or pinned bytes |  | ruling A: data-only form in S3 (bail-out exempts stripe_alloc groups); the stripe_meta exemption is in #129. Message: metadata wording, moved line |
+| 48 | 130 | S5 | stripe_meta: maintain trapped free space for metadata groups like data |  |  |
+| 49 | 131 | S5 | stripe_meta: back the global reserve with usable stripes, and say when a tree block finds none |  |  |
+| 50 | 132 | S5 | stripe_meta: hold back whole stripes so tree blocks always land and trapped groups can be reclaimed |  |  |
+| 51 | 136 | S5 | stripe_meta: do not steal from the global reserve below the relocation reserve |  |  |
+| 52 | 137 | S5 | stripe_meta: let the transaction machinery's own reservations draw on the reserve |  |  |
+| 53 | 138 | S5 | stripe_meta: let a group go read-only for relocation against the reserve |  |  |
+| 54 | 34 | S1 | stripe_alloc: show per-group trapped bytes in the space info dump |  | space_info dump (enospc_debug) line; production diagnostic, kept upstream-side |
+| 55 | 161 | S6b | stripe_alloc: tell a dead tree block from a live one in the metadata RMW audit |  | debug: RMW audit refinement; S6b |
+| 56 | 81 | S2 | stripe_alloc: do not read an inline backref off a keyed-ref extent item |  | fix to 20's stripe_extents_owned_by() |
+| 57 | 35 | S1 | stripe_alloc: count whole stripes stranded behind live runs as trapped | #92 S3, #133 S5 | generic stranded-stripe accounting. Its edit of 46's reclaim predicate goes to S3 (#92); its stranded field in the space_info dump sits on 50's format line: S5 (#133) |
+| 58 | 82 | S2 | stripe_alloc: give nocow extents a private run only while they may be written in place |  | NOCOW run lifecycle under the allow_rmw policy |
+| 59 | 36 | S1 | stripe_alloc: count nocow run lifecycles and stranded stripes in sysfs | #68 S2 | stripe_run_stats (ruling c); test-only. Its NOCOW counter bump goes to S2 (#68) |
+| 60 | 37 | S1 | stripe_alloc: hold a stripe of margin across a preallocation |  | admission: preallocation margin (fallocate, relocation, encoded write) |
+| 61 | 139 | S5 | stripe_meta: carry raid56 metadata groups through a runtime enable or disable |  | stripe_meta runtime enable/disable; touches 39's drain worker (S6a, before it now), so it needs no part |
+| 62 | 38 | S1 | stripe_alloc: return a group's allocation cluster before scanning its stripes |  | runtime-enable scan fix (data groups under ssd_spread, metadata groups) |
+| 63 | 39 | S1 | stripe_alloc: release open stripe runs when a mount fails or an aborted filesystem unmounts |  | teardown; motivated by metadata runs but releases every class |
+| 64 | 40 | S1 | stripe_alloc: say at mount whether the policy is on | #119 S6a | mount message. Removing the old enable-time message is in 39's code, so it goes to S6a (#119): S1-S4 print the line twice at mount |
+| 65 | 140 | S5 | stripe_meta: cover raid56 system chunks |  | stripe_meta system chunks; also extends 46's cleaner tick to SYSTEM |
+| 66 | 83 | S2 | stripe_alloc: close dead nocow stripe runs at commit |  | NOCOW dead-run close; adds btrfs_stripe_run_note_free() on the free path |
+| 67 | 74 | S2 | stripe_alloc: do not round a full stripe with power-of-two macros | #78 S2, #107 S4 | every hunk edits S2 code (19, 20) or S4 code (13, 15). Its main commit lands in S2 (#74) with stripe_round_down(); stripe_is_aligned() goes with its only user to S4 (#107). No S1 code had the bug |
+| 68 | 41 | S1 | stripe_alloc: do not wait for stripe runs to drain on an errored filesystem |  | errored-fs drain; also stops reclaim on an errored fs |
+| 69 | 42 | S1 | stripe_alloc: end the commit-time and log drains on an errored filesystem too | #104 S4 | errored-fs drain; one hunk is in the fsync settle wait (S4) |
+| 70 | 94 | S3 | stripe_alloc: compact mostly live groups instead of skipping them |  | compaction. Ruling A: data-only form; the metadata extent items in compact_plan() and the stripe_meta comments are in #129. Its edit of 42's block is now in its main commit. Message: metadata wording, moved line |
+| 71 | 121 | S6a | stripe_alloc: attribute each data read-modify-write to why padding declined | #156 S6b | debug: RMW attribution counters; records the pad verdict on the rbio. S6a; its stats lines that follow 29's format are S6b (#156) |
+| 72 | 122 | S6a | stripe_alloc: optionally audit data read-modify-writes against the committed extent tree |  | debug: CONFIG_BTRFS_DEBUG audit |
+| 73 | 43 | S1 | stripe_alloc: keep relocation's stripe runs until relocation ends | #95 S3 | relocation runs retained. Ruling A: S1-S4 frees at the three write-done report sites test `!run->retained` (overlay `retained-glue`, from #43 to 38's #127, which replaces those sites with open_stripe_run_drain_reported()); its run_freed_on_drain() test is folded into 38. Sysfs line: #95 S3 |
+| 74 | 44 | S1 | stripe_alloc: let relocation allocate a data chunk before it fails |  |  |
+| 75 | 45 | S1 | stripe_alloc: keep a stripe in the rbio cache until its run has written all of it | #69 S2, #158 S6b | rbio pin. The NOCOW early return in run_written_range() goes to S2 (#69); its counters' sysfs lines to S6b (#158) |
+| 76 | 46 | S1 | stripe_alloc: pad a stripe's allocated sectors whose write is still to come | #70 S2 | pads unwritten sectors. The NOCOW exclusion goes to S2 (#70) |
+| 77 | 47 | S1 | stripe_alloc: apply the property before tree-log replay |  | activation: property applied before log replay |
+| 78 | 48 | S1 | stripe_alloc: count refused rbio pins and track rbio cache high water | #159 S6b | pin counters (test-only), S1 with 75 and 79 that bump them; sysfs lines from S6b (#159) |
+| 79 | 49 | S1 | stripe_alloc: sweep stale rbio pins, and commit when live pins run low | #160 S6b | core: stale-pin sweep + commit request; counters ride along (sysfs lines #160 S6b) |
+| 80 | 123 | S6a | stripe_alloc: break rbio pins and open stripe runs down by run class |  | debug: per-class breakdown, S6a. Its class_names entry "meta" is written by 38 (synthetic 80.5 folded into 38), so S6a's table has the four data classes |
+| 81 | 141 | S5 | stripe_alloc: give each log commit its own metadata stripe run |  | stripe_meta: META_LOG runs; adds "meta_log" to 80's table (80 is now before it) |
+| 82 | 50 | S1 | stripe_alloc: don't make a parked rbio wait for sectors that will never be written |  | core parking |
+| 83 | 110 | S4 | stripe_alloc: share LOG data runs per log transaction | #143 S5 | fsync: shared LOG runs; the init line stays in 83 (transfer). Its log_* counters' sysfs lines and comment sit in 81's code: S5 (#143) |
+| 84 | 51 | S1 | stripe_alloc: let relocation allocate as many data chunks as its reservation needs |  |  |
+| 85 | 84 | S2 | stripe_alloc: key private stripe runs by subvolume and inode | #111 S4, #142 S5 | keys runs by root: S2. Its edits of 83 (S4, #111) and 81 (S5, #142) follow them |
+| 86 | 52 | S1 | stripe_alloc: do not treat an allocation error as a found extent |  | fixes 3, 14, 38 |
+| 87 | 53 | S1 | stripe_alloc: mark an ended ordered extent's sectors written |  | fixes 83 (S4), 75, 76; marking is generic |
+| 88 | 112 | S4 | stripe_alloc: read the shared LOG run mode once per log settle |  | fsync: shared-mode knob read once |
+| 89 | 54 | S1 | stripe_alloc: remove only the set bits of a bitmap when claiming a split run |  |  |
+| 90 | 85 | S2 | stripe_alloc: claim a stripe tail in one free space lock section |  |  |
+| 91 | 55 | S1 | stripe_alloc: keep the stripe totals consistent with the groups during the commit scan | #134 S5 | its STRIPE_ALLOC test of 50's reserve block goes to S5 (#134) |
+| 92 | 56 | S1 | stripe_alloc: do not delete an unused block group that still has stripe runs |  | fixes 3, 20, 38 |
+| 93 | 144 | S5 | stripe_meta: commit before waiting for metadata runs when making a group read-only |  | stripe_meta read-only commit |
+| 94 | 162 | S6b | raid56: do not read tree blocks under the stripe lock in the metadata RMW audit |  | debug: fix to 29/55 audits; S6b |
+| 95 | 57 | S1 | raid56: stop the park timer before destroying the raid56 workqueue |  | teardown: park timer vs workqueue |
+| 96 | 58 | S1 | stripe_alloc: order the filesystem error before waking stripe drain waiters |  | errored-fs wake ordering |
+| 97 | 59 | S1 | raid56: set a padded rbio's data bitmap under bio_list_lock |  |  |
+| 98 | 60 | S1 | stripe_alloc: forget the failed-claim verdict when a cluster returns its space |  |  |
+| 99 | 61 | S1 | stripe_alloc: do not let a remount revert the stripe_alloc property |  | activation: remount must not revert the property |
+| 100 | 86 | S2 | stripe_alloc: do not block a NOWAIT write in the nocow stripe check |  | fix to 19 |
+| 101 | 62 | S1 | stripe_alloc: keep the head of a claimed free space entry under the lock |  |  |
+| 102 | 145 | S5 | stripe_meta: check the block group lookup when freeing an unwritten tree block |  | fix to 38 |
+| 103 | 87 | S2 | stripe_alloc: remove the unused stripe_rmw_opt field |  | removes 19's dead field |
+| 104 | 146 | S5 | stripe_alloc: correct and trim the block group comments | #63 S1, #73 S2, #75 S2, #88 S2, #96 S3, #113 S4, #120 S6a, #124 S6a | comment-only; split by hunk into each subtopic's code (ruling e), see the parts column. Its S3 piece (#96) trims 42's comment |
+| 105 | 147 | S5 | stripe_alloc: correct and trim the comments outside the block group code | #64 S1, #89 S2, #97 S3, #114 S4, #125 S6a, #163 S6b | comment-only; split by hunk into each subtopic's code (ruling e), see the parts column |
+| 106 | 149 | S5 | stripe_meta: keep waiting for metadata runs that do not drain at commit |  | fix to 38 |
+| 107 | 164 | S6b | stripe_alloc: remove pad refusal reasons that no longer exist |  | debug: removes dead pad reasons/counters (71/30/31). S6b whole, last: the stats lines that read the removed counters are 30's, 31's and 71's S6b parts (#154-#156), which sit in 29's format |
+| 108 | 126 | S6a | stripe_alloc: count and log ordered extents that end with sectors unwritten | #152 S6b | debug: counter + rate-limited log; the marking it counts is 87's. S6a; its stats lines follow 81's: S6b (#152) |
+| 109 | 65 | S1 | stripe_alloc: skip RAID5/6 groups that are mapped as RAID1/RAID1C3 | #128 S5, #148 S5 | generic; its edit of btrfs_is_stripe_meta_bg goes to S5 (#128, #148) |
+| 110 | 66 | S1 | stripe_alloc: count single-data-stripe groups' free space in write admission | #135 S5 | admission; its unmanaged_free in the space_info dump sits on 50's format line: S5 (#135, one part: the format and its argument, JOIN) |
+| 111 | 150 | S5 | stripe_alloc: account claimable stripes while a trim has them out |  | stripe_meta: tests btrfs_is_stripe_meta_bg in the trim debit; S5 whole (trim debit is not reclaim). Also adds stripe_whole_bytes(), which is unused at the series tip (W=1 warning, an original-series defect) |
+| 112 | 151 | S5 | stripe_alloc: do not miss bitmap free space when debiting a trim |  | S5 with 111, which it fixes |
+| 113 | 98 | S3 | log block group reclaim at debug level |  | reclaim: Zygo's production diagnostic, a reclaim log message that dynamic debug can enable; S3 whole |
+| 114 | 99 | S3 | stripe_alloc: add stripe_reclaim_now to reclaim stripes on demand |  | ruling A: data-only form in S3 (one group and "all" accept stripe_alloc groups); stripe_meta groups are accepted from #129. Message: metadata wording, moved line |
+| 115 | 100 | S3 | stripe_alloc: back off block group reclaim after repeated ENOSPC |  | reclaim ENOSPC backoff, S3 whole (ruling A). Its relocation metadata room check (stripe_reclaim_meta_room()) is for relocating data groups and stays |
+| 116 | 101 | S3 | stripe_alloc: let queued exclusive operations in between reclaims |  | reclaim yields the exclusive operation between groups; S3 whole |
+
+## 2. Follow-up parts
+
+47 parts on misc-next.  14 are pieces of the comment cleanups 104/105
+(ruling e).  The other 33 move a patch's own lines that edit or use
+later-placed code.  The "why" column comes from the replay log.
+
+| new | S | from old | lines | why |
+|---:|:-:|---:|---:|---|
+| 63 | S1 | 104 | 363 | subtopic base |
+| 64 | S1 | 105 | 621 | subtopic base |
+| 68 | S2 | 59 | 2 | uses BTRFS_STRIPE_RUN_NOCOW from old 18 |
+| 69 | S2 | 75 | 2 | uses BTRFS_STRIPE_RUN_NOCOW from old 18 |
+| 70 | S2 | 76 | 1 | uses BTRFS_STRIPE_RUN_NOCOW from old 18 |
+| 72 | S2 | 33 | 26 | deletes a line of old 19 |
+| 73 | S2 | 104 | 16 | deletes a line of old 33 |
+| 75 | S2 | 104 | 10 | deletes a line of old 67 |
+| 77 | S2 | 24 | 1 | sits inside a block of old 20 |
+| 78 | S2 | 67 | 2 | deletes a line of old 20 |
+| 80 | S2 | 30 | 2 | deletes a line of old 21 |
+| 88 | S2 | 104 | 136 | subtopic allow_rmw |
+| 89 | S2 | 105 | 82 | subtopic allow_rmw |
+| 92 | S3 | 57 | 8 | deletes a line of old 46 |
+| 95 | S3 | 73 | 4 | sits inside an argument list of old 70 |
+| 96 | S3 | 104 | 12 | subtopic reclaim |
+| 97 | S3 | 105 | 55 | subtopic reclaim |
+| 103 | S4 | 24 | 4 | deletes a line of old 13 |
+| 104 | S4 | 69 | 3 | deletes a line of old 13 |
+| 105 | S4 | 19 | 15 | sits inside a block of old 13 |
+| 107 | S4 | 67 | 9 | defines stripe_is_aligned for its first user, old 67; deletes a line of old 15 |
+| 108 | S4 | 19 | 3 | sits inside a block of old 15 |
+| 111 | S4 | 85 | 7 | deletes a line of old 83 |
+| 113 | S4 | 104 | 68 | subtopic fsync |
+| 114 | S4 | 105 | 72 | subtopic fsync |
+| 116 | S6a | 28 | 8 | joined with its other hunks in the patch; uses meta_rmw from old 28 |
+| 117 | S6a | 19 | 3 | deletes a line of old 7 |
+| 119 | S6a | 64 | 12 | deletes a line of old 39 |
+| 120 | S6a | 104 | 6 | deletes a line of old 64 |
+| 124 | S6a | 104 | 63 | subtopic debug |
+| 125 | S6a | 105 | 14 | subtopic debug |
+| 128 | S5 | 109 | 3 | deletes a line of old 38 |
+| 133 | S5 | 57 | 5 | deletes a line of old 50 |
+| 134 | S5 | 91 | 8 | deletes a line of old 50 |
+| 135 | S5 | 110 | 5 | deletes a line of old 50; joined with its other hunks in fs/btrfs/space-info.c |
+| 142 | S5 | 85 | 1 | sits inside a block of old 81 |
+| 143 | S5 | 83 | 19 | deletes a line of old 81; sits inside a block of old 81 |
+| 148 | S5 | 109 | 4 | deletes a line of old 105 |
+| 152 | S6b | 108 | 8 | deletes a line of old 83; after the stripe_meta subtopic |
+| 154 | S6b | 30 | 8 | sits inside an argument list of old 29 |
+| 155 | S6b | 31 | 2 | sits inside an argument list of old 30 |
+| 156 | S6b | 71 | 28 | sits inside an argument list of old 31 |
+| 157 | S6b | 35 | 8 | deletes a line of old 29 |
+| 158 | S6b | 75 | 4 | sits inside an argument list of old 35 |
+| 159 | S6b | 78 | 14 | sits inside an argument list of old 75 |
+| 160 | S6b | 79 | 4 | sits inside an argument list of old 78 |
+| 163 | S6b | 105 | 58 | subtopic debug_meta |
+
+Effects of the parts on the intermediate trees (all cosmetic or
+counter-only; the counters exist from the main commit):
+
+- 57's stranded field, 91's guard and 110's unmanaged_free in the
+  space_info dump share a format line with 50's stripe_reserve: #133-#135
+  in S5.  S1-S4 print the dump without them.
+- 64's removal of the old enable-time message lands in S6a (#119), in
+  39's code.  S1-S4 print "using stripe-exclusive allocation for raid56
+  data" twice at mount.
+- The counter lines that 30, 31, 35, 75, 78 and 79 add to
+  stripe_park_stats follow 29's format change into S6b (#154-#160).
+
+## 3. Rulings (a), (c), (e)
+
+**(a) old 14.**  14 is in S1 whole, at its original position.  The
+minimal split (14a generic private runs, 14b LOG steering) would need a
+class parameter that only 18 introduces.  Before 13 (S4), LOG runs are
+closed only by commit retirement, which is harmless.
+
+**(c) Counters.**  The counter infrastructure stays with the subtopic
+whose patches bump it: 22 (stripe_park_stats), 59 (stripe_run_stats),
+31 (tracepoint and pad_info) and 78 (pin counters) are in S1.  80 is
+pure breakdown and is in S6a.  28's meta_rmw counter is an S6a part
+(ruling C4).  Every counter is test-only: production code only
+increments them or records high-water marks, and only sysfs reads them
+(the `stripe_parked_now` gauge is in neither struct).  Field (patch that
+adds it):
+
+- stripe_park_stats: parked, merged_bytes, filled, expired, kicked,
+  rmw_reads, padded (22); unparked_ready, stuck (32); padded_unwritten
+  (76); data_rmw, pad_decline_no_run (30); pad_decline_uncovered (31);
+  data_rmw_by[] (107); data_rmw_norun[], data_rmw_norun_ro,
+  data_rmw_reloc_writer (71); meta_rmw (28, debug part); meta_rmw_cur,
+  meta_rmw_old, meta_rmw_free (29); meta_rmw_ghost (55); meta_rmw_unknown
+  (94); congestion_short (35); rbio_pinned, written_not_live (75);
+  rbio_pin_refused, rbio_pinned_hwm, rbio_cache_hwm, meta_rmw_reads (78);
+  rbio_pin_swept, rbio_pin_commit_requests (79).
+- stripe_run_stats: nocow_run_opened, claim_refused_live_run,
+  strand_scan_bytes, strand_rescan_marks (59); nocow_run_dead_closed
+  (66); reloc_run_retained, reloc_run_released (73); compact_runs,
+  compact_fallbacks, compact_stripes, compact_bytes (70); log_run_opened
+  (81); log_settle_waits, log_settle_wait_ns, log_carry_ranges,
+  log_carry_bytes, log_seals, log_seal_bytes (83); unwritten_on_end,
+  unwritten_on_end_bytes (108).
+- Also test-only: the per-class pin and run breakdowns (80), the
+  stripe_run_stats and stripe_park_stats sysfs files themselves, and the
+  CONFIG_BTRFS_DEBUG stripe_unusable_rescan trigger (8).
+
+**(e) 104/105.**  Split by hunk into their subtopics: S1, S2, S3, S4, S6a,
+S5 (main commits) and S6b (105 only).  104's S3 piece (#96) trims 42's
+comment.
+
+## 4. (d) The S1-S4 trees have no stripe_meta code
+
+Grep of the S4 boundary trees (misc-next 94228b0ee7e2, 6.18 938994da00db) for
+btrfs_is_stripe_meta_bg, BTRFS_STRIPE_RUN_META, bytes_stripe_reserve,
+retire_meta, stripe_log_run, META_LOG and stripe_meta: no code.  The
+matches are comments, which S1 patches (or their 104/105 pieces) wrote
+in their final form and which name the stripe_meta counterpart:
+
+```
+fs/btrfs/block-group.c:468: * (btrfs_retire_meta_stripes()); persistent NOCOW runs survive commits.
+fs/btrfs/block-group.c:504:     * (bit 63 set, see stripe_run_owner()), or for META_LOG the root id
+fs/btrfs/block-group.c:749:    /* Private runs (LOG, NOCOW, META_LOG) never occupy a band slot. */
+fs/btrfs/block-group.c:2605: * IO.  Metadata runs are left to btrfs_retire_meta_stripes() and persistent
+fs/btrfs/block-group.h:145:     * IO never reaches raid56, so stripe_alloc and stripe_meta skip it.
+fs/btrfs/block-group.h:290:     * stripe_meta block group: present in the free space cache, but not
+fs/btrfs/extent-tree.c:4198: * Metadata is covered by btrfs_is_stripe_meta_bg().  Mixed groups are
+fs/btrfs/raid56.c:90: * btrfs_retire_meta_stripes() for metadata), which makes their pins
+fs/btrfs/raid56.c:3238: * stripe_meta does not cover.  Silent when stripe_alloc is off.
+fs/btrfs/space-info.h:162:                                        stripe_meta groups cannot allocate:
+```
+
+They are left as they are: rewriting them would add comment-only
+changes to S5 with no effect on the code.  Zygo can ask for them.
+
+Where each S1-S4 use of a stripe_meta symbol went:
+
+| old | use | handling |
+|---:|---|---|
+| 42, 46, 47, 70, 114 | metadata in the reclaim code | data-only form in S3, the extension in S5 (ruling A, A1) |
+| 63 | releases runs of every class on a failed mount | adds no stripe_meta line; every hunk edits S1 code |
+| 73 | `run->class != BTRFS_STRIPE_RUN_META && !run->retained` in run_freed_on_drain() | folded into 38; S1-S4 have the overlay (A3) |
+| 87 | marks an ended ordered extent's sectors written | adds no stripe_meta line; every hunk edits S1 code |
+| 109 | btrfs_is_stripe_meta_bg()'s RAID1-mapped test | parts #128, #148 in S5 |
+| 111 | btrfs_is_stripe_meta_bg() in the trim debit | whole patch in S5, with 112 |
+
+So dropping S5 now costs only 111 and 112: without them, a trim that has
+claimable stripes out is not accounted.
+
+## 5. Semantic review and decisions
+
+**Fixed by the method: a use-after-free in an earlier candidate.**  In
+an earlier run, the S4 tree's btrfs_open_stripe_write_done_run() freed a
+drained run and then wrote its written map (38 had replaced the free
+with open_stripe_run_drain_reported(); 75 had moved that call to the end
+of the function).  The weave places a patch's new lines above the old
+lines they replace when the patch inserted them above.  The S1-S4 trees
+update the map, wake, and then free.  73's overlay keeps that order: it
+only adds `&& !run->retained` to the free test.
+
+Revision 2's decisions, now ruled:
+
+- Decision 1 (73 without S5): the glue was added (ruling A, A3).
+- Decision 2 (42, 47, 111/112, 114, 115 in S5): ruling A puts 42, 47
+  and 114 in S3 in data-only form, and 115, unchanged, after 114.
+  111/112 stay in S5.
+- Decision 3 (80): 80 stays debug, now S6a before S5.  Its "meta" entry
+  is written by 38 (A4), and 81 adds "meta_log" in its own commit.
+
+Other notes:
+- 67 lands in S2.  Every one of its hunks edits S2 code (19, 20) or S4
+  code (13, 15).  Rule 5 keeps its helpers out of S1, where they were
+  unused (W=1 -Wunused-function).
+- 116 and 115 are both in S3 again, in their original order, so S3's
+  reclaim loop is the original's (minus metadata).
+- The double mount message in S1-S4 (64, #119) is cosmetic.
 
-The failure is D11: the include comes from old 7 (S6).  With the include
-moved into old 11, the prefix compiles, so the three adjacency
-resolutions are sound.  The only W=1 warning is
-`tree-log.c:3602 frame size 1056 > 1024`.  It is pre-existing: no patch
-in the prefix touches tree-log.c.
+## 6. Builds
 
-## 7. 6.18 lane
+VM ahive, worktree `/mnt/linux/wt-osord-mn`.  `make -j8 W=1 fs/btrfs/`,
+then `make -j8 bzImage`, at each boundary.  Then a linear chain, every
+commit from the last S2 commit to the end, `make -j8 W=1 fs/btrfs/` only
+(incremental, so a warning shows at the commit that recompiles its
+file).  misc-next config `/mnt/linux/config-r5fix-mn-kasan`, 6.18 config
+`config-review-618ffe-kasan`, both olddefconfig.  6.18 trees are merged
+with raid56-disguise (section 9).
 
-Not attempted, per the brief, because mn did not complete.  For planning:
-6.18/topics/stripe-alloc (1977bbfdee3c, 130 patches on v6.18.57) maps by
-subject to all 114 mn patches except one.  mn's old 27 "warn when raid56
-metadata is not covered" is "warn at mount when raid56 metadata is not
-covered" on 6.18.  The 16 subjects that exist only on 6.18 classify as
-follows:
+Boundaries (W=1 fs/btrfs, then bzImage):
 
-| 6.18 # | subject | subtopic |
-|---:|---|---|
+| subtopic | misc-next | 6.18 (merged with raid56-disguise) |
+|---|---|---|
+| S1 base | PASS / PASS, 39485952 bytes | PASS / PASS, 31838720 |
+| S2 allow_rmw | PASS / PASS, 39473664 | PASS / PASS, 31908352 |
+| S3 reclaim | PASS / PASS, 39408128 | PASS / PASS, 31945216 |
+| S4 fsync | PASS / PASS, 39453184 | PASS / PASS, 31883776 |
+| S6a debug | PASS / PASS, 39535104 | PASS / PASS, 31863296 |
+| S5 stripe_meta | PASS / PASS, 39457280 | PASS / PASS, 31908352 |
+| S6b debug_meta | PASS / PASS, 39490048 | PASS / PASS, 31965696 |
+
+S1 and S2 have the trees of the p13/q14 builds (unchanged since);
+S3-S6b were built as p16 and q16, the final trees.
+
+Every commit from S3 to the end, W=1 fs/btrfs (misc-next #90-#164, 75
+commits; 6.18 #102-#180, 79 commits, each merged with raid56-disguise):
+all rc=0.  Warnings: only the known ones below; stripe_whole_bytes
+first appears at 111's main commit (misc-next #150, 6.18 #166), as in
+the original.  No commit or boundary adds a W=1 warning (ruling C3).
+S1-S2 were built at their boundaries only, as the ruling asked (per
+commit from S3 on).
+
+What the builds of this revision found and fixed on the way (both
+lanes): 115's call needs 50's argument (A3b); compact_plan()'s fs_info
+unused in S3-S6a (C3); 107's field removal before the stats lines that
+read the fields (A4).
+
+Known warnings, in the base and the lane tips too: the frame-size
+warning in tree-log.c (both lanes) and free-space-cache.c (6.18), and
+stripe_whole_bytes() unused from 111's main commit (section 7).
+
+## 7. Defects found in the original series
+
+- 111 (a1ba776d84f3) adds stripe_whole_bytes() in free-space-cache.c with
+  no caller.  The original tip warns under W=1 (-Wunused-function), and so
+  does every commit from 111 on here.
+- 19 adds btrfs_show_stripe_rmw(), which nothing calls (no W=1 warning:
+  it is not static).  Removed (ruling C4, A6).
+- 4 and 13 carried `(cherry picked from commit ...)` lines.  Removed.
+- 46 of the 116 original messages end in extra blank lines, apparently
+  from earlier replays that used `git log --format=%B`.  The candidate
+  copies them verbatim (raw `cat-file` body).  Future replays should copy
+  the raw body too.
+- fs/btrfs/tree-log.c: the frame-size warning (KASAN config) appears in
+  every tree, the base included.
+
+## 8. Refs and files
+
+- Revision 3 candidates: `refs/tmp/o-sord/p16` f4cfb9869a7d and
+  `refs/tmp/o-sord/q16` 0d329b02edc8.  `refs/cand/sa-reorder/{mn,618}/topic`
+  still hold revision 2 until the reorder is replayed onto the rebased
+  lanes.
+- Revision 2's candidates: `refs/backup/sa-reorder-2026-10-22/rev2-mn-topic`
+  5b4847cb8f7a and `.../rev2-618-topic` 487ff1c5a439.  Earlier
+  experiments: `refs/backup/sa-reorder-2026-10-22/` (partial-s1
+  0a5df3ca5081, experiment-deferral c113d49f9228).
+- Scripts and logs are in the job directory (`osord/` below); the lead
+  copies the engine, inputs and final logs to `scripts/sa-reorder/`:
+  - `bin/wreplay.py` is the engine (SYNTH and REWRITE are new);
+    `bin/wpost.py` the overlay and message pass;
+  - misc-next: `wspec13.py`, `class.v13`, `order.orig116`, `post/wpost-mn.py`,
+    `post/msgs.py`; output `wreplay-x15.log`, `wreplay-x15.json`,
+    `wpost-p16.json`, `wpost-p16.log`;
+  - 6.18: `wspec618b.py` (it execs `post/ext.py`), `class618.v5`,
+    `order618.orig132`, `post/wpost-618.py`; output `wreplay-y15.log`,
+    `wreplay-y15.json`, `wpost-q16.json`, `wpost-q16.log`;
+  - `class.v13` is `class.v12` with 107 in debug_meta; `class618.v5` is
+    `class618.v4` with 122 (107) in debug_meta;
+  - checks: `bin/oracle3.py` with `post/residual-{mn,618}.diff`,
+    `bin/review4.py` (`review4-{mn,618}.txt`), `bin/msgdiff.py`;
+    builds: `bin/mkchain.py`, `queue7.sh`-`queue9.sh`, `build-one2.sh`,
+    `each-commit2.sh`; plan: `bin/assemble3.py`, `plan3-*.md`,
+    `post/notes13.py`.
+- To regenerate misc-next (about 5 minutes):
+
+  ```
+  cd t13 && TMPD=$PWD python3 -I ../bin/wreplay.py ~/share/linux \
+      0c48d26d46bd ../order.orig116 ../class.v13 ../wspec13.py \
+      refs/tmp/o-sord/x15 ../wreplay-x15.log && cp wreplay.json ../wreplay-x15.json
+  TMPD=$PWD python3 -I ../bin/wpost.py ~/share/linux ../wreplay-x15.json \
+      ../post/wpost-mn.py <ref> ../wpost-p16.json ../wpost-p16.log
+  ```
+
+  6.18 the same in `t618b` with base 2ff600d29ee4, `order618.orig132`,
+  `class618.v5`, `wspec618b.py` and `post/wpost-618.py`.
+
+## 9. 6.18
+
+`refs/tmp/o-sord/q16` = 0d329b02edc8: 180 commits on v6.18.57
+2ff600d29ee4: the 132 lane patches, 47 parts and the extension commit
+(#141).  The lane tip is 6.18/topics/stripe-alloc 6602cb54b8e2; the
+candidate's tree is the lane tip's plus the residual (A6).
+
+The same engine ran with:
+- `class618.v5`: class.v13 mapped by subject (`mn2s618.json`), plus the
+  16 lane-only patches (below).
+- `wspec618b.py`: the same rules renumbered.  The synthetic patches are
+  49.5 and 132.5 (the extension) and 95.5 (80's "meta", into 39).  The
+  REWRITE regexes match 6.18's indentation, and two comments that 6.18
+  wraps differently (84, 85) have rules of their own.  6.18-only: FOLD 65
+  into 16 (the defrag margin probe comes from lane-only 65 there), FOLD 88
+  into 39 (73 into 38), and 29's meta_rmw counter as a debug part
+  (FORCE, SPLIT_STMT, JOIN).
+
+oracle3: PASS on every check (A7).
+
+The 6.18 topic does not build on bare v6.18.57: 109's 6.18 version uses
+`btrfs_chunk_map.on_disk_type`, from 6.18/topics/raid56-disguise
+(3305976c0241, one commit on v6.18.57).  Each build tree is therefore
+merged with raid56-disguise (merge-tree, no conflicts), as a linear chain
+(`bin/mkchain.py`).  The candidate does not contain the merge.
+
+6.18 numbers for the A1 table (mn → 6.18): 42 → 44, 46 → 48, 47 → 49,
+70 → 84, 105 → 120, 113 → 129, 114 → 130, 115 → 131, 116 → 132.  Lane-only
+85 (compact by the trapped share of the group) is in S3 and has a
+REWRITE of its own (its comment).  The 6.18 S3 is #102-#113: 44, 48, 59's
+part, 49, 84, 88's part, 85, 120's part, 129, 130, 131, 132.
+
+The lane-only patches:
+
+| 6.18 # | subject | S |
+|---:|---|:-:|
 | 7 | refuse space_cache=v1 | S1 |
-| 41 | do not count trapped free space twice when making a block group read-only | S1 (fix to 40) |
+| 41 | do not count trapped free space twice when making a block group read-only | S1 |
 | 62 | charge the held stripe margin against every admission | S1 |
 | 63 | admit data reservations by whole stripes | S1 |
-| 65 | hold the probe margin until the metadata reservation charges it | S1 (data admission margin; read) |
-| 66 | saturate the read-only guard's claimable subtraction | S1 (fix to 40) |
-| 68 | charge the preallocation's stripe hold under the reservation lock | S1 (fix to 60) |
+| 65 | hold the probe margin until the metadata reservation charges it | S1 |
+| 66 | saturate the read-only guard's claimable subtraction | S1 |
+| 68 | charge the preallocation's stripe hold under the reservation lock | S1 |
 | 70 | stripe_meta: sync the open-run remainder when the commit retires metadata runs | S5 |
-| 71 | raid56: do not call a covered stripe_meta group uncovered | S6 (fix to 28's warning; uses stripe_meta, fine since S6 is last; read) |
+| 71 | raid56: do not call a covered stripe_meta group uncovered (edits 29's report) | S5 |
 | 73 | let the property accept a cache-less filesystem like the mount option does | S1 |
 | 75 | hold a reference on the rbio being parked | S1 |
-| 76 | drop the mount options, the property is the interface | S1 (mn never had the options) |
+| 76 | drop the mount options, the property is the interface | S1 |
 | 82 | grant the stripe_meta reserve to all of a relocation | S5 |
 | 83 | stripe_meta: let mount-time orphan cleanup steal from the global reserve | S5 |
-| 85 | compact a mostly live group by its trapped share of the group | S3 (fix to 70) |
-| 127 | do not refuse leftover v1 space cache inodes | S1 (fix to 7) |
-
-The rows marked "read" were checked against the patch.  The others are
-classified from the subject and the memory notes only.  The 6.18 lane has mount options that are later dropped (76),
-which mn does not have, so S1 on 6.18 carries one more interface change.
-
-## 8. Per-subtopic summaries (for the cover letter)
-
-The ranges use the no-split numbering of section 1.  The splits proposed
-in section 2 add about 20 commits and will shift them.
-
-### 1. Activation by property and basic no-RMW function (new 1-61)
+| 85 | compact a mostly live group by its trapped share of the group | S3 |
+| 127 | do not refuse leftover v1 space cache inodes | S1 |
+
+76 and the uncovered warning: section C2.  The 6.18 parts:
+
+| new | S | from old | lines | why |
+|---:|:-:|---:|---:|---|
+| 73 | S1 | 119 | 363 | subtopic base |
+| 74 | S1 | 120 | 621 | subtopic base |
+| 79 | S2 | 61 | 2 | uses BTRFS_STRIPE_RUN_NOCOW from old 19 |
+| 80 | S2 | 90 | 2 | uses BTRFS_STRIPE_RUN_NOCOW from old 19 |
+| 81 | S2 | 91 | 1 | uses BTRFS_STRIPE_RUN_NOCOW from old 19 |
+| 83 | S2 | 34 | 26 | deletes a line of old 20 |
+| 84 | S2 | 119 | 16 | deletes a line of old 34 |
+| 85 | S2 | 76 | 29 | deletes a line of old 20 |
+| 87 | S2 | 119 | 10 | deletes a line of old 79 |
+| 89 | S2 | 25 | 1 | sits inside a block of old 21 |
+| 90 | S2 | 79 | 2 | deletes a line of old 21 |
+| 92 | S2 | 31 | 2 | deletes a line of old 22 |
+| 100 | S2 | 119 | 136 | subtopic allow_rmw |
+| 101 | S2 | 120 | 82 | subtopic allow_rmw |
+| 104 | S3 | 59 | 8 | deletes a line of old 48 |
+| 107 | S3 | 88 | 4 | sits inside an argument list of old 84 |
+| 109 | S3 | 120 | 55 | subtopic reclaim |
+| 115 | S4 | 25 | 4 | deletes a line of old 14 |
+| 116 | S4 | 81 | 3 | deletes a line of old 14 |
+| 117 | S4 | 20 | 15 | sits inside a block of old 14 |
+| 119 | S4 | 79 | 9 | defines stripe_is_aligned for its first user, old 79; deletes a line of old 16 |
+| 120 | S4 | 20 | 3 | sits inside a block of old 16 |
+| 123 | S4 | 100 | 7 | deletes a line of old 98 |
+| 125 | S4 | 119 | 68 | subtopic fsync |
+| 126 | S4 | 120 | 72 | subtopic fsync |
+| 128 | S6a | 29 | 8 | joined with its other hunks in the patch; uses meta_rmw from old 29 |
+| 129 | S6a | 20 | 3 | deletes a line of old 6 |
+| 131 | S6a | 74 | 12 | deletes a line of old 40 |
+| 132 | S6a | 119 | 6 | deletes a line of old 74 |
+| 136 | S6a | 119 | 63 | subtopic debug |
+| 137 | S6a | 120 | 14 | subtopic debug |
+| 140 | S5 | 124 | 3 | deletes a line of old 39 |
+| 145 | S5 | 59 | 5 | deletes a line of old 52 |
+| 146 | S5 | 106 | 8 | deletes a line of old 52 |
+| 147 | S5 | 125 | 5 | deletes a line of old 52; joined with its other hunks in fs/btrfs/space-info.c |
+| 158 | S5 | 100 | 1 | sits inside a block of old 96 |
+| 159 | S5 | 98 | 19 | deletes a line of old 96; sits inside a block of old 96 |
+| 164 | S5 | 124 | 4 | deletes a line of old 120 |
+| 168 | S6b | 123 | 8 | deletes a line of old 98; after the stripe_meta subtopic |
+| 170 | S6b | 31 | 8 | sits inside an argument list of old 30 |
+| 171 | S6b | 32 | 2 | sits inside an argument list of old 31 |
+| 172 | S6b | 86 | 28 | sits inside an argument list of old 32 |
+| 173 | S6b | 36 | 8 | deletes a line of old 30 |
+| 174 | S6b | 90 | 4 | sits inside an argument list of old 36 |
+| 175 | S6b | 93 | 14 | sits inside an argument list of old 90 |
+| 176 | S6b | 94 | 4 | sits inside an argument list of old 93 |
+| 179 | S6b | 120 | 58 | subtopic debug_meta |
+
+## 10. Per-subtopic summaries (for the cover letter)
+
+New numbers are misc-next positions: main commit `#n`, old patch number
+`old n`.
+
+### S1. Activation by property, basic no-RMW function (#1-#66)
 
 Under stripe_alloc, raid56 data is allocated so that a stripe holding
 committed data is never written by a partial stripe write.  The write
 hole then cannot reach data that a completed transaction made durable.
 
 Mechanisms:
-- Claim rule: allocation takes runs of wholly free stripes (old 1, 26,
-  89, 101).
+- Claim rule: allocation takes runs of wholly free stripes (old 1, 26, 89,
+  101).
 - Open runs: per size band, the frontier run grows instead of stranding
   its tail (2, 9, 10, 12).
 - Run IO is reported through the ordered-extent lifecycle (5, 87).
-- Commit retirement closes and drains runs before the commit's super, so
-  nothing reopens a stripe across transactions (6, invariants I1-I4).
-- Partial writes inside an open run are parked and batched into
-  full-stripe writes.  Otherwise they are padded: unallocated or
-  abandoned sectors are zero-filled (11, 17, 23, 32, 82).
+- Commit retirement closes and drains runs before joins stop, so nothing
+  reopens a stripe across transactions (6, invariants I1-I4).
+- Parking and padding (11, 17, 23, 32, 82):
+  - Partial writes inside an open run are parked and batched into
+    full-stripe writes, or padded: unallocated or abandoned sectors are
+    zero-filled.
   - A per-sector liveness map decides what may be padded (33).
   - A written map pins a stripe in the rbio cache until its run has
     written all of it (75, 79).
-  - Sectors whose write is still to come get padded too (76).
-- Accounting: trapped free space (partial stripes nobody may write) is
-  out of statfs and df (8, 54).  Whole-stripe supply is counted directly
-  (34).  Data admission is gated on claimable whole stripes, with a
-  margin per extent and the open-run remainders charged (24, 25, 36, 57,
-  60, 110, 111, 112).
+  - Sectors whose write is still to come are padded too (76).
+- Accounting:
+  - Trapped free space (partial stripes nobody may write) is out of
+    statfs and df (8, 54).
+  - Whole-stripe supply is counted directly (34).
+  - Data admission is gated on claimable whole stripes.  A margin per
+    extent and the open-run remainders are charged (24, 25, 36, 57, 60,
+    110).
 - Relocation (balance, device remove, shrink) works under the gate: it
   is exempt from the gate, gets margins and fallback groups, and its runs
   are retained until relocation ends (40, 41, 43-45, 73, 74, 84).
+- Private per-inode runs, and LOG steering of log-active inodes (14,
+  ruling a).
 - Lifecycle and robustness: runtime enable and disable, remount, log
-  replay ordering, errored filesystems, mount failure, and teardown (62,
-  63, 68, 69, 77, 92, 95, 96, 99).
-- 109 skips raid5/6 groups that are mapped as raid1/raid1c3 (3-device
-  raid6).
+  replay ordering, errored filesystems, mount failure, teardown (62, 63,
+  68, 69, 77, 92, 95, 96, 99).
+- 109 skips raid5/6 groups that are mapped as raid1/raid1c3.
+- A rate-limited warning when a stripe that stripe_alloc does not cover
+  takes a read-modify-write (28).
 
 Knobs:
-- `btrfs.stripe_alloc` property on the top-level subvolume's root
-  directory (`setfattr -n btrfs.stripe_alloc -v 1`).  Deleting it turns
-  the policy off.  It requires the free space tree and refuses zoned,
-  remap-tree and mixed-bg filesystems.  Copies on received or cloned
-  subvolumes are ignored.  No on-disk format change: an older kernel
-  uses the legacy allocator.
-- Mount prints whether the policy is on (64).  It warns that raid56
-  metadata is uncovered (27) until S5.
+- The `btrfs.stripe_alloc` property on the top-level subvolume's root
+  directory.  Deleting it turns the policy off.  It requires the free
+  space tree and refuses zoned, remap-tree and mixed-bg filesystems.
+  There is no on-disk format change.
+- At mount the kernel says whether the policy is on (64), and warns that
+  raid56 metadata is uncovered (27; on 6.18 the moved copy, C2) until S5.
 - sysfs `allocation/data/`: `bytes_stripe_unusable`, `bytes_stripe_open`,
   `bytes_stripe_margin`, `bytes_stripe_claimable`, `bytes_stripe_stranded`.
 - Park tunables `stripe_park_timeout_ms` (100), `stripe_park_sync_timeout_ms`
-  (3) and `stripe_park_congestion` (0, off).
-- Under D4 (a), also the read-only `stripe_park_stats` and
-  `stripe_run_stats` and the pad-decline tracepoint.
+  (3), `stripe_park_congestion` (0).
+- Test-only (ruling c): `stripe_park_stats`, `stripe_run_stats`, and the
+  pad-decline tracepoint (31).
 
-### 2. Property to allow RMW for some operations (new 62-72)
+### S2. Property to allow RMW for some operations (#67-#89)
 
-Without this subtopic, stripe_alloc forces COW on nodatacow files and
-preallocated extents.  A second property lets the administrator allow
-in-place writes again.  The blast radius stays bounded: in-place writes
-are allowed only into stripes isolated to the writing inode, so a
-degraded crash can tear only that file's own data, which is the
-nodatacow contract.
+Without S2, stripe_alloc forces COW on nodatacow files and preallocated
+extents.  A second property allows in-place writes again, only into
+stripes isolated to the writing inode.  A degraded crash can then tear
+only that file's own data, which is the nodatacow contract.
 
 Mechanisms:
-- NOCOW-class private runs, keyed by subvolume and inode (18, 85; after
-  14a under D1).
+- NOCOW-class private runs, keyed by subvolume and inode (18, 85).
 - An ownership check: the fast path uses the inode's own runs, the slow
   path the committed extent tree's single plain ref (19, 56, 100).
-- Legacy nocow files migrate themselves in one COW generation.
+- Legacy nocow files migrate in one COW generation.
 - NOCOW runs persist across commits and remounts while the policy allows
   in-place writes (20, 58), and dead runs close at commit (66).
 - Sync writes into NOCOW runs are not parked (21).
-- 90 and 103 are small fixes and cleanups.
+- 90 and 103 are a fix and a cleanup.
+- 67 (full-stripe rounding by division) lands here, with the code it
+  fixes.
 
-Knob: `btrfs.stripe_alloc_allow_rmw`, a word list of `nodatacow` and
-`prealloc`.  The `fsync` word moves to S4 (D2).
+Knob: `btrfs.stripe_alloc_allow_rmw`, a word list: `nodatacow`,
+`prealloc`, `fsync`.  The `fsync` word's checks in the settle and carry
+are S4 parts of 19.
 
-### 3. Stripe-only reclaim for data block groups (new 73-77)
+### S3. Stripe-only reclaim for data block groups (#90-#101)
 
-Trapped tails pile up until something relocates their groups, and the
-stock trigger keys on used bytes, so it never sees them.
+Trapped tails pile up until something relocates their groups.  The stock
+trigger keys on used bytes, so it never sees them.  S3 reclaims data
+groups only; S5 extends it to metadata (ruling A).
 
 Mechanisms:
-- A group whose trapped bytes reach `bg_reclaim_threshold` of its free
-  space goes to the existing reclaim worker.  The trigger runs from the
-  cleaner tick as well as the commit rescan, with a room check and a
-  five-minute hysteresis (46).
-- The worker relocates queued groups even with reserved or pinned bytes
-  (47).  It allocates a chunk to relocate into when supply is short (42).
-- Compaction for mostly live groups.  It moves only the closure of the
-  partial stripes under "shares an extent with" (union-find over the
-  extent items).  It falls back to whole relocation when the closure is
-  more than half the live bytes (70).
-- On-demand reclaim (114).
-
-These paths also serve S5's metadata groups.  S3 contains the
-`|| btrfs_is_stripe_meta_bg()` terms only after the D5 split.
-
-Knobs:
-- `bg_reclaim_threshold` (the existing per-space_info knob; the trigger compares trapped bytes against it, 46).
-- `stripe_compact`: percent of the group trapped before compaction,
-  default 10.
-- `stripe_reclaim_now` (write-only): `all`/`1`, or a group's logical
-  start.
-
-### 4. Competing fsync implementations (new 78-83)
+- 46: a group whose trapped bytes reach `bg_reclaim_threshold` of its
+  free space goes to the existing reclaim worker.  The trigger runs from
+  the cleaner tick (data space_info) and the commit rescan, with a room
+  check and a five-minute hysteresis.
+- 47: the worker relocates a queued group even while it has reserved or
+  pinned bytes; waiting never frees trapped space.
+- 42: when the rest of the space_info has too few claimable bytes for
+  the group's live extents, allocate a chunk to relocate into, once per
+  attempt.
+- 70: compaction for mostly live groups.  It moves only the closure of
+  the partial stripes under "shares an extent with", and falls back to
+  whole relocation when the closure is more than half the live bytes.
+- 113: reclaim log messages at debug level, which dynamic debug can
+  enable.
+- 114: `stripe_reclaim_now`, to reclaim now ("all", or one group by its
+  logical start).
+- 115: the ENOSPC backoff (3 failures in a row: 10 minutes off, or until
+  a chunk is added or freed, or free space grows), plus a check that
+  relocation's metadata reservation fits.
+- 116: between groups, the reclaim worker yields the balance exclusive
+  operation, so a queued resize or replace gets in.  The gap is 12 s.
+
+Knobs: `bg_reclaim_threshold` (the existing knob), `stripe_compact`
+(percent of the group trapped before compaction, default 10),
+`stripe_reclaim_now`, `allocation/<type>/reclaim_backoffs`.  113's
+message is enabled with dynamic debug (`file block-group.c +p`).
+
+### S4. Competing fsync implementations (#102-#114)
 
 stripe_alloc alone confines the write hole to the current transaction.
 Inside that window two log commits can still share a stripe, so a later
-RMW can tear data that an earlier fsync made durable.  The base, 13,
-settles logged extents at each log commit: it closes the stripe's run,
-kicks parked writes, and waits for the run's data IO before the log
-super is written.  This closes the hole for completed fsyncs.  The cost
-is a trapped tail per fsync per touched stripe.  The two implementations
-that pay that cost back are:
-
-- **Private runs with carry-forward** (14, 15; 16 is the parked-rbio
-  kick before the fast fsync's writeback wait):
-  - Each log-active inode gets a private LOG run, which each log commit
-    closes.
+RMW can tear data that an earlier fsync made durable.
+
+The base, 13, settles logged extents at each log commit.  It closes the
+stripe's run, kicks parked writes, and waits for the run's data IO
+before the log super is written.  The cost is a trapped tail per fsync
+per touched stripe.  Two implementations pay it back:
+
+- **Private runs with carry-forward** (15; 16 kicks parked rbios before
+  the fast fsync's writeback wait):
+  - Each log-active inode has a private LOG run (14, in S1), which each
+    log commit closes.
   - The logged extents in the closed run's final partial stripe are
-    recorded.  At the next fsync they are re-dirtied defrag-style, so
-    the flush rewrites them into the new run and the old stripe frees
-    whole.
-  - One partial stripe per inode per fsync.  A back-to-back fsync loop
-    rewrites its previous tail each time.
+    re-dirtied at the next fsync and rewritten into the new run, so the
+    old stripe frees whole.
 - **Shared LOG runs per log transaction, the default** (83, 88):
   - LOG runs are keyed by (subvolume, log_transid), so inodes logging in
     one log transaction fill the same stripes.  Allocations of a full
     stripe or more keep a private run.
-  - The log commit does not close the run.  It seals the stripe holding
-    the end of the logged extent: the frontier moves to the stripe end,
-    and the skipped sectors are padded by the stripe's final write.
-  - The settle waits, with no timeout, only until every allocated sector
-    of the logged extent's stripes is written (the written map).
-  - Nothing is carried forward.  Leftover partial stripes wait for frees
-    or compaction.
-
-Why shared is the default (Zygo's ruling, 2026-10-06, fsync-log-mode
-bench; the measurements are in 83's message):
-- Setup: 5 x 8 GiB raid5 data, raid1 and raid5 metadata, compared
-  against private runs with carry-forward.
-- At 16 and 64 writers, and with one fsync per inode: 1.2-2.9x the
-  fsyncs/s (one 64-writer rep of eight was 0.8x), and 3-8x fewer device
-  bytes per fsync.  Later bench #280: 1.3-3x the fsyncs/s at 4-64
-  writers, with p99.9 latency at 0.1-0.7x.
-- One writer: parity on latency, with 17-29% fewer device bytes.
-- The workload that can lose: two large streaming writers beside small
-  fsync writers, at 0.5-1.9x the fsyncs/s.  A small fsync waits for
-  neighbours that joined its stripe.  The multi-second p99.9 there is
-  btrfs's log-commit tail, which both modes show and stock raid5 shows
-  too (17.1 s).
-- An earlier mode 1 was dropped.  Of the park-ceiling variants, only C1
-  (ceiling from live sectors) was kept.
+  - The log commit seals the stripe holding the end of the logged
+    extent.  The settle waits, with no timeout, until every allocated
+    sector of those stripes is written.
+  - Nothing is carried forward.
+
+Why shared is the default (Zygo, 2026-10-06; fsync-log-mode bench, also
+in 83's message):
+- 1.3-3x the fsyncs/s at 4-64 writers, with p99.9 at 0.1-0.7x.
+- 3-8x fewer device bytes per fsync.
+- Parity for a single writer.
+- The case that can lose is small fsync writers beside large streaming
+  writers.  Their multi-second p99.9 is btrfs's log-commit tail, which
+  stock raid5 shows too (17.1 s).
 
 Knobs:
-- `stripe_log_data_shared` (sysfs, default 1; 0 selects private runs
-  with carry-forward).
-- `btrfs.stripe_alloc_allow_rmw` word `fsync` (D2): waives the
-  log-window guarantee, so no settle and no carry.
-- Counters in `stripe_run_stats`: `log_settle_waits` and
-  `log_settle_wait_ns` (both modes), `log_carry_*` (private),
-  `log_seals` and `log_seal_bytes` (shared).
+- `stripe_log_data_shared` (sysfs, default 1; 0 selects carry-forward).
+- The `fsync` word of `btrfs.stripe_alloc_allow_rmw`.
+- Counters `log_settle_*`, `log_carry_*` and `log_seal_*` in
+  `stripe_run_stats`.  Their sysfs lines arrive with 81 in S5.
 
-### 5. stripe_meta (new 84-98)
+### S6a. Debugging code, minus its metadata parts (#115-#126)
 
-raid56 metadata gets the data rule.  Tree blocks come from runs of wholly
-free stripes, and a stripe is never revisited once its transaction has
-written it.  There is no separate switch: raid56 metadata is covered
-whenever stripe_alloc is on, and other profiles have no write hole.
+- The write-hole checker and its runtime-enable drain (7, 39).
+- RMW reports (72), and 28's meta_rmw counter.
+- RMW attribution by pad-decline reason (71).
+- The per-class pin and run breakdown (80), and the unwritten-on-end
+  counter and log (108).
+
+### S5. stripe_meta (#127-#151)
+
+raid56 metadata gets the data rule.  Tree blocks come from runs of
+wholly free stripes, and a stripe is never revisited once its
+transaction has written it.  There is no separate switch: raid56
+metadata is covered whenever stripe_alloc is on.
 
 Mechanisms:
-- Metadata write completion reports, and abandoned tree blocks are
-  reported too (38, 102).
-- Two-phase retirement: metadata runs close after the commit writes its
-  tree blocks (38, 106).
+- Metadata write completion and abandoned-block reports (38, 102).
+- Two-phase retirement after the commit writes its tree blocks (38, 106).
+- The extension of S3's reclaim to metadata groups (#129, ruling A).
 - Trapped-space accounting for metadata groups (48).
-- A global reserve backed by usable stripes (49), and a whole-stripe
-  reserve that relocation alone may draw on.  It prevents fill-edge
-  transaction aborts and lets trapped metadata groups be reclaimed (50,
-  51, 52, 53, 93).
+- A global reserve backed by usable stripes (49).
+- A whole-stripe relocation reserve (50-53, 93).
 - Runtime enable and disable (61), and system chunks (65).
-- META_LOG runs: each log commit gets its own metadata stripe run, keyed
-  by (root, log_transid), so log blocks that fsync made durable are never
-  RMWed by the next writer (81).
-  - Trapped space returns once the log tree frees.
-  - Metadata total settles around 2.15x the plain allocator's.
-- 104 and 105 (comment cleanup of the whole series) close the upstream
-  part (D7).
+- META_LOG runs: one per log commit, keyed by (root, log_transid) (81).
+- The trim debit for claimable stripes (111, 112).
+- The stripe_meta halves of S1-S4 patches, and the main commits of the
+  comment cleanups 104/105.
 
 Knobs:
-- `allocation/metadata/bytes_stripe_reserve`, and the S1 counters for
-  metadata.
-- `stripe_log_run` (sysfs, default 1) switches META_LOG runs.
+- `allocation/metadata/bytes_stripe_reserve`.
+- `stripe_log_run` (default 1).
 - The S1 mount warning is narrowed by 38 and removed by 65.
 
-### 6. Debugging code not for upstream (new 99-114)
-
-- The write-hole invariant checker and its runtime-enable drain (7, 39).
-- The metadata RMW audit (29, 55, 94).
-- The CONFIG_BTRFS_DEBUG data-RMW audit against the committed extent
-  tree (72: `debug/stripe_rmw_audit` and `debug/stripe_rmw_audit_stats`).
-- RMW attribution by pad-decline reason (71, 107).
-- The "write hole applies" warning for uncovered RMWs (28).
-- Counters: refused pins and rbio-cache high water (78), the per-class
-  breakdown (80), and ordered extents that end with sectors unwritten
-  (108).
-- The dyndbg reclaim log (113).
-- Under D4 (b) this subtopic would also hold `stripe_park_stats` (22),
-  the pad-decline tracepoint (31) and `stripe_run_stats` (59).
-- `space_info/stripe_unusable_rescan` (debug, from 8) should move here
-  as a split of 8.  That split is mechanical.
-
-Wired into production paths: see section 1 (7's RELOC_USED and 19's
-NOCOW_USED set_bit calls, 39's drain worker, 28's warning).
+### S6b. The metadata parts of the debugging code (#152-#164)
+
+- The metadata RMW audit and its fixes (29, 55, 94).
+- The removal of pad reasons that no longer exist (107), after the stats
+  lines that read the removed counters.
+- The debug lines that sit in stripe_meta code, including the
+  stats-file lines that follow 29's format change.