Горячие клавиши

Нажмите ← или → для навигации между главами

Нажмите S или / для поиска по книге

Нажмите ? для показа этой справки

Нажмите Esc для скрытия этой справки

Небезопасный Rust

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

Небезопасный Rust существует потому, что по своей природе статический анализ консервативен. Когда компилятор пытается определить, поддерживает ли код гарантии, лучше, чтобы он отклонил некоторые допустимые программы, чем принял некоторые недопустимые. Хотя код может быть в порядке, если у компилятора Rust недостаточно информации, чтобы быть уверенным, он отклонит код. В таких случаях вы можете использовать небезопасный код, чтобы сказать компилятору: «Доверься мне, я знаю, что делаю». Однако будьте предупреждены: вы используете небезопасный Rust на свой страх и риск: если вы неправильно используете небезопасный код, могут возникнуть проблемы из-за небезопасности памяти, такие как разыменование нулевого указателя.

Другая причина, по которой у Rust есть небезопасное альтер эго, заключается в том, что лежащее в основе компьютерное оборудование по своей сути небезопасно. Если бы Rust не позволял выполнять небезопасные операции, вы не смогли бы выполнять определённые задачи. Rust должен позволять вам заниматься низкоуровневым системным программированием, например, напрямую взаимодействовать с операционной системой или даже писать собственную операционную систему. Работа с низкоуровневым системным программированием — одна из целей языка. Давайте исследуем, что мы можем делать с небезопасным Rust и как это делать.

Выполнение небезопасных сверхспособностей

Чтобы переключиться на небезопасный Rust, используйте ключевое слово unsafe, а затем начните новый блок, который содержит небезопасный код. В небезопасном Rust вы можете выполнять пять действий, которые не можете в безопасном Rust, и мы называем их небезопасными сверхспособностями. Эти сверхспособности включают возможность:

  1. Разыменовывать сырой указатель.
  2. Вызывать небезопасную функцию или метод.
  3. Получать доступ к изменяемой статической переменной или изменять её.
  4. Реализовывать небезопасный трейт.
  5. Получать доступ к полям union.

Важно понимать, что unsafe не отключает проверку заимствований и не отключает какие-либо другие проверки безопасности Rust: если вы используете ссылку в небезопасном коде, она всё равно будет проверена. Ключевое слово unsafe только даёт вам доступ к этим пяти возможностям, которые затем не проверяются компилятором на безопасность памяти. Внутри небезопасного блока вы всё равно получите некоторую степень безопасности.

Кроме того, unsafe не означает, что код внутри блока обязательно опасен или что у него точно будут проблемы с безопасностью памяти: смысл в том, что как программист вы обеспечите, чтобы код внутри блока unsafe обращался к памяти допустимым образом.

Люди подвержены ошибкам, и ошибки будут происходить, но, требуя, чтобы эти пять небезопасных операций находились внутри блоков, помеченных unsafe, вы будете знать, что любые ошибки, связанные с безопасностью памяти, должны находиться внутри блока unsafe. Держите блоки unsafe маленькими; вы будете благодарны позже, когда будете исследовать ошибки памяти.

Чтобы максимально изолировать небезопасный код, лучше всего заключить такой код в безопасную абстракцию и предоставить безопасный API, который мы обсудим позже в этой главе, когда будем рассматривать небезопасные функции и методы. Части стандартной библиотеки реализованы как безопасные абстракции над проверенным небезопасным кодом. Обёртывание небезопасного кода в безопасную абстракцию предотвращает утечку использования unsafe во все места, где вы или ваши пользователи можете захотеть использовать функциональность, реализованную с помощью небезопасного кода, потому что использование безопасной абстракции безопасно.

Давайте рассмотрим каждую из пяти небезопасных сверхспособностей по очереди. Мы также рассмотрим некоторые абстракции, которые обеспечивают безопасный интерфейс к небезопасному коду.

Разыменование сырого указателя

