Method recover_record

nodedb-wal/src/double_write.rs:355–417

Try to recover a WAL record by LSN from the double-write buffer. Scans **all** DWB_CAPACITY slots for a record matching the given LSN with valid CRC. We scan every slot rather than relying on `count` or `write_pos` because the header itself may be stale or corrupted after a crash. Each slot is self-describing: the record's own CRC validates whether the slot contains usable data.

(&mut self, target_lsn: u64)

    /// a crash. Each slot is self-describing: the record's own CRC validates
    /// whether the slot contains usable data.
    pub fn recover_record(&mut self, target_lsn: u64) -> Result<Option<WalRecord>> {
        #[cfg(target_arch = "wasm32")]
        {
            let _ = target_lsn;
            return Ok(None);
        }

        #[cfg(not(target_arch = "wasm32"))]
        {
            use std::os::unix::io::AsRawFd as _;

            // Under O_DIRECT, reads must also use aligned buffers and aligned
            // lengths. Read one full aligned slot at a time, then parse.
            let mut slot = AlignedBuf::new(DWB_SLOT_STRIDE, DEFAULT_ALIGNMENT)?;

            for i in 0..DWB_CAPACITY as u32 {
                let offset = slot_offset(i);
                // SAFETY: slot.as_mut_ptr is valid for `capacity()` bytes.
                let read = unsafe {
                    libc::pread(
                        self.file.as_raw_fd(),
                        slot.as_mut_ptr() as *mut libc::c_void,
                        DWB_SLOT_STRIDE,
                        offset as libc::off_t,
                    )
                };
                if read <= 0 {
                    continue;
                }
                // SAFETY: the kernel populated `read` bytes starting at the buffer.
                let bytes: &[u8] =
                    unsafe { std::slice::from_raw_parts(slot.as_ptr(), read as usize) };
                if bytes.len() < 4 + HEADER_SIZE {
                    continue;
                }

                let mut arr4 = [0u8; 4];
                arr4.copy_from_slice(&bytes[0..4]);
                let total_size = u32::from_le_bytes(arr4) as usize;
                if !(HEADER_SIZE..=DWB_SLOT_PAYLOAD_MAX).contains(&total_size)
                    || bytes.len() < 4 + total_size
                {
                    continue;
                }

                let mut header_buf = [0u8; HEADER_SIZE];
                header_buf.copy_from_slice(&bytes[4..4 + HEADER_SIZE]);
                let header = RecordHeader::from_bytes(&header_buf);
                if header.magic != WAL_MAGIC || header.lsn != target_lsn {
                    continue;
                }

                let payload_len = total_size - HEADER_SIZE;
                let payload = bytes[4 + HEADER_SIZE..4 + HEADER_SIZE + payload_len].to_vec();
                let record = WalRecord { header, payload };
                if record.verify_checksum().is_ok() {
                    return Ok(Some(record));
                }