如何使用 memmap crate 附加到文件支持的 mmap？

Question

我有一个foo.txt包含内容的文件

foobar

我想连续追加到该文件并有权访问修改后的文件。

MmapMut

我尝试的第一件事是直接改变 mmap：

use memmap;
use std::fs;
use std::io::prelude::*;

fn main() -> Result<(), Box<std::error::Error>> {
    let backing_file = fs::OpenOptions::new()
        .read(true)
        .append(true)
        .create(true)
        .write(true)
        .open("foo.txt")?;

    let mut mmap = unsafe { memmap::MmapMut::map_mut(&backing_file)? };

    loop {
        println!("{}", std::str::from_utf8(&mmap[..])?);
        std::thread::sleep(std::time::Duration::from_secs(5));
        let buf = b"somestring";
        (&mut mmap[..]).write_all(buf)?;
        mmap.flush()?;
    }
}

这会导致恐慌：

use memmap;
use std::fs;
use std::io::prelude::*;

fn main() -> Result<(), Box<std::error::Error>> {
    let backing_file = fs::OpenOptions::new()
        .read(true)
        .append(true)
        .create(true)
        .write(true)
        .open("foo.txt")?;

    let mut mmap = unsafe { memmap::MmapMut::map_mut(&backing_file)? };

    loop {
        println!("{}", std::str::from_utf8(&mmap[..])?);
        std::thread::sleep(std::time::Duration::from_secs(5));
        let buf = b"somestring";
        (&mut mmap[..]).write_all(buf)?;
        mmap.flush()?;
    }
}

结果文件读取somest

直接附加到备份文件

之后，我尝试直接附加到支持文件：

use memmap;
use std::fs;
use std::io::prelude::*;

fn main() -> Result<(), Box<std::error::Error>> {
    let mut backing_file = fs::OpenOptions::new()
        .read(true)
        .append(true)
        .create(true)
        .write(true)
        .open("foo.txt")?;

    let mmap = unsafe { memmap::MmapMut::map_mut(&backing_file)? };

    loop {
        println!("{}", std::str::from_utf8(&mmap[..])?);
        std::thread::sleep(std::time::Duration::from_secs(5));
        let buf = b"somestring";
        backing_file.write_all(buf)?;
        backing_file.flush()?;
    }
}

这不会导致恐慌。该文件将定期更新，但我的 mmap 不反映这些更改。我期望标准输出如下所示：

Error: Custom { kind: WriteZero, error: StringError("failed to write whole buffer") }

但我得到了

use memmap;
use std::fs;
use std::io::prelude::*;

fn main() -> Result<(), Box<std::error::Error>> {
    let mut backing_file = fs::OpenOptions::new()
        .read(true)
        .append(true)
        .create(true)
        .write(true)
        .open("foo.txt")?;

    let mmap = unsafe { memmap::MmapMut::map_mut(&backing_file)? };

    loop {
        println!("{}", std::str::from_utf8(&mmap[..])?);
        std::thread::sleep(std::time::Duration::from_secs(5));
        let buf = b"somestring";
        backing_file.write_all(buf)?;
        backing_file.flush()?;
    }
}

我主要对 Linux 解决方案感兴趣，如果它是平台相关的。

Answer 1

首先，根据我的理解，我建议你对那个箱子保持高度怀疑。它允许你用安全的 Rust 来做你不应该做的事情。

例如，如果您有文件支持的 mmap，则计算机上具有该文件正确权限的任何进程都可以修改它。这意味着：

1. 将映射文件视为不可变的字节片 ( &[u8]) 永远是无效的，因为它可能会发生变化！
2. 将映射文件视为可变字节片 ( &mut [u8]) 永远是无效的，因为可变引用意味着可以更改该数据的独占所有者，但您没有。

该板条箱的文档没有涵盖这些问题，也没有讨论您应该如何unsafe以安全的方式使用少数函数。对我来说，这些迹象表明您可能在代码中引入了未定义的行为，这是一件非常糟糕的事情。

例如：

use memmap;
use std::{fs, io::prelude::*};

fn main() -> Result<(), Box<std::error::Error>> {
    let mut backing_file = fs::OpenOptions::new()
        .read(true)
        .append(true)
        .create(true)
        .write(true)
        .open("foo.txt")?;

    backing_file.write_all(b"initial")?;

    let mut mmap_mut = unsafe { memmap::MmapMut::map_mut(&backing_file)? };
    let mmap_immut = unsafe { memmap::Mmap::map(&backing_file)? };

    // Code after here violates the rules of references, but doesn't use `unsafe`
    let a_str: &str = std::str::from_utf8(&mmap_immut)?;
    println!("{}", a_str); // initial

    mmap_mut[0] = b'x';

    // Look, we just changed an "immutable reference"!
    println!("{}", a_str); // xnitial

    Ok(())
}

由于人们通常不喜欢被告知“不，不要这样做，这是一个坏主意”，因此以下是如何让代码“工作”：直接附加到文件，然后重新创建 mmap：

use memmap;
use std::{fs, io::prelude::*, thread, time::Duration};

fn main() -> Result<(), Box<std::error::Error>> {
    let mut backing_file = fs::OpenOptions::new()
        .read(true)
        .append(true)
        .create(true)
        .write(true)
        .open("foo.txt")?;

    // mmap requires that the initial mapping be non-zero
    backing_file.write_all(b"initial")?;

    for _ in 0..3 {
        let mmap = unsafe { memmap::MmapMut::map_mut(&backing_file)? };

        // I think this line can introduce memory unsafety
        println!("{}", std::str::from_utf8(&mmap[..])?);

        thread::sleep(Duration::from_secs(1));

        backing_file.write_all(b"somestring")?;
    }

    Ok(())
}

您可能希望在此文件中预先分配一块“大”空间，以便您可以打开它并开始写入，而不必重新映射它。

我自己不会将此代码用于任何数据正确性很重要的地方。

也可以看看：

• 附加到经过 Mmap 处理的文件是否安全且跨平台？
• 追加到内存映射文件
• 如何创建和写入内存映射文件？