В главе 4, в разделе «Висячие ссылки», мы упоминали, что компилятор гарантирует, что ссылки всегда действительны. В небезопасном Rust есть два новых типа, называемых сырыми указателями, которые похожи на ссылки. Как и ссылки, сырые указатели могут быть неизменяемыми или изменяемыми и записываются как *const T и *mut T соответственно. Звёздочка — это не оператор разыменования; это часть имени типа. В контексте сырых указателей неизменяемый означает, что указателю нельзя напрямую присвоить значение после разыменования.

В отличие от ссылок и умных указателей, сырые указатели:

  • Могут игнорировать правила заимствования, имея одновременно неизменяемые и изменяемые указатели или несколько изменяемых указателей на одно и то же место.
  • Не гарантируют, что указывают на действительную память.
  • Могут быть нулевыми.
  • Не реализуют автоматическую очистку.

Отказавшись от того, чтобы Rust обеспечивал эти гарантии, вы можете отказаться от гарантированной безопасности в обмен на большую производительность или возможность взаимодействия с другим языком или оборудованием, где гарантии Rust не применяются.

Листинг 20-1 показывает, как создать неизменяемый и изменяемый сырые указатели.

fn main() {
    let mut num = 5;

    let r1 = &raw const num;
    let r2 = &raw mut num;
}
Листинг 20-1: Создание сырых указателей с помощью операторов сырого заимствования

Обратите внимание, что мы не включаем ключевое слово unsafe в этот код. Мы можем создавать сырые указатели в безопасном коде; мы просто не можем разыменовывать сырые указатели вне небезопасного блока, как вы увидите чуть позже.

Мы создали сырые указатели с помощью операторов сырого заимствования: &raw const num создаёт неизменяемый сырой указатель *const i32, а &raw mut num создаёт изменяемый сырой указатель *mut i32. Поскольку мы создали их непосредственно из локальной переменной, мы знаем, что эти конкретные сырые указатели действительны, но мы не можем сделать такое предположение о любом сыром указателе.

Чтобы продемонстрировать это, далее мы создадим сырой указатель, в действительности которого мы не можем быть так уверены, используя ключевое слово as для приведения значения вместо использования оператора сырого заимствования. Листинг 20-2 показывает, как создать сырой указатель на произвольное место в памяти. Попытка использовать произвольную память не определена: по этому адресу могут быть данные, а могут и не быть, компилятор может оптимизировать код так, что обращения к памяти не будет, или программа может завершиться с ошибкой сегментации. Обычно нет веской причины писать такой код, особенно в случаях, когда вы можете использовать оператор сырого заимствования, но это возможно.

fn main() {
    let address = 0x012345usize;
    let r = address as *const i32;
}
Листинг 20-2: Создание сырого указателя на произвольный адрес памяти

Вспомните, что мы можем создавать сырые указатели в безопасном коде, но мы не можем разыменовывать сырые указатели и читать данные, на которые они указывают. В листинге 20-3 мы используем оператор разыменования * с сырым указателем, что требует блока unsafe.

fn main() {
    let mut num = 5;

    let r1 = &raw const num;
    let r2 = &raw mut num;

    unsafe {
        println!("r1 is: {}", *r1);
        println!("r2 is: {}", *r2);
    }
}
Листинг 20-3: Разыменование сырых указателей внутри блока unsafe

Создание указателя не причиняет вреда; только когда мы пытаемся получить доступ к значению, на которое он указывает, мы можем столкнуться с недопустимым значением.

Обратите также внимание, что в листингах 20-1 и 20-3 мы создали сырые указатели *const i32 и *mut i32, которые оба указывали на одно и то же место в памяти, где хранится num. Если бы вместо этого мы попытались создать неизменяемую и изменяемую ссылки на num, код не скомпилировался бы, потому что правила владения Rust не допускают изменяемую ссылку одновременно с любыми неизменяемыми ссылками. С сырыми указателями мы можем создать изменяемый указатель и неизменяемый указатель на одно и то же место и изменять данные через изменяемый указатель, потенциально создавая гонку данных. Будьте осторожны!

