a10 0.4.1

This library is meant as a low-level library safely exposing different OS's abilities to perform non-blocking I/O.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! Utilities for address sanitizer support.

// Let's make it easier with all the `cfg`s.
#![allow(unused_variables, dead_code)]

use std::ffi::{CString, c_void};
use std::mem;

use crate::io::{IoMutSlice, IoSlice};

// TODO: replace with `std::ffi::c_size_t` once stable
// <https://github.com/rust-lang/rust/issues/88345>.
#[allow(non_camel_case_types)]
type c_size_t = usize;

// From <sanitizer/asan_interface.h>.
#[cfg_attr(feature = "nightly", cfg(sanitize = "address"))]
#[cfg_attr(not(feature = "nightly"), cfg(false))]
unsafe extern "C" {
    fn __asan_poison_memory_region(addr: *const c_void, size: c_size_t);
    fn __asan_unpoison_memory_region(addr: *const c_void, size: c_size_t);
}

/// Mark a memory region as unaddressable.
pub(crate) fn poison_region(addr: *const c_void, size: c_size_t) {
    #[cfg_attr(feature = "nightly", cfg(sanitize = "address"))]
    #[cfg_attr(not(feature = "nightly"), cfg(false))]
    unsafe {
        __asan_poison_memory_region(addr, size);
    }
}

/// Mark memory storing `T` as unaddressable.
pub(crate) fn poison<T: Sized>(addr: *const T) {
    if mem::size_of::<T>() != 0 && !addr.is_null() {
        // Don't poison zero sized types.
        poison_region(addr.cast(), mem::size_of::<T>());
    }
}

/// Mark the bytes of iovecs as addressable.
pub(crate) fn poison_iovecs(iovecs: &[IoSlice]) {
    for iovec in iovecs {
        poison_region(unsafe { iovec.ptr().cast() }, iovec.len());
    }
}

/// Mark the bytes of iovecs as addressable.
pub(crate) fn poison_iovecs_mut(iovecs: &[IoMutSlice]) {
    for iovec in iovecs {
        poison_region(unsafe { iovec.ptr().cast() }, iovec.len());
    }
}

/// Mark memory storing `T` as unaddressable.
pub(crate) fn poison_cstring(value: &CString) {
    let value = value.as_bytes_with_nul();
    poison_region(value.as_ptr().cast(), value.len());
}

/// Mark a memory region as addressable.
pub(crate) fn unpoison_region(addr: *const c_void, size: c_size_t) {
    #[cfg_attr(feature = "nightly", cfg(sanitize = "address"))]
    #[cfg_attr(not(feature = "nightly"), cfg(false))]
    unsafe {
        __asan_unpoison_memory_region(addr, size);
    }
}

/// Mark memory storing `T` as addressable.
pub(crate) fn unpoison<T: Sized>(addr: *const T) {
    if mem::size_of::<T>() != 0 && !addr.is_null() {
        // We don't poison zero sized types, so don't unpoison them
        unpoison_region(addr.cast(), mem::size_of::<T>());
    }
}

/// Mark the bytes of iovecs as addressable.
pub(crate) fn unpoison_iovecs(iovecs: &[IoSlice]) {
    for iovec in iovecs {
        unpoison_region(unsafe { iovec.ptr().cast() }, iovec.len());
    }
}

/// Mark the bytes of iovecs as addressable.
pub(crate) fn unpoison_iovecs_mut(iovecs: &[IoMutSlice]) {
    for iovec in iovecs {
        unpoison_region(unsafe { iovec.ptr().cast() }, iovec.len());
    }
}

/// Mark memory storing `T` as addressable.
pub(crate) fn unpoison_cstring(value: &CString) {
    let value = value.as_bytes_with_nul();
    unpoison_region(value.as_ptr().cast(), value.len());
}