Как безопасно построить жирные указатели / указатели на DSTs атомов LV2 в Rust? - PullRequest
Новая
       52

Как безопасно построить жирные указатели / указатели на DSTs атомов LV2 в Rust?

0 голосов
/ 03 апреля 2019

Я работаю над интеграцией атомов LV2 для Rust, которые являются динамическими типами (DST) на основе срезов. В общем, атомы создаются хостом или другими плагинами, и мой код получает только тонкий указатель на них. Поэтому мне нужно создать толстый указатель на DST на основе среза из тонкого указателя. Примерно так выглядит мой код: 

#[repr(C)]
struct Atom {
    /// The len of the `data` field.
    len: u32,
    /// The data. 
    data: [u8],
}

/// This is the host. It creates the atom in a generally unknown way and calls
/// the plugin's run function. This isn't really part of my code, but it is
/// needed to understand it.
fn host() {
    // The raw representation of the atom
    let raw_representation: [u8; 8] = [
        // len: Raw representation of a `u32`. We have four data bytes.
        4, 0, 0, 0,
        // The actual data:
        1, 2, 3, 4
    ];

    let ptr: *const u8 = raw_representation.as_ptr();

    plugin_run(ptr);
}

/// This function represents the plugin's run function:
/// It only knows the pointer to the atom, nothing more.
fn plugin_run(ptr: *const u8) {
    // The length of the data.
    let len: u32 = *unsafe { (ptr as *const u32).as_ref() }.unwrap();

    // The "true" representation of the fat pointer.
    let fat_pointer: (*const u8, usize) = (ptr, len as usize);

    // transmuting the tuple into the actuall raw pointer.
    let atom: *const Atom = unsafe { std::mem::transmute(fat_pointer) };

    println!("{:?}", &atom.data);
}

Интересная строка - предпоследняя строка в plugin_run: здесь создается толстый указатель путем преобразования кортежа, содержащего тонкий указатель и длину. Этот подход работает, но он использует крайне небезопасный метод transmute. Согласно документации, этот метод должен быть абсолютным последним средством, но, насколько я понимаю, дизайн Rust, я не делаю ничего, что должно быть небезопасно. Я просто создаю указатель!

Я не хочу придерживаться этого решения. Есть ли безопасный способ создания указателей на структуры на основе массива, кроме использования transmute?

Единственное, что идет в этом направлении, это std::slice::from_raw_parts, но это также небезопасно, напрямую создает ссылку, а не указатель, и работает исключительно для срезов. Я ничего не нашел в стандартной библиотеке, я ничего не нашел на crates.io, я даже не нашел никаких проблем в git-репо. Я ищу неправильные ключевые слова? В Русте что-то подобное приветствуется?

Если бы ничего подобного не существовало, я бы пошел дальше и создал бы проблему для этого в репозитории Rust на Github.

РЕДАКТИРОВАТЬ: Я не должен был что-то говорить о LV2, это заставило обсуждение идти в совершенно ином направлении. Все работает отлично, я глубоко задумался о моделях данных и проверил их; Единственное, что я хотел бы иметь, - это безопасная альтернатива использованию transmute для создания жирных указателей. (

1 Ответ

0 голосов
/ 03 апреля 2019

Я работаю над интеграцией атомов LV2 для Rust

Есть ли причина, по которой вы не используете существующий ящик, который имеет дело с этим ?

LV2 атомов для Rust, которые являются типами динамического размера на основе срезов

Они не являются, согласно исходным кодом, который я мог найти . Вместо этого используется только структурный состав: 

typedef struct {
    uint32_t size;  /**< Size in bytes, not including type and size. */
    uint32_t type;  /**< Type of this atom (mapped URI). */
} LV2_Atom;

/** An atom:Int or atom:Bool.  May be cast to LV2_Atom. */
typedef struct {
    LV2_Atom atom;  /**< Atom header. */
    int32_t  body;  /**< Integer value. */
} LV2_Atom_Int;

Официальная документация , похоже, согласна. Это означает, что, вероятно, было бы недопустимо принимать значение LV2_Atom по значению, поскольку вы будете копировать только заголовок, а не тело. Это обычно называется struct tearing .

В Rust это может быть реализовано как: 

use libc::{int32_t, uint32_t};

#[repr(C)]
struct Atom {
    size: uint32_t,
    r#type: uint32_t,
}

#[repr(C)]
struct Int {
    atom: Atom,
    body: int32_t,
}

const INT_TYPE: uint32_t = 42; // Not real

extern "C" {
    fn get_some_atom() -> *const Atom;
}

fn get_int() -> Option<*const Int> {
    unsafe {
        let a = get_some_atom();
        if (*a).r#type == INT_TYPE {
            Some(a as *const Int)
        } else {
            None
        }
    }
}

fn use_int() {
    if let Some(i) = get_int() {
        let val = unsafe { (*i).body };
        println!("{}", val);
    }
}

Если вы посмотрите на исходный код lv2_raw crate , вы увидите почти то же самое. Есть также lv2 crate , который пытается вывести интерфейс более высокого уровня.

...