Со всеми этими опасностями, почему вы когда-либо стали бы использовать сырые указатели? Один из основных случаев использования — при взаимодействии с кодом на C, как вы увидите в следующем разделе. Другой случай — при построении безопасных абстракций, которые не понимает проверка заимствований. Мы представим небезопасные функции, а затем рассмотрим пример безопасной абстракции, которая использует небезопасный код.

Вызов небезопасной функции или метода

Второй тип операции, которую вы можете выполнять в небезопасном блоке, — вызов небезопасных функций. Небезопасные функции и методы выглядят точно так же, как обычные функции и методы, но у них есть дополнительное unsafe перед остальной частью определения. Ключевое слово unsafe в этом контексте указывает, что функция имеет требования, которые мы должны выполнить, когда вызываем эту функцию, потому что Rust не может гарантировать, что мы выполнили эти требования. Вызывая небезопасную функцию внутри блока unsafe, мы говорим, что прочитали документацию этой функции и берём на себя ответственность за выполнение контрактов функции.

Вот небезопасная функция с именем dangerous, которая ничего не делает в своём теле:

fn main() {
    unsafe fn dangerous() {}

    unsafe {
        dangerous();
    }
}

Мы должны вызвать функцию dangerous внутри отдельного блока unsafe. Если мы попытаемся вызвать dangerous без блока unsafe, мы получим ошибку:

$ cargo run
   Compiling unsafe-example v0.1.0 (file:///projects/unsafe-example)
error[E0133]: call to unsafe function `dangerous` is unsafe and requires unsafe block
 --> src/main.rs:4:5
  |
4 |     dangerous();
  |     ^^^^^^^^^^^ call to unsafe function
  |
  = note: consult the function's documentation for information on how to avoid undefined behavior

For more information about this error, try `rustc --explain E0133`.
error: could not compile `unsafe-example` (bin "unsafe-example") due to 1 previous error

С блоком unsafe мы заверяем Rust, что прочитали документацию функции, понимаем, как её правильно использовать, и проверили, что выполняем контракт функции.

Чтобы выполнять небезопасные операции в теле unsafe функции, вам всё равно нужно использовать блок unsafe, как и внутри обычной функции, и компилятор предупредит вас, если вы забудете. Это помогает нам держать блоки unsafe как можно меньше, так как небезопасные операции могут быть не нужны на протяжении всего тела функции.

Создание безопасной абстракции над небезопасным кодом

То, что функция содержит небезопасный код, не означает, что нам нужно помечать всю функцию как небезопасную. На самом деле, обёртывание небезопасного кода в безопасную функцию — это распространённая абстракция. В качестве примера давайте изучим функцию split_at_mut из стандартной библиотеки, которая требует некоторого небезопасного кода. Мы исследуем, как мы могли бы её реализовать. Этот безопасный метод определён для изменяемых срезов: он принимает один срез и делает из него два, разделяя срез по индексу, данному в качестве аргумента. Листинг 20-4 показывает, как использовать split_at_mut.

fn main() {
    let mut v = vec![1, 2, 3, 4, 5, 6];

    let r = &mut v[..];

    let (a, b) = r.split_at_mut(3);

    assert_eq!(a, &mut [1, 2, 3]);
    assert_eq!(b, &mut [4, 5, 6]);
}
Листинг 20-4: Использование безопасной функции split_at_mut

Мы не можем реализовать эту функцию, используя только безопасный Rust. Попытка может выглядеть примерно как в листинге 20-5, который не скомпилируется. Для простоты мы реализуем split_at_mut как функцию, а не как метод, и только для срезов значений i32, а не для обобщённого типа T.

fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
    let len = values.len();

    assert!(mid <= len);

    (&mut values[..mid], &mut values[mid..])
}

fn main() {
    let mut vector = vec![1, 2, 3, 4, 5, 6];
    let (left, right) = split_at_mut(&mut vector, 3);
}
Листинг 20-5: Попытка реализации split_at_mut с использованием только безопасного Rust

