f2fs_reader/
reader.rs

1// Copyright 2025 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4use crate::block_cache::BlockCache;
5use crate::checkpoint::*;
6use crate::crypto;
7use crate::dir::{DentryBlock, DirEntry};
8use crate::inode::{self, Inode};
9use crate::nat::{Nat, NatJournal, RawNatEntry, SummaryBlock};
10use crate::superblock::{
11    BLOCK_SIZE, BLOCKS_PER_SEGMENT, F2FS_MAGIC, SEGMENT_SIZE, SUPERBLOCK_OFFSET, SuperBlock,
12    f2fs_crc32,
13};
14use anyhow::{Error, anyhow, bail, ensure};
15use async_trait::async_trait;
16use std::collections::HashMap;
17use std::ops::Deref;
18use std::sync::Arc;
19use storage_device::Device;
20use storage_device::buffer::Buffer;
21use zerocopy::FromBytes;
22
23// Used to indicate zero pages (when used as block_addr) and end of list (when used as nid).
24pub const NULL_ADDR: u32 = 0;
25// Used to indicate a new page that hasn't been allocated yet.
26pub const NEW_ADDR: u32 = 0xffffffff;
27
28/// This trait is exposed to allow unit testing of Inode and other structs.
29/// It is implemented by F2fsReader.
30#[async_trait]
31pub(super) trait Reader {
32    /// Read a raw block from disk.
33    /// `block_addr` is the physical block offset on the device.
34    async fn read_raw_block(&self, block_addr: u32) -> Result<Buffer<'_>, Error>;
35
36    /// Reads a logical 'node' block from the disk (i.e. via NAT indirection)
37    async fn read_node(&self, nid: u32) -> Result<Buffer<'_>, Error>;
38
39    /// Attempt to retrieve a key given its identifier.
40    fn get_key(&self, _identifier: &[u8; 16]) -> Option<&[u8; 64]> {
41        None
42    }
43
44    /// Returns the filesystem UUID. This is needed for some decryption policies.
45    fn fs_uuid(&self) -> &[u8; 16];
46
47    /// Attempt to obtain a decryptor for a given crypto context.
48    /// Will return None if the main key is not known.
49    fn get_decryptor_for_inode(&self, inode: &Inode) -> Option<crypto::PerFileDecryptor> {
50        if let Some(context) = inode.context {
51            if let Some(main_key) = self.get_key(&context.main_key_identifier) {
52                return Some(crypto::PerFileDecryptor::new(main_key, context, self.fs_uuid()));
53            }
54        }
55        None
56    }
57
58    /// Look up a raw NAT entry given a node ID.
59    async fn get_nat_entry(&self, nid: u32) -> Result<RawNatEntry, Error>;
60}
61
62pub struct F2fsReader {
63    device: Arc<dyn Device>,
64    superblock: SuperBlock,     // 1kb, points at checkpoints
65    checkpoint: CheckpointPack, // pair of a/b segments (alternating versions)
66    cp_start_block: u32,        // Start block of the active checkpoint
67    nat: Option<Nat>,
68
69    // A simple key store.
70    keys: HashMap<[u8; 16], [u8; 64]>,
71    cache: BlockCache,
72}
73
74impl Drop for F2fsReader {
75    fn drop(&mut self) {
76        // Zero keys in RAM for extra safety.
77        self.keys.values_mut().for_each(|v| {
78            *v = [0u8; 64];
79        });
80    }
81}
82
83impl F2fsReader {
84    pub fn superblock(&self) -> &SuperBlock {
85        &self.superblock
86    }
87
88    pub fn checkpoint(&self) -> &CheckpointPack {
89        &self.checkpoint
90    }
91
92    pub async fn open_device(device: Arc<dyn Device>) -> Result<Self, Error> {
93        let (superblock, checkpoints) =
94            match Self::try_from_superblock(device.as_ref(), SUPERBLOCK_OFFSET).await {
95                Ok(x) => x,
96                Err(e) => Self::try_from_superblock(device.as_ref(), SUPERBLOCK_OFFSET * 2)
97                    .await
98                    .map_err(|_| e)?,
99            };
100
101        let mut last_error = anyhow!("No checkpoints found");
102
103        for (checkpoint, cp_start_block) in checkpoints {
104            let mut this = Self {
105                device: device.clone(),
106                superblock,
107                checkpoint,
108                cp_start_block,
109                nat: None,
110                keys: HashMap::with_capacity(16),
111                cache: BlockCache::new(1024, BLOCK_SIZE),
112            };
113
114            match this.read_nat_journal().await {
115                Ok(nat_journal) => {
116                    this.nat = Some(Nat::new(
117                        this.superblock.nat_blkaddr,
118                        this.checkpoint.nat_bitmap.clone(),
119                        nat_journal,
120                    ));
121                    return Ok(this);
122                }
123                Err(e) => {
124                    let ver = this.checkpoint.header.checkpoint_ver;
125                    log::warn!(
126                        "Failed to initialize from checkpoint (Ver {} at {}): {}. Trying next.",
127                        ver,
128                        cp_start_block,
129                        e
130                    );
131                    last_error = e;
132                    // Continue loop to try next checkpoint
133                }
134            }
135        }
136
137        Err(last_error)
138    }
139
140    async fn try_from_superblock(
141        device: &dyn Device,
142        superblock_offset: u64,
143    ) -> Result<(SuperBlock, Vec<(CheckpointPack, u32)>), Error> {
144        let superblock = SuperBlock::read_from_device(device, superblock_offset).await?;
145        let checkpoint_addr = superblock.cp_blkaddr;
146        let checkpoint_a_offset = BLOCK_SIZE as u64 * checkpoint_addr as u64;
147        let checkpoint_b_offset = checkpoint_a_offset + SEGMENT_SIZE as u64;
148
149        let mut checkpoints = Vec::new();
150
151        // Read both checkpoints and collect valid ones with their block addresses
152        if let Ok(cp) = CheckpointPack::read_from_device(device, checkpoint_a_offset).await {
153            checkpoints.push((cp, checkpoint_addr));
154        }
155        if let Ok(cp) = CheckpointPack::read_from_device(device, checkpoint_b_offset).await {
156            checkpoints.push((cp, checkpoint_addr + BLOCKS_PER_SEGMENT as u32));
157        }
158
159        if checkpoints.is_empty() {
160            bail!("Failed to read any valid checkpoint");
161        }
162
163        // Sort by version descending (newest first)
164        checkpoints.sort_by(|(a, _), (b, _)| {
165            let va = a.header.checkpoint_ver;
166            let vb = b.header.checkpoint_ver;
167            vb.cmp(&va)
168        });
169
170        // Min metadata segment count is 1 superblock, 1 ssa, (ckpt + sit + nat) * 2
171        const MIN_METADATA_SEGMENT_COUNT: u32 = 8;
172
173        // Use newest for validation
174        let first_cp = &checkpoints[0].0;
175
176        // Make sure the metadata fits on the device
177        let metadata_segment_count = superblock.segment_count_sit
178            + superblock.segment_count_nat
179            + first_cp.header.rsvd_segment_count
180            + superblock.segment_count_ssa
181            + superblock.segment_count_ckpt;
182        ensure!(
183            metadata_segment_count <= superblock.segment_count
184                && metadata_segment_count >= MIN_METADATA_SEGMENT_COUNT,
185            "Bad segment counts in checkpoint"
186        );
187        Ok((superblock, checkpoints))
188    }
189
190    /// Returns the block address that the checkpoint starts at.
191    pub fn checkpoint_start_addr(&self) -> u32 {
192        self.cp_start_block
193    }
194
195    fn nat(&self) -> &Nat {
196        self.nat.as_ref().unwrap()
197    }
198    /// Returns the absolute block address of the summary block (default or compact).
199    /// handles CP_ORPHAN_PRESENT_FLAG for compact summaries.
200    pub fn summary_block_addr(&self) -> u32 {
201        let mut offset = self.checkpoint.header.cp_pack_start_sum;
202        if self.checkpoint.header.ckpt_flags & CP_ORPHAN_PRESENT_FLAG != 0 {
203            // If orphans are present, they occupy the block at `cp_pack_start_sum`.
204            // The actual summary block follows it.
205            offset += 1;
206        }
207        self.checkpoint_start_addr() + offset
208    }
209
210    async fn read_nat_journal(&mut self) -> Result<HashMap<u32, RawNatEntry>, Error> {
211        if self.checkpoint.header.ckpt_flags & CKPT_FLAG_COMPACT_SUMMARY != 0 {
212            // The "compact summary" feature packs NAT/SIT/summary into one block.
213            // The NAT journal entries come first.
214            let summary_addr = self.summary_block_addr();
215            let block = self.read_raw_block(summary_addr).await?;
216            let n_nats = u16::read_from_bytes(&block.as_slice()[..2]).unwrap();
217            let nat_journal = NatJournal::read_from_bytes(
218                &block.as_slice()[2..2 + std::mem::size_of::<NatJournal>()],
219            )
220            .unwrap();
221            ensure!(
222                (n_nats as usize) <= nat_journal.entries.len(),
223                "n_nats {} larger than block size {}",
224                n_nats,
225                nat_journal.entries.len()
226            );
227            Ok(HashMap::from_iter(
228                nat_journal.entries[..n_nats as usize].into_iter().map(|e| (e.ino, e.entry)),
229            ))
230        } else {
231            // Read the default summary block location from the "hot data" segment.
232            // If orphans are present, `summary_block_addr` automatically skips the orphan block.
233            let summary_addr = self.summary_block_addr();
234            let block = self.read_raw_block(summary_addr).await?;
235
236            let summary = SummaryBlock::read_from_bytes(block.as_slice())
237                .map_err(|_| anyhow!("Failed to parse SummaryBlock"))?;
238            ensure!(summary.footer.entry_type == 0u8, "sum_type != 0 in summary footer");
239            let actual_checksum = f2fs_crc32(F2FS_MAGIC, &block.as_slice()[..BLOCK_SIZE - 4]);
240            let expected_checksum = summary.footer.check_sum;
241            ensure!(actual_checksum == expected_checksum, "Summary block has invalid checksum");
242            let mut out = HashMap::new();
243            for i in 0..summary.n_nats as usize {
244                out.insert(
245                    summary.nat_journal.entries[i].ino,
246                    summary.nat_journal.entries[i].entry,
247                );
248            }
249            Ok(out)
250        }
251    }
252
253    pub fn root_ino(&self) -> u32 {
254        self.superblock.root_ino
255    }
256
257    /// Gives the maximum addressable inode. This can be used to ensure we don't have namespace
258    /// collisions when building hybrid images.
259    pub fn max_ino(&self) -> u32 {
260        (self.checkpoint.nat_bitmap.len() * 8) as u32
261    }
262
263    /// Registers a new main key.
264    /// This 'unlocks' any files using this key.
265    pub fn add_key(&mut self, main_key: &[u8; 64]) -> [u8; 16] {
266        let identifier = fscrypt::main_key_to_identifier(main_key);
267        println!("Adding key with identifier {}", hex::encode(identifier));
268        self.keys.insert(identifier.clone(), main_key.clone());
269        identifier
270    }
271
272    /// Read an inode for a directory and return entries.
273    pub async fn readdir(&self, ino: u32) -> Result<Vec<DirEntry>, Error> {
274        let inode = Inode::try_load(self, ino).await?;
275        let decryptor = self.get_decryptor_for_inode(&inode);
276        let mode = inode.header.mode;
277        let advise_flags = inode.header.advise_flags;
278        let flags = inode.header.flags;
279        ensure!(mode.contains(inode::Mode::Directory), "not a directory");
280        if let Some(entries) = inode.get_inline_dir_entries(
281            advise_flags.contains(inode::AdviseFlags::Encrypted),
282            flags.contains(inode::Flags::Casefold),
283            &decryptor,
284        )? {
285            Ok(entries)
286        } else {
287            let mut entries = Vec::new();
288
289            // Entries are stored in a series of increasingly larger hash tables.
290            // The number of these that exist are based on inode.dir_depth.
291            // Thankfully, we don't need to worry about this as the total number of blocks is
292            // bound to inode.header.size and we can just skip NULL blocks.
293            for mut extent in inode.data_blocks() {
294                for _ in 0..extent.length {
295                    let dentry_block = DentryBlock::read_from_bytes(
296                        self.read_raw_block(extent.physical_block_num).await?.as_slice(),
297                    )
298                    .unwrap();
299                    entries.append(&mut dentry_block.get_entries(
300                        ino,
301                        advise_flags.contains(inode::AdviseFlags::Encrypted),
302                        flags.contains(inode::Flags::Casefold),
303                        &decryptor,
304                    )?);
305                    extent.physical_block_num += 1;
306                }
307            }
308            Ok(entries)
309        }
310    }
311
312    /// Read an inode and associated blocks from disk.
313    pub async fn read_inode(&self, ino: u32) -> Result<Box<Inode>, Error> {
314        Inode::try_load(self, ino).await
315    }
316
317    /// Takes an inode for a symlink and the link as a set of bytes, decrypted if possible.
318    pub fn read_symlink(&self, inode: &Inode) -> Result<Box<[u8]>, Error> {
319        if let Some(inline_data) = inode.inline_data.as_deref() {
320            let mut filename = inline_data.to_vec();
321            if inode.header.advise_flags.contains(inode::AdviseFlags::Encrypted) {
322                // Encrypted symlinks have a 2-byte length prefix.
323                ensure!(filename.len() >= 2, "invalid encrypted symlink");
324                let symlink_len = u16::read_from_bytes(&filename[..2]).unwrap();
325                filename.drain(..2);
326                filename.truncate(symlink_len as usize);
327                ensure!(symlink_len == filename.len() as u16, "invalid encrypted symlink");
328                if let Some(decryptor) = self.get_decryptor_for_inode(inode) {
329                    decryptor.decrypt_filename_data(inode.footer.ino, &mut filename);
330                } else {
331                    // Symlinks don't have a hash code, so we just use 0.
332                    let proxy_filename: String =
333                        fscrypt::proxy_filename::ProxyFilename::new_with_hash_code(0, &filename)
334                            .into();
335                    filename = proxy_filename.as_bytes().to_vec();
336                }
337                // Unfortunately, it seems we still have to remove trailing nulls.
338                // fscrypt + f2fs publishes a file size equal to padded symlink length + 2 bytes.
339                while let Some(0) = filename.last() {
340                    filename.pop();
341                }
342            }
343            Ok(filename.into_boxed_slice())
344        } else {
345            bail!("Not a valid symlink");
346        }
347    }
348
349    /// Reads and returns a data block of a file.
350    /// On success, this will return Some(Buffer) containing the data or None if the file is sparse.
351    pub async fn read_data(
352        &self,
353        inode: &Inode,
354        block_num: u32,
355    ) -> Result<Option<Buffer<'_>>, Error> {
356        let inline_flags = inode.header.inline_flags;
357        ensure!(
358            !inline_flags.contains(crate::InlineFlags::Data),
359            "Can't use read_data() on inline file."
360        );
361        let block_addr = inode.data_block_addr(block_num);
362        if block_addr == NULL_ADDR || block_addr == NEW_ADDR {
363            // Treat as an empty page
364            return Ok(None);
365        }
366        let mut buffer = self.read_raw_block(block_addr).await?;
367        if let Some(decryptor) = self.get_decryptor_for_inode(inode) {
368            decryptor.decrypt_data(inode.footer.ino, block_num, buffer.as_mut().as_mut_slice());
369        }
370        Ok(Some(buffer))
371    }
372}
373
374#[async_trait]
375impl Reader for F2fsReader {
376    /// `block_addr` is the physical block offset on the device.
377    async fn read_raw_block(&self, block_addr: u32) -> Result<Buffer<'_>, Error> {
378        if let Some(block) = self.cache.get_buffer(block_addr, self.device.deref()).await {
379            return Ok(block);
380        }
381
382        const READAHEAD: u64 = 16;
383        let end = std::cmp::min(block_addr as u64 + READAHEAD, self.device.block_count());
384        let count = end.saturating_sub(block_addr as u64).max(1) as usize;
385
386        let mut buffer = self.device.allocate_buffer(count * BLOCK_SIZE).await;
387        self.device
388            .read(block_addr as u64 * BLOCK_SIZE as u64, buffer.as_mut())
389            .await
390            .map_err(|_| anyhow!("device read failed"))?;
391
392        for i in 0..count {
393            let slice = &buffer.as_slice()[i * BLOCK_SIZE..(i + 1) * BLOCK_SIZE];
394            self.cache.insert(block_addr + i as u32, slice.to_vec());
395        }
396        Ok(self.cache.get_buffer(block_addr, self.device.deref()).await.unwrap())
397    }
398
399    async fn read_node(&self, nid: u32) -> Result<Buffer<'_>, Error> {
400        let nat_entry = self.get_nat_entry(nid).await?;
401        self.read_raw_block(nat_entry.block_addr).await
402    }
403
404    fn get_key(&self, identifier: &[u8; 16]) -> Option<&[u8; 64]> {
405        self.keys.get(identifier)
406    }
407
408    fn fs_uuid(&self) -> &[u8; 16] {
409        &self.superblock.uuid
410    }
411
412    async fn get_nat_entry(&self, nid: u32) -> Result<RawNatEntry, Error> {
413        if let Some(entry) = self.nat().nat_journal.get(&nid) {
414            return Ok(*entry);
415        }
416        let nat_block_addr = self.nat().get_nat_block_for_entry(nid)?;
417        let offset = self.nat().get_nat_block_offset_for_entry(nid);
418        let block = self.read_raw_block(nat_block_addr).await?;
419        Ok(RawNatEntry::read_from_bytes(
420            &block.as_slice()[offset..offset + std::mem::size_of::<RawNatEntry>()],
421        )
422        .unwrap())
423    }
424}
425
426#[cfg(test)]
427mod test {
428    use super::*;
429    use crate::dir::FileType;
430    use crate::xattr;
431    use std::collections::HashSet;
432    use std::path::PathBuf;
433    use std::sync::Arc;
434
435    use storage_device::fake_device::FakeDevice;
436
437    fn open_test_image(path: &str) -> FakeDevice {
438        let path = std::path::PathBuf::from(path);
439        println!("path is {path:?}");
440        FakeDevice::from_image(
441            zstd::Decoder::new(std::fs::File::open(&path).expect("open image"))
442                .expect("decompress image"),
443            BLOCK_SIZE as u32,
444        )
445        .expect("open image")
446    }
447
448    #[fuchsia::test]
449    async fn test_open_fs() {
450        let device = open_test_image("/pkg/testdata/f2fs.img.zst");
451
452        let f2fs = F2fsReader::open_device(Arc::new(device)).await.expect("open ok");
453        // Root inode is a known constant.
454        assert_eq!(f2fs.root_ino(), 3);
455        let superblock = &f2fs.superblock;
456        let major_ver = superblock.major_ver;
457        let minor_ver = superblock.minor_ver;
458        assert_eq!(major_ver, 1);
459        assert_eq!(minor_ver, 16);
460        assert_eq!(superblock.get_total_size(), 256 << 20);
461        assert_eq!(superblock.get_volume_name().expect("get volume name"), "testimage");
462    }
463
464    // Helper method to walk paths.
465    async fn resolve_inode_path(f2fs: &F2fsReader, path: &str) -> Result<u32, Error> {
466        let path = PathBuf::from(path.strip_prefix("/").unwrap());
467        let mut ino = f2fs.root_ino();
468        for filename in &path {
469            let entries = f2fs.readdir(ino).await?;
470            if let Some(entry) = entries.iter().filter(|e| *e.filename == *filename).next() {
471                ino = entry.ino;
472            } else {
473                bail!("Not found.");
474            }
475        }
476        Ok(ino)
477    }
478
479    #[fuchsia::test]
480    async fn test_basic_dirs() {
481        let device = open_test_image("/pkg/testdata/f2fs.img.zst");
482
483        let f2fs = F2fsReader::open_device(Arc::new(device)).await.expect("open ok");
484        let root_ino = f2fs.root_ino();
485        let root_entries = f2fs.readdir(root_ino).await.expect("readdir");
486        assert_eq!(root_entries.len(), 7);
487        assert_eq!(root_entries[0].filename, "a");
488        assert_eq!(root_entries[0].file_type, FileType::Directory);
489        assert_eq!(root_entries[1].filename, "large_dir");
490        assert_eq!(root_entries[2].filename, "large_dir2");
491        assert_eq!(root_entries[3].filename, "sparse.dat");
492        assert_eq!(root_entries[4].filename, "verity");
493        assert_eq!(root_entries[5].filename, "fscrypt");
494        assert_eq!(root_entries[6].filename, "large_zero");
495
496        let inlined_file_ino =
497            resolve_inode_path(&f2fs, "/a/b/c/inlined").await.expect("resolve inlined");
498        let inode = Inode::try_load(&f2fs, inlined_file_ino).await.expect("load inode");
499        let block_size = inode.header.block_size;
500        let size = inode.header.size;
501        assert_eq!(block_size, 1);
502        assert_eq!(size, 12);
503        assert_eq!(inode.inline_data.unwrap().as_ref(), "inline_data\n".as_bytes());
504
505        const REG_FILE_SIZE: u64 = 8 * BLOCK_SIZE as u64 + 8;
506        const REG_FILE_BLOCKS: u64 = 9 + 1;
507        let regular_file_ino =
508            resolve_inode_path(&f2fs, "/a/b/c/regular").await.expect("resolve regular");
509        let inode = Inode::try_load(&f2fs, regular_file_ino).await.expect("load inode");
510        let block_size = inode.header.block_size;
511        let size = inode.header.size;
512        assert_eq!(block_size, REG_FILE_BLOCKS);
513        assert_eq!(size, REG_FILE_SIZE);
514        assert!(inode.inline_data.is_none());
515        for i in 0..8 {
516            assert_eq!(
517                f2fs.read_data(&inode, i).await.expect("read data").unwrap().as_slice(),
518                &[0u8; BLOCK_SIZE]
519            );
520        }
521        assert_eq!(
522            &f2fs.read_data(&inode, 8).await.expect("read data").unwrap().as_slice()[..9],
523            b"01234567\0"
524        );
525
526        let symlink_ino =
527            resolve_inode_path(&f2fs, "/a/b/c/symlink").await.expect("resolve symlink");
528        let inode = Inode::try_load(&f2fs, symlink_ino).await.expect("load inode");
529        assert_eq!(f2fs.read_symlink(&inode).expect("read_symlink").as_ref(), b"regular");
530
531        let hardlink_ino =
532            resolve_inode_path(&f2fs, "/a/b/c/hardlink").await.expect("resolve hardlink");
533        let inode = Inode::try_load(&f2fs, hardlink_ino).await.expect("load inode");
534        let block_size = inode.header.block_size;
535        let size = inode.header.size;
536        assert_eq!(block_size, REG_FILE_BLOCKS);
537        assert_eq!(size, REG_FILE_SIZE);
538
539        let chowned_ino =
540            resolve_inode_path(&f2fs, "/a/b/c/chowned").await.expect("resolve chowned");
541        let inode = Inode::try_load(&f2fs, chowned_ino).await.expect("load inode");
542        let uid = inode.header.uid;
543        let gid = inode.header.gid;
544        assert_eq!(uid, 999);
545        assert_eq!(gid, 999);
546
547        let large_dir = resolve_inode_path(&f2fs, "/large_dir").await.expect("resolve large_dir");
548        assert_eq!(f2fs.readdir(large_dir).await.expect("readdir").len(), 2001);
549
550        let large_dir2 = resolve_inode_path(&f2fs, "/large_dir2").await.expect("resolve large_dir");
551        assert_eq!(f2fs.readdir(large_dir2).await.expect("readdir").len(), 1);
552
553        let sparse_dat =
554            resolve_inode_path(&f2fs, "/sparse.dat").await.expect("resolve sparse.dat");
555        let inode = Inode::try_load(&f2fs, sparse_dat).await.expect("load inode");
556        let data_blocks: Vec<_> = inode.data_blocks().into_iter().collect();
557        assert_eq!(data_blocks.len(), 6);
558        assert_eq!(data_blocks[0].logical_block_num, 0);
559        assert_eq!(data_blocks[0].length, 1);
560        // Raw read of block.
561        let block =
562            f2fs.read_raw_block(data_blocks[0].physical_block_num).await.expect("read sparse");
563        assert_eq!(&block.as_slice()[..3], b"foo");
564        // The following chain of blocks are designed to land in each of the self.nids[] ranges.
565        assert_eq!(data_blocks[1].logical_block_num, 923);
566        assert_eq!(data_blocks[1].length, 1);
567        assert_eq!(data_blocks[2].logical_block_num, 1941);
568        assert_eq!(data_blocks[2].length, 1);
569        assert_eq!(data_blocks[3].logical_block_num, 2959);
570        assert_eq!(data_blocks[3].length, 1);
571        assert_eq!(data_blocks[4].logical_block_num, 1039283);
572        assert_eq!(data_blocks[4].length, 1);
573        assert_eq!(data_blocks[5].logical_block_num, 104671683);
574        assert_eq!(data_blocks[5].length, 2);
575        let block =
576            f2fs.read_raw_block(data_blocks[5].physical_block_num).await.expect("read sparse");
577        assert_eq!(block.as_slice(), &[0; BLOCK_SIZE]);
578        // Exercise helper method to read block.
579        assert_eq!(
580            &f2fs.read_data(&inode, 104671684).await.expect("read data block").unwrap().as_slice()
581                [..3],
582            b"bar"
583        );
584        // Exercise helper method on zero page. Expect to get back 'None'.
585        assert!(f2fs.read_data(&inode, 104671684 - 10).await.expect("read data block").is_none());
586    }
587
588    #[fuchsia::test]
589    async fn test_xattr() {
590        let device = open_test_image("/pkg/testdata/f2fs.img.zst");
591
592        let f2fs = F2fsReader::open_device(Arc::new(device)).await.expect("open ok");
593        let sparse_dat =
594            resolve_inode_path(&f2fs, "/sparse.dat").await.expect("resolve sparse.dat");
595        let inode = Inode::try_load(&f2fs, sparse_dat).await.expect("load inode");
596        assert_eq!(
597            inode.xattr,
598            vec![
599                xattr::XattrEntry {
600                    index: xattr::Index::User,
601                    name: Box::new(b"a".to_owned()),
602                    value: Box::new(b"value".to_owned())
603                },
604                xattr::XattrEntry {
605                    index: xattr::Index::User,
606                    name: Box::new(b"c".to_owned()),
607                    value: Box::new(b"value".to_owned())
608                },
609                xattr::XattrEntry {
610                    index: xattr::Index::User,
611                    name: Box::new(b"padding_test_1".to_owned()),
612                    value: Box::new(b"v".to_owned())
613                },
614                xattr::XattrEntry {
615                    index: xattr::Index::User,
616                    name: Box::new(b"padding_test_2".to_owned()),
617                    value: Box::new(b"va".to_owned())
618                },
619                xattr::XattrEntry {
620                    index: xattr::Index::User,
621                    name: Box::new(b"padding_test_3".to_owned()),
622                    value: Box::new(b"val".to_owned())
623                },
624                xattr::XattrEntry {
625                    index: xattr::Index::User,
626                    name: Box::new(b"padding_test_4".to_owned()),
627                    value: Box::new(b"valu".to_owned())
628                },
629                xattr::XattrEntry {
630                    index: xattr::Index::User,
631                    name: Box::new(b"padding_test_5".to_owned()),
632                    value: Box::new(b"value".to_owned())
633                },
634            ]
635        );
636    }
637
638    #[fuchsia::test]
639    async fn test_fsverity() {
640        let device = open_test_image("/pkg/testdata/f2fs.img.zst");
641        let mut f2fs = F2fsReader::open_device(Arc::new(device)).await.expect("open ok");
642        f2fs.add_key(&[0u8; 64]);
643        let verity_files = vec![
644            "/verity/inlined",
645            "/verity/regular",
646            "/verity/merkle_layers.dat",
647            "/fscrypt/a/b/regular",
648        ];
649        for file_path in verity_files {
650            let file = resolve_inode_path(&f2fs, file_path).await.expect("resolve file");
651            let inode = Inode::try_load(&f2fs, file).await.expect("load inode");
652            assert!(inode.header.advise_flags.contains(inode::AdviseFlags::Verity));
653        }
654        // Verify other files aren't marked for verity.
655        let file = resolve_inode_path(&f2fs, "/a/b/c/regular").await.expect("resolve file");
656        let inode = Inode::try_load(&f2fs, file).await.expect("load inode");
657        assert!(!inode.header.advise_flags.contains(inode::AdviseFlags::Verity));
658        // TODO(https://fxbug.dev/399727919): Handle the verity descriptor and merkle tree parsing.
659    }
660
661    #[fuchsia::test]
662    async fn test_fbe() {
663        // Note: The synthetic filenames below are based on the nonce generated at file/directory
664        // creation time. This will differ each time a new image is generated.
665        // They can be extracted with a simple 'ls -l' by mounting the generated image. i.e.
666        //   $ zstd -d testdata/f2fs.img.st
667        //   $ sudo mount testdata/f2fs.img /mnt
668        //   $ ls /mnt/fscrypt -lR
669
670        // /fscrypt/<a>/<b>/<symlink>
671        let str_a = "2ll82QAAAADywluz1Ule7OVNBxUfa5Mw";
672        let str_b = "sttckQAAAADLBOCVVgjrZ-CXNkj5E6Cr";
673        let str_symlink = "zHAtQgAAAACRNPQYvCKuQo5F8rQUORg3";
674        let bytes_symlink_content = b"AAAAAAAAAADUsYZ_qNiiouF7e40xm65S";
675
676        let mut expected : HashSet<_> = [ // files in fscrypt/ dir.
677            "2ll82QAAAADywluz1Ule7OVNBxUfa5Mw",
678            "65OSUQAAAADqOiZJcQ1El2dpVdYMy84l",
679            "7vcnbgAAAAAOWdQfi4wK46uRGQBD0YSy",
680            "9Gsv9QAAAADjTeJ_9WdCxZMVTiSWhsWR",
681            "FAqGXAAAAAD1jOLXaZN-o8X9PoS67GI7",
682            "Rq5qZAAAAAA3y2lvAqesYDnVJWMklWnj",
683            "S93sdgAAAABo-YmXNPKtv4wxQCcUslTu",
684            "VP8QBwAAAAATw6Ozex0N2gMYrnDsB2aH",
685            "xUNjwgAAAADB0pEx5ovwx-AS02L0d1j7VMBRXzM4YnBri2pbasOqbFLhtegXr9kDGNcYd_hyk2mOkQIqu8hk7eARlFl-bq1yLhikhIT9HVC3FMrI7vQ-ewncEjXLDP3KK6RtH3r34S89AlzJZ4DVfXrr_Q5N5mANBbGTzeO70aJHL0Ms-MgkKwjHcbIxXLwcjE2B-mssLAvXam58pSD-aazxS_J2hrxOHGoUYiVJ-rXHozmKxBdWAO6OUW65",
686        ].into_iter().collect();
687
688        let device = open_test_image("/pkg/testdata/f2fs.img.zst");
689
690        let mut f2fs = F2fsReader::open_device(Arc::new(device)).await.expect("open ok");
691
692        // First without the key...
693        // (The filenames below have been extracted from the generated image by
694        // mounting it and manually inspecting.)
695        resolve_inode_path(&f2fs, "/fscrypt/a/b/regular")
696            .await
697            .expect_err("resolve fscrypt regular");
698        let fscrypt_dir_ino =
699            resolve_inode_path(&f2fs, "/fscrypt").await.expect("resolve encrypted dir");
700        let entries = f2fs.readdir(fscrypt_dir_ino).await.expect("readdir");
701        println!("entries {entries:?}");
702
703        for entry in entries {
704            assert!(expected.remove(entry.filename.as_str()), "unexpected entry {entry:?}");
705        }
706        assert!(expected.is_empty());
707
708        resolve_inode_path(&f2fs, &format!("/fscrypt/{str_a}"))
709            .await
710            .expect("resolve encrypted dir");
711        let enc_symlink_ino =
712            resolve_inode_path(&f2fs, &format!("/fscrypt/{str_a}/{str_b}/{str_symlink}"))
713                .await
714                .expect("resolve encrypted symlink");
715        let symlink_inode =
716            Inode::try_load(&f2fs, enc_symlink_ino).await.expect("load symlink inode");
717        assert_eq!(
718            &*f2fs.read_symlink(&symlink_inode).expect("read_symlink"),
719            bytes_symlink_content
720        );
721
722        // ...now try with the key
723        f2fs.add_key(&[0u8; 64]);
724        resolve_inode_path(&f2fs, "/fscrypt/a/b/regular").await.expect("resolve fscrypt regular");
725        let inlined_ino = resolve_inode_path(&f2fs, "/fscrypt/a/b/inlined")
726            .await
727            .expect("resolve fscrypt inlined");
728        let short_file = Inode::try_load(&f2fs, inlined_ino).await.expect("load symlink inode");
729        assert!(
730            !short_file.header.inline_flags.contains(inode::InlineFlags::Data),
731            "encrypted files shouldn't be inlined"
732        );
733        let short_data =
734            f2fs.read_data(&short_file, 0).await.expect("read_data").expect("non-empty page");
735        assert_eq!(
736            &short_data.as_slice()[..short_file.header.size as usize],
737            b"test45678abcdef_12345678"
738        );
739
740        let symlink_ino = resolve_inode_path(&f2fs, "/fscrypt/a/b/symlink")
741            .await
742            .expect("resolve fscrypt symlink");
743        assert_eq!(symlink_ino, enc_symlink_ino);
744
745        let symlink_inode = Inode::try_load(&f2fs, symlink_ino).await.expect("load symlink inode");
746        let symlink = f2fs.read_symlink(&symlink_inode).expect("read_symlink");
747        assert_eq!(*symlink, *b"inlined");
748    }
749
750    #[fuchsia::test]
751    async fn test_summary_block_addr() {
752        let device = open_test_image("/pkg/testdata/f2fs.img.zst");
753        let mut f2fs = F2fsReader::open_device(Arc::new(device)).await.expect("open ok");
754
755        // Case 1: No Orphan Flag
756        f2fs.checkpoint.header.ckpt_flags = 0; // Clear all
757        f2fs.checkpoint.header.cp_pack_start_sum = 100;
758        let base = f2fs.checkpoint_start_addr();
759        assert_eq!(f2fs.summary_block_addr(), base + 100);
760
761        // Case 2: With Orphan Flag
762        f2fs.checkpoint.header.ckpt_flags = CP_ORPHAN_PRESENT_FLAG;
763        assert_eq!(f2fs.summary_block_addr(), base + 100 + 1);
764
765        // Case 3: Compact Summary + Orphan (Real crash case)
766        f2fs.checkpoint.header.ckpt_flags = CP_ORPHAN_PRESENT_FLAG | CKPT_FLAG_COMPACT_SUMMARY;
767        assert_eq!(f2fs.summary_block_addr(), base + 100 + 1);
768    }
769}
f2fs_reader/reader.rs

f2fs_reader/
reader.rs
