Unsafe Operations

As an introduction to this section, to borrow from the official docs, “one should try to minimize the amount of unsafe code in a code base.” With that in mind, let’s get started! Unsafe annotations in Rust are used to bypass protections put in place by the compiler; specifically, there are four primary things that unsafe is used for:

• dereferencing raw pointers
• calling functions or methods which are unsafe (including calling a function over FFI, see a previous chapter of the book)
• accessing or modifying static mutable variables
• implementing unsafe traits
• accessing elements of a union

Raw Pointers

Raw pointers * and references &T function similarly, but references are always safe because they are guaranteed to point to valid data due to the borrow checker. Dereferencing a raw pointer can only be done through an unsafe block.

fn main() {
    let raw_p: *const u32 = &10;

    unsafe {
        assert!(*raw_p == 10);
    }
}

Calling Unsafe Functions

Some functions can be declared as unsafe, meaning it is the programmer’s responsibility to ensure correctness instead of the compiler’s. One example of this is std::slice::from_raw_parts which will create a slice given a pointer to the first element and a length.

use std::slice;

fn main() {
    let some_vector = vec![1, 2, 3, 4];

    let pointer = some_vector.as_ptr();
    let length = some_vector.len();

    unsafe {
        let my_slice: &[u32] = slice::from_raw_parts(pointer, length);

        assert_eq!(some_vector.as_slice(), my_slice);
    }
}

For slice::from_raw_parts, one of the assumptions which must be upheld is that the pointer passed in points to valid memory and that the memory pointed to is of the correct type. If these invariants aren’t upheld then the program’s behaviour is undefined and there is no knowing what will happen.

Union Elements

Elements of unions overlap in memory, thus changing the value of one element automatically changes every element’s value. They can be used, if you don’t know which data type you will need at runtime. Since Rust offers safe Enums, the main purpose of Unions is to allow interacting with C code. Accessing and changing elements of unions is only allowed in unsafe Rust.

union MyFirstUnion {
    float: f32,
    integer: u32
}

fn main() {
    // Creating an object of a union type doesn't require Unsafe Rust.
    let mut u = MyFirstUnion { float: 123.45 };
    
    // Reading and changing u.float or u.integer is only allowed in Unsafe Rust.
    unsafe {
        assert_eq!(u.float, 123.45);
        println!("u.float = 123.45, but u.integer = {}", u.integer);

        u.integer = 42;
        assert_eq!(u.integer, 42);
        println!("u.integer = 42, but u.float = {}", u.float);
    }
}