Эта функция сначала получает общую длину среза. Затем она утверждает, что индекс, заданный в качестве параметра, находится в пределах среза, проверяя, что он меньше или равен длине. Утверждение означает, что если мы передадим индекс, который больше длины, для разделения среза, функция запаникует до того, как попытается использовать этот индекс.

Затем мы возвращаем два изменяемых среза в кортеже: один от начала исходного среза до индекса mid, а другой от mid до конца среза.

Когда мы пытаемся скомпилировать код в листинге 20-5, мы получаем ошибку:

$ cargo run
   Compiling unsafe-example v0.1.0 (file:///projects/unsafe-example)
error[E0499]: cannot borrow `*values` as mutable more than once at a time
 --> src/main.rs:6:31
  |
1 | fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
  |                         - let's call the lifetime of this reference `'1`
...
6 |     (&mut values[..mid], &mut values[mid..])
  |     --------------------------^^^^^^--------
  |     |     |                   |
  |     |     |                   second mutable borrow occurs here
  |     |     first mutable borrow occurs here
  |     returning this value requires that `*values` is borrowed for `'1`
  |
  = help: use `.split_at_mut(position)` to obtain two mutable non-overlapping sub-slices

For more information about this error, try `rustc --explain E0499`.
error: could not compile `unsafe-example` (bin "unsafe-example") due to 1 previous error

Проверка заимствований Rust не может понять, что мы заимствуем разные части среза; она знает только, что мы заимствуем из одного среза дважды. Заимствование разных частей среза принципиально допустимо, потому что два среза не перекрываются, но Rust недостаточно умён, чтобы это знать. Когда мы знаем, что код в порядке, а Rust — нет, настало время обратиться к небезопасному коду.

Листинг 20-6 показывает, как использовать блок unsafe, сырой указатель и некоторые вызовы небезопасных функций, чтобы реализация split_at_mut работала.

use std::slice;

fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
    let len = values.len();
    let ptr = values.as_mut_ptr();

    assert!(mid <= len);

    unsafe {
        (
            slice::from_raw_parts_mut(ptr, mid),
            slice::from_raw_parts_mut(ptr.add(mid), len - mid),
        )
    }
}

fn main() {
    let mut vector = vec![1, 2, 3, 4, 5, 6];
    let (left, right) = split_at_mut(&mut vector, 3);
}
Листинг 20-6: Использование небезопасного кода в реализации функции split_at_mut

Вспомните из раздела «Тип срез» главы 4, что срез — это указатель на некоторые данные и длина среза. Мы используем метод len, чтобы получить длину среза, и метод as_mut_ptr, чтобы получить доступ к сырому указателю среза. В этом случае, поскольку у нас есть изменяемый срез значений i32, as_mut_ptr возвращает сырой указатель с типом *mut i32, который мы сохранили в переменной ptr.

Мы сохраняем утверждение, что индекс mid находится в пределах среза. Затем мы переходим к небезопасному коду: функция slice::from_raw_parts_mut принимает сырой указатель и длину и создаёт срез. Мы используем эту функцию, чтобы создать срез, который начинается с ptr и имеет длину mid элементов. Затем мы вызываем метод add для ptr с mid в качестве аргумента, чтобы получить сырой указатель, который начинается с mid, и мы создаём срез, используя этот указатель и оставшееся количество элементов после mid в качестве длины.

Функция slice::from_raw_parts_mut небезопасна, потому что она принимает сырой указатель и должна доверять тому, что этот указатель действителен. Метод add для сырых указателей также небезопасен, потому что он должен доверять тому, что местоположение смещения также является действительным указателем. Поэтому нам пришлось поместить блок unsafe вокруг наших вызовов slice::from_raw_parts_mut и add, чтобы мы могли их вызвать. Глядя на код и добавляя утверждение, что mid должен быть меньше или равен len, мы можем сказать, что все сырые указатели, используемые внутри блока unsafe, будут действительными указателями на данные внутри среза. Это приемлемое и уместное использование unsafe.

