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()?;
    }
}

这将导致恐慌：

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

结果文件显示为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不能反映这些更改。我希望标准输出看起来像这样：

foobar
foobarsomestring
foobarsomestringsomestring
...

但是我知道了

foobar
foobar
foobar
...

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

Answer 1

首先，根据我的理解，我敦促您高度怀疑该板条箱。它允许您在安全的Rust中执行您应该不执行的操作。

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

将映射文件视为不可变的字节片（&[u8]）永远是无效的，因为它可能被突变了！
将映射文件视为可变的字节片（&mut [u8]永远是无效的，因为可变的引用意味着可以更改该数据的专有所有者，但是您没有。

documentation for that crate覆盖了所有这些问题，并且没有讨论如何安全地使用少数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：< / p>

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(())
}

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

我不会在任何对数据正确无误的事情上使用此代码。

另请参阅：

如何使用memmap板条箱附加到文件支持的mmap？

`MmapMut`

直接附加到支持文件

1 个答案: