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
|
// Copyright 2021-2026 Vector 35 Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use std::time::{Duration, SystemTime, UNIX_EPOCH};
macro_rules! ffi_wrap {
($n:expr, $b:expr) => {{
use std::panic;
use std::process;
panic::catch_unwind(|| $b).unwrap_or_else(|_| {
::tracing::error!("ffi callback caught panic: {}", $n);
process::abort()
})
}};
}
pub(crate) fn time_from_bn(timestamp: u64) -> SystemTime {
let m = Duration::from_secs(timestamp);
UNIX_EPOCH + m
}
pub(crate) unsafe fn slice_from_raw_parts<'a, T>(data: *const T, len: usize) -> &'a [T] {
if len == 0 {
// C can and will pass null pointers for data in the case of zero length arrays.
// According to the documentation of std::slice::from_raw_parts, data must be
// non-null and properly aligned. To avoid creating unsound slices, return an
// empty slice directly on any zero-length array, avoiding the unsound call
// to std::slice::from_raw_parts.
&[]
} else {
unsafe { std::slice::from_raw_parts(data, len) }
}
}
#[macro_export]
macro_rules! ffi_span {
($name:expr, $bv:expr) => {{
#[allow(unused_imports)]
use $crate::file_metadata::FileMetadata;
::tracing::info_span!($name, session_id = $bv.file().session_id().0).entered()
}};
($name:expr) => {
::tracing::info_span!($name).entered()
};
}
macro_rules! new_id_type {
($name:ident, $inner_type:ty) => {
#[derive(std::fmt::Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct $name(pub $inner_type);
impl From<$inner_type> for $name {
fn from(value: $inner_type) -> Self {
Self(value)
}
}
impl From<$name> for $inner_type {
fn from(value: $name) -> Self {
value.0
}
}
impl std::fmt::Display for $name {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.0)
}
}
};
}
|