Обратите внимание, что нам не нужно помечать результирующую функцию split_at_mut как unsafe, и мы можем вызывать эту функцию из безопасного Rust. Мы создали безопасную абстракцию над небезопасным кодом с помощью реализации функции, которая использует небезопасный код безопасным образом, потому что она создаёт только действительные указатели из данных, к которым эта функция имеет доступ.

В отличие от этого, использование slice::from_raw_parts_mut в листинге 20-7, вероятно, приведёт к аварийному завершению при использовании среза. Этот код принимает произвольное место в памяти и создаёт срез длиной 10 000 элементов.

fn main() {
    use std::slice;

    let address = 0x01234usize;
    let r = address as *mut i32;

    let values: &[i32] = unsafe { slice::from_raw_parts_mut(r, 10000) };
}
Листинг 20-7: Создание среза из произвольного места в памяти

Мы не владеем памятью по этому произвольному адресу, и нет гарантии, что срез, созданный этим кодом, содержит действительные значения i32. Попытка использовать values так, как если бы это был действительный срез, приводит к неопределённому поведению.

Использование extern функций для вызова внешнего кода

Иногда вашему коду Rust может понадобиться взаимодействовать с кодом, написанным на другом языке. Для этого в Rust есть ключевое слово extern, которое облегчает создание и использование интерфейса внешних функций (FFI) — способа, которым язык программирования определяет функции и позволяет другому (внешнему) языку программирования вызывать эти функции.

Листинг 20-8 демонстрирует, как настроить интеграцию с функцией abs из стандартной библиотеки C. Функции, объявленные внутри блоков extern, как правило, небезопасно вызывать из кода Rust, поэтому блоки extern также должны быть помечены unsafe. Причина в том, что другие языки не применяют правила и гарантии Rust, и Rust не может их проверить, поэтому ответственность ложится на программиста по обеспечению безопасности.

Имя файла: src/main.rs
unsafe extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    unsafe {
        println!("Absolute value of -3 according to C: {}", abs(-3));
    }
}
Листинг 20-8: Объявление и вызов extern функции, определённой на другом языке

Внутри блока unsafe extern "C" мы перечисляем имена и сигнатуры внешних функций из другого языка, которые хотим вызывать. Часть "C" определяет, какой двоичный интерфейс приложения (ABI) использует внешняя функция: ABI определяет, как вызывать функцию на уровне ассемблера. ABI "C" является наиболее распространённым и следует ABI языка программирования C. Информация обо всех ABI, которые поддерживает Rust, доступна в справочнике Rust.

Каждый элемент, объявленный внутри блока unsafe extern, неявно небезопасен. Однако некоторые функции FFI безопасны для вызова. Например, функция abs из стандартной библиотеки C не имеет соображений безопасности памяти, и мы знаем, что её можно вызывать с любым i32. В таких случаях мы можем использовать ключевое слово safe, чтобы сказать, что эта конкретная функция безопасна для вызова, даже если она находится в блоке unsafe extern. Как только мы сделаем это изменение, её вызов больше не требует блока unsafe, как показано в листинге 20-9.

Имя файла: src/main.rs
unsafe extern "C" {
    safe fn abs(input: i32) -> i32;
}

fn main() {
    println!("Absolute value of -3 according to C: {}", abs(-3));
}
Листинг 20-9: Явное помечивание функции как safe внутри блока unsafe extern и её безопасный вызов

Помечивание функции как safe не делает её по своей сути безопасной! Вместо этого это как обещание, которое вы даёте Rust, что она безопасна. По-прежнему ваша ответственность — убедиться, что это обещание выполняется!

Вызов функций Rust из других языков

