分配数据以传递给 FFI 调用的正确方法是什么? [英] What is the right way to allocate data to pass to an FFI call?

问题描述

在 讨论/学习从 Rust 调用 Windows-API 的 FFI 的正确方法，我进一步研究了它，并想再次检查我的理解.

After discussing/learning about the correct way to call a FFI of the Windows-API from Rust, I played with it a little bit further and would like to double-check my understanding.

我有一个被调用两次的 Windows API.在第一次调用中，它返回实际输出参数所需的缓冲区大小.然后，使用足够大小的缓冲区再次调用它.我目前使用 Vec 作为这个缓冲区的数据类型(见下面的例子).

I have a Windows API that is called twice. In the first call, it returns the size of the buffer that it will need for its actual out parameter. Then, it is called a second time with a buffer of sufficient size. I'm currently using a Vec as a datatype for this buffer (see example below).

代码有效，但我想知道这是否是正确的方法，或者使用像 alloc::heap::allocate 这样的函数来直接保留一些内存和然后使用 transmute 将结果从 FFI 转换回来.同样，我的代码有效，但我试图在幕后查看一下.

The code works but I'm wondering whether this is right way to do it or whether it would be better to utilize a function like alloc::heap::allocate to directly reserve some memory and then to use transmute to convert the result from the FFI back. Again, my code works but I'm trying to look a little bit behind the scenes.

extern crate advapi32;
extern crate winapi;
extern crate widestring;
use widestring::WideCString;
use std::io::Error as IOError;
use winapi::winnt;

fn main() {
    let mut lp_buffer: Vec<winnt::WCHAR> = Vec::new();
    let mut pcb_buffer: winapi::DWORD = 0;

    let rtrn_bool = unsafe {
        advapi32::GetUserNameW(lp_buffer.as_mut_ptr(),
                               &mut pcb_buffer )
    };

    if rtrn_bool == 0 {

        match IOError::last_os_error().raw_os_error() {
            Some(122) => {
                // Resizing the buffers sizes so that the data fits in after 2nd 
                lp_buffer.resize(pcb_buffer as usize, 0 as winnt::WCHAR);
            } // This error is to be expected
            Some(e) => panic!("Unknown OS error {}", e),
            None => panic!("That should not happen"),
        }
    }


    let rtrn_bool2 = unsafe {
        advapi32::GetUserNameW(lp_buffer.as_mut_ptr(), 
                               &mut pcb_buffer )
    };

    if rtrn_bool2 == 0 {
        match IOError::last_os_error().raw_os_error() {
            Some(e) => panic!("Unknown OS error {}", e),
            None => panic!("That should not happen"),
        }
    }

    let widestr: WideCString = unsafe { WideCString::from_ptr_str(lp_buffer.as_ptr()) };

    println!("The owner of the file is {:?}", widestr.to_string_lossy());
}

依赖:

[dependencies]
advapi32-sys = "0.2"
winapi = "0.2"
widestring = "*"

推荐答案

理想情况下，您应该使用 std::alloc::alloc 因为你可以在 layout 中指定所需的对齐方式:

Ideally you would use std::alloc::alloc because you can then specify the desired alignment as part of the layout:

pub unsafe fn alloc(layout: Layout) -> *mut u8

主要的缺点是你需要知道对齐，即使你释放了分配.

The main downside is that you need to know the alignment, even when you free the allocation.

使用 Vec 作为一种简单的分配机制是常见的做法，但在使用它时需要小心.

It's common practice to use a Vec as an easy allocation mechanism, but you need to be careful when using it as such.

1. 确保您的单位是正确的——长度"参数是项的数量还是字节的数量?
2. 如果你将 Vec 分解成组成部分，你需要

1. Make sure that your units are correct — is the "length" parameter the number of items or the number of bytes?
2. If you dissolve the Vec into component parts, you need to

1. 跟踪长度和容量.有些人使用 shr​​ink_to_fit 以确保这两个值相同.
2. 避免跨流 - 内存由 Rust 分配，必须由 Rust 释放.将其转换回要删除的 Vec.

1. track the length and the capacity. Some people use shrink_to_fit to ensure those two values are the same.
2. Avoid crossing the streams - that memory was allocated by Rust and must be freed by Rust. Convert it back into a Vec to be dropped.

注意一个空的 Vec 确实没有有一个 NULL 指针！:

Beware that an empty Vec does not have a NULL pointer!:

fn main() {
    let v: Vec<u8> = Vec::new();
    println!("{:p}", v.as_ptr());
    // => 0x1
}

<小时>

对于您的具体情况，我可能建议使用 Vec 的 capacity 而不是自己跟踪第二个变量.你会注意到你在第一次调用后忘记更新 pcb_buffer，所以我很确定代码总是会失败.这很烦人，因为它需要是一个可变引用，所以你不能完全摆脱它.

---

For your specific case, I might suggest using the capacity of the Vec instead of tracking the second variable yourself. You'll note that you forgot to update pcb_buffer after the first call, so I'm pretty sure that the code will always fail. It's annoying because it needs to be a mutable reference so you can't completely get away from it.

此外，您可以只reserve 空间.

Additionally, instead of extending the Vec, you could just reserve space.

也不能保证第一次调用所需的大小与第二次调用所需的大小相同.你可以做某种循环，但是你必须担心会发生无限循环.

There's also no guarantee that the size required during the first call will be the same as the size required during the second call. You could do some kind of loop, but then you have to worry about an infinite loop happening.

这篇关于分配数据以传递给 FFI 调用的正确方法是什么?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！