tools/fs/xfs_recover: stop the extent fork walk at the last record · Pull Request !1403 · OpenCloudOS/OpenCloudOS-Kernel

## Problem / Evidence

`inode_extent_tree_travel()` walks a data fork in extent format with a loop
that only ends on a record whose block count is zero:

```
        convert_extent(rec, &startoff, &startblock, &blockcount, &state);
        while (1) {
            convert_extent(rec, &startoff, &startblock, &blockcount, &state);
            if (blockcount == 0) {
                break;
            }
            ...
            rec++;
        }
```

A fork can be full - `di_nextents` at `XFS_DFORK_SIZE()/sizeof(xfs_bmbt_rec_t)`,
21 records for a 512 byte inode - and a full fork contains no zero record. The
walk then reads the next 16 bytes, which are the core of the inode that
follows in the same 4 KiB block, and decodes its `di_magic`, `di_mode`,
`di_uid`, `di_gid` and `di_nlink` as an extent.

Reproduced on a real, mounted filesystem (no crafted bytes): a 41 block file
fragmented into 21 extents with `xfs_io -c fpunch` and owned by `1000:1000`,
with one inode allocated beside it.

```
$ xfs_db -r -c "inode 131" -c "p core.format" -c "p core.nextents" t.img
core.format = 2 (extents)
core.nextents = 21

$ xfsrecover -n t.img          # baseline
startoff:20                  startblock:80876    blockcount:1     ag:3
startoff:10316996004643072   startblock:1603584  blockcount:1000  ag:62
lseek(inofd): Invalid argument
recover_block_to_file(inode_extent_tree_travel)
Recover error: ./RECOVER/131_file
Recovery incomplete!                       (exit 1)
```

The last line is the 21st real extent; the line after it is the neighbour's
core: its uid/gid (`1000`) became the block count and its magic and mode
became the file offset, which cannot be seeked to. The run is abandoned, so
**every inode behind this one is lost** - and before that the copy path is fed
whatever blocks the garbage record names. With root-owned neighbours the
garbage record happens to decode to a zero block count, which is why the bug
stays hidden on many images.

### Fixture (400 MiB image, 4 KiB blocks, 512 byte inodes, no mount)

`mkfs.xfs` writes the victim and a neighbour from one prototype file, so they
hold **consecutive** inode slots and both are owned by `1000:1000`; `xfs_db`
then gives the victim `core.format 2`, `core.nextents 21` and 21 `u3.bmx[]`
records, and the data blocks those records name are written into the image at
the device blocks the scanner's own `XFS_FSB_TO_DADDR()` conversion resolves
to.

| | baseline (`linux-6.6/devel` @ 866d9321422b) | fixed |
|---|---|---|
| tool output | 21 extents, then `lseek(inofd): Invalid argument`, `Recovery incomplete!` | 21 extents, `Recover success!` |
| exit status | 1 | 0 |
| `RECOVER/99_file` | 86016 bytes but the run aborted, later inodes never scanned | 86016 bytes, byte-identical to the written pattern |
| `tests/full_fork.sh` | `tool exit=1; scan aborted` | `ok - all 21 extents of a full inode fork recovered (86016 bytes)` |

## Root cause / Fix

```
        if (iflag == 1) {
            /* extent */
            rec = (xfs_bmbt_rec_t *) rblock;
            numrecs = be32_to_cpu(dinode->di_nextents);
            fsize = XFS_DFORK_SIZE(dinode, mp, XFS_DATA_FORK);
            maxrecs = fsize / sizeof(xfs_bmbt_rec_t);
            if (numrecs > maxrecs) {
                numrecs = maxrecs;
            }
        } else {
            /* leaf */
            rec = (xfs_bmbt_rec_t * )(rblock + 1);
            numrecs = be16_to_cpu(rblock->bb_numrecs);
        }
        for (i = 0; i < numrecs; i++) {
```

The record count is on-disk data, so the fork size is used as the hard maximum
of how many the inode can hold, and a stale or damaged `di_nextents` cannot
walk past the fork either. The loop body is unchanged, including the
`blockcount == 0` bail-out; the dead `convert_extent()` call before the loop
went away with the rewrite.

## Tests

```
$ make -C tools/fs/xfs_recover
$ sh tests/full_fork.sh    -> ok - all 21 extents of a full inode fork recovered
                              (86016 bytes)                            (fails before)
$ sh tests/btree.sh        -> ok - btree data fork recovered completely (102400 bytes)
$ sh tests/unwritten.sh    -> ok - unwritten extents stay holes in both fork formats
$ sh tools/fs/tests/recover-io.sh        -> ok - 61 recovery copy cases
$ python3 tools/fs/tests/recover-images.py -> 17 cases + xfs metadata-only scan, unchanged
$ sh tools/fs/tests/xfs-recover-path.sh  -> PASS for the 512 and 1023 byte path cases
```

`tests/full_fork.py` asserts the shape it depends on rather than assuming it:
the neighbour is the next inode number, the fork holds exactly
`(inodesize - 176) / 16` records, and the neighbour really is owned by
`1000:1000` (with a zero owner the overrun would decode to a zero block count
and the fixture would be vacuous).

## Risk

Small and local: the extent walk now reads exactly the records the inode
declares instead of scanning for a terminator, and the btree leaf case is
unchanged. Forks that are not full keep the same extents; no interface or
output format changes.

类型	指派人员	状态
审查	zoucao Huang Cun Jianping Liu	已完成 (0/0人)
测试	Jianping Liu	已完成 (0/0人)

GVPOpenCloudOS / OpenCloudOS-Kernel

搜索帮助

GVP OpenCloudOS / OpenCloudOS-Kernel