Мы также можем использовать extern, чтобы создать интерфейс, позволяющий другим языкам вызывать функции Rust. Вместо создания целого блока extern мы добавляем ключевое слово extern и указываем ABI для использования непосредственно перед ключевым словом fn для соответствующей функции. Нам также нужно добавить аннотацию #[unsafe(no_mangle)], чтобы сообщить компилятору Rust не искажать имя этой функции. Искажение имён — это когда компилятор изменяет имя, которое мы дали функции, на другое имя, которое содержит больше информации для других частей процесса компиляции, но менее читаемо для человека. Каждый компилятор языка программирования искажает имена немного по-разному, поэтому, чтобы функцию Rust можно было назвать из других языков, мы должны отключить искажение имён компилятора Rust. Это небезопасно, потому что без встроенного искажения могут возникнуть коллизии имён между библиотеками, поэтому наша ответственность — убедиться, что выбранное нами имя безопасно экспортировать без искажения.

В следующем примере мы делаем функцию call_from_c доступной из кода C после её компиляции в разделяемую библиотеку и связывания из C:

#[unsafe(no_mangle)]
pub extern "C" fn call_from_c() {
    println!("Just called a Rust function from C!");
}

Это использование extern требует unsafe только в атрибуте, а не в блоке extern.

Доступ к изменяемой статической переменной или её изменение

В этой книге мы ещё не говорили о глобальных переменных, которые Rust поддерживает, но которые могут быть проблематичными с правилами владения Rust. Если два потока обращаются к одной и той же изменяемой глобальной переменной, это может вызвать гонку данных.

В Rust глобальные переменные называются статическими переменными. Листинг 20-10 показывает пример объявления и использования статической переменной со срезом строки в качестве значения.

Имя файла: src/main.rs
static HELLO_WORLD: &str = "Hello, world!";

fn main() {
    println!("value is: {HELLO_WORLD}");
}
Листинг 20-10: Определение и использование неизменяемой статической переменной

Статические переменные похожи на константы, которые мы обсуждали в разделе «Объявление констант» главы 3. Имена статических переменных по соглашению пишутся в SCREAMING_SNAKE_CASE. Статические переменные могут хранить только ссылки со временем жизни 'static, что означает, что компилятор Rust может определить время жизни, и нам не требуется аннотировать его явно. Доступ к неизменяемой статической переменной безопасен.

Тонкое различие между константами и неизменяемыми статическими переменными заключается в том, что значения в статической переменной имеют фиксированный адрес в памяти. Использование значения всегда будет обращаться к одним и тем же данным. Константы, с другой стороны, могут дублировать свои данные при каждом использовании. Другое различие заключается в том, что статические переменные могут быть изменяемыми. Доступ к изменяемым статическим переменным и их изменение небезопасны. Листинг 20-11 показывает, как объявить, получить доступ и изменить изменяемую статическую переменную с именем COUNTER.

Имя файла: src/main.rs
static mut COUNTER: u32 = 0;

/// SAFETY: Вызов этой функции более чем из одного потока одновременно приводит к неопределённому
/// поведению, поэтому вы *обязаны* гарантировать, что вызываете её только из одного потока
/// за раз.
unsafe fn add_to_count(inc: u32) {
    unsafe {
        COUNTER += inc;
    }
}

fn main() {
    unsafe {
        // SAFETY: Это вызывается только из одного потока в `main`.
        add_to_count(3);
        println!("COUNTER: {}", *(&raw const COUNTER));
    }
}
Листинг 20-11: Чтение из изменяемой статической переменной или запись в неё небезопасны.

Как и с обычными переменными, мы указываем изменяемость с помощью ключевого слова mut. Любой код, который читает из COUNTER или пишет в него, должен находиться внутри блока unsafe. Код в листинге 20-11 компилируется и печатает COUNTER: 3, как мы и ожидали, потому что он однопоточный. Если бы несколько потоков обращались к COUNTER, это, вероятно, привело бы к гонкам данных, поэтому это неопределённое поведение. Следовательно, нам нужно пометить всю функцию как unsafe и документировать ограничение безопасности, чтобы любой, кто вызывает функцию, знал, что ему разрешено и что не разрешено делать безопасно.

Всякий раз, когда мы пишем небезопасную функцию, идиоматично писать комментарий, начинающийся с SAFETY, и объяснять, что вызывающему нужно сделать, чтобы безопасно вызвать функцию. Точно так же, когда мы выполняем небезопасную операцию, идиоматично писать комментарий, начинающийся с SAFETY, чтобы объяснить, как соблюдаются правила безопасности.

Кроме того, компилятор по умолчанию запрещает любую попытку создать ссылки на изменяемую статическую переменную с помощью линта компилятора. Вы должны либо явно отказаться от защит этого линта, добавив аннотацию #[allow(static_mut_refs)], либо получить доступ к изменяемой статической переменной через сырой указатель, созданный с помощью одного из операторов сырого заимствования. Это включает случаи, когда ссылка создаётся невидимо, как при её использовании в println! в этом листинге. Требование создавать ссылки на изменяемые статические переменные через сырые указатели помогает сделать требования безопасности при их использовании более очевидными.

С изменяемыми данными, которые глобально доступны, трудно гарантировать отсутствие гонок данных, поэтому Rust считает изменяемые статические переменные небезопасными. Где возможно, предпочтительнее использовать методы конкурентности и потокобезопасные умные указатели, которые мы обсуждали в главе 16, чтобы компилятор проверял, что доступ к данным из разных потоков выполняется безопасно.

Реализация небезопасного трейта

Мы можем использовать unsafe для реализации небезопасного трейта. Трейт небезопасен, когда хотя бы один из его методов имеет инвариант, который компилятор не может проверить. Мы объявляем, что трейт unsafe, добавляя ключевое слово unsafe перед trait, и также помечаем реализацию трейта как unsafe, как показано в листинге 20-12.

unsafe trait Foo {
    // здесь методы
}

unsafe impl Foo for i32 {
    // здесь реализации методов
}

fn main() {}
Листинг 20-12: Определение и реализация небезопасного трейта

Используя unsafe impl, мы обещаем, что будем соблюдать инварианты, которые компилятор не может проверить.

В качестве примера вспомните маркерные трейты Send и Sync, которые мы обсуждали в разделе «Расширяемая конкурентность с Send и Sync» главы 16: компилятор реализует эти трейты автоматически, если наши типы полностью состоят из других типов, реализующих Send и Sync. Если мы реализуем тип, содержащий тип, который не реализует Send или Sync, такой как сырые указатели, и хотим пометить этот тип как Send или Sync, мы должны использовать unsafe. Rust не может проверить, что наш тип поддерживает гарантии, что его можно безопасно передавать между потоками или получать к нему доступ из нескольких потоков; следовательно, нам нужно выполнить эти проверки вручную и указать это с помощью unsafe.

Доступ к полям объединения

Последнее действие, которое работает только с unsafe, — доступ к полям объединения. Объединение (union) похоже на struct, но только одно объявленное поле используется в конкретном экземпляре в один момент времени. Объединения в основном используются для взаимодействия с объединениями в коде C. Доступ к полям объединения небезопасен, потому что Rust не может гарантировать тип данных, которые в настоящее время хранятся в экземпляре объединения. Вы можете узнать больше об объединениях в справочнике Rust.

Использование Miri для проверки небезопасного кода

При написании небезопасного кода вы можете захотеть проверить, что написанное вами на самом деле безопасно и правильно. Один из лучших способов сделать это — использовать Miri, официальный инструмент Rust для обнаружения неопределённого поведения. В то время как проверка заимствований — это статический инструмент, который работает во время компиляции, Miri — это динамический инструмент, который работает во время выполнения. Он проверяет ваш код, запуская вашу программу или её набор тестов, и обнаруживает, когда вы нарушаете правила, которые он понимает о том, как должен работать Rust.

Использование Miri требует ночной сборки Rust (о которой мы говорим подробнее в Приложении G: Как создаётся Rust и «Ночной Rust»). Вы можете установить как ночную версию Rust, так и инструмент Miri, набрав rustup +nightly component add miri. Это не меняет версию Rust, которую использует ваш проект; это только добавляет инструмент в вашу систему, чтобы вы могли использовать его, когда захотите. Вы можете запустить Miri для проекта, набрав cargo +nightly miri run или cargo +nightly miri test.

В качестве примера того, насколько это может быть полезно, рассмотрим, что происходит, когда мы запускаем его против листинга 20-7.

$ cargo +nightly miri run
   Compiling unsafe-example v0.1.0 (file:///projects/unsafe-example)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.17s
     Running `file:///home/.rustup/toolchains/nightly/bin/cargo-miri runner target/miri/debug/unsafe-example`
warning: integer-to-pointer cast
 --> src/main.rs:5:13
  |
5 |     let r = address as *mut i32;
  |             ^^^^^^^^^^^^^^^^^^^ integer-to-pointer cast
  |
  = help: this program is using integer-to-pointer casts or (equivalently) `ptr::with_exposed_provenance`, which means that Miri might miss pointer bugs in this program
  = help: see https://doc.rust-lang.org/nightly/std/ptr/fn.with_exposed_provenance.html for more details on that operation
  = help: to ensure that Miri does not miss bugs in your program, use Strict Provenance APIs (https://doc.rust-lang.org/nightly/std/ptr/index.html#strict-provenance, https://crates.io/crates/sptr) instead
  = help: you can then set `MIRIFLAGS=-Zmiri-strict-provenance` to ensure you are not relying on `with_exposed_provenance` semantics
  = help: alternatively, `MIRIFLAGS=-Zmiri-permissive-provenance` disables this warning

error: Undefined Behavior: constructing invalid value of type &mut [i32]: encountered a dangling reference (0x1234[noalloc] has no provenance)
 --> src/main.rs:7:35
  |
7 |     let values: &[i32] = unsafe { slice::from_raw_parts_mut(r, 10000) };
  |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
  |
  = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
  = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information

note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace

error: aborting due to 1 previous error; 1 warning emitted

Miri правильно предупреждает нас, что мы приводим целое число к указателю, что может быть проблемой, но Miri не может определить, существует ли проблема, потому что он не знает, как возник указатель. Затем Miri возвращает ошибку в месте, где листинг 20-7 имеет неопределённое поведение, потому что у нас есть висячий указатель. Благодаря Miri мы теперь знаем, что есть риск неопределённого поведения, и мы можем подумать о том, как сделать код безопасным. В некоторых случаях Miri может даже давать рекомендации о том, как исправить ошибки.

Miri не ловит всё, что вы можете сделать неправильно при написании небезопасного кода. Miri — это инструмент динамического анализа, поэтому он ловит проблемы только с кодом, который фактически выполняется. Это означает, что вам нужно будет использовать его в сочетании с хорошими методами тестирования, чтобы повысить вашу уверенность в написанном небезопасном коде. Miri также не охватывает все возможные способы, которыми ваш код может быть некорректным.

Другими словами: если Miri обнаружит проблему, вы знаете, что есть ошибка, но только потому, что Miri не обнаруживает ошибку, не означает, что проблемы нет. Однако он может поймать многое. Попробуйте запустить его на других примерах небезопасного кода в этой главе и посмотрите, что он скажет!

Вы можете узнать больше о Miri в его репозитории на GitHub.

Правильное использование небезопасного кода

Использование unsafe для одной из пяти только что обсуждённых сверхспособностей не является неправильным или даже не одобряется, но правильнее использовать unsafe сложнее, потому что компилятор не может помочь поддерживать безопасность памяти. Когда у вас есть причина использовать небезопасный код, вы можете это сделать, и наличие явной аннотации unsafe облегчает отслеживание источника проблем, когда они возникают. Всякий раз, когда вы пишете небезопасный код, вы можете использовать Miri, чтобы помочь вам быть более уверенным, что написанный вами код поддерживает правила Rust.

Для гораздо более глубокого изучения того, как эффективно работать с небезопасным Rust, прочитайте официальное руководство Rust по unsafe — Rustonomicon.