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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
//! What the agent's signal handlers share: the frame the kernel pushes on
//! x86-64, and handlers installed with the raw syscall, behind libc's back.
const std = @import("std");
const linux = std.os.linux;
const zt = @import("ztrace");
/// The kernel's `struct ucontext`: the interrupted thread's registers, which
/// a handler may change before they are restored.
pub const Ucontext = extern struct {
flags: u64,
link: ?*Ucontext,
stack: extern struct { sp: usize, flags: i32, size: usize },
r8: u64,
r9: u64,
r10: u64,
r11: u64,
r12: u64,
r13: u64,
r14: u64,
r15: u64,
rdi: u64,
rsi: u64,
rbp: u64,
rbx: u64,
rdx: u64,
rax: u64,
rcx: u64,
rsp: u64,
rip: u64,
eflags: u64,
cs: u16,
gs: u16,
fs: u16,
ss: u16,
err: u64,
trapno: u64,
oldmask: u64,
cr2: u64,
fpstate: usize,
reserved: [8]u64,
sigmask: u64,
comptime {
std.debug.assert(@offsetOf(Ucontext, "sigmask") == 296);
}
pub fn regs(uc: *const Ucontext) zt.Regs {
var out: zt.Regs = .{ .orig_rax = uc.rax, .cs = uc.cs, .ss = uc.ss, .fs = uc.fs, .gs = uc.gs };
inline for (zt.Regs.names) |name| @field(out, name) = @field(uc, name);
return out;
}
};
/// The trap flag: one instruction, then SIGTRAP.
pub const trap_flag = 0x100;
/// The bit of a signal in a kernel signal set.
pub fn bit(sig: linux.SIG) u64 {
return @as(u64, 1) << @intCast(@intFromEnum(sig) - 1);
}
// The gate: the only syscall instructions the dispatcher (sud.zig) lets
// through whatever the selector says. One symbol after the other, so that
// the range between the first and the last is these and nothing else.
comptime {
asm (
\\ .pushsection .text.ztrace_gate, "ax", @progbits
\\ .globl ztrace_gate_sigreturn, ztrace_gate_restorer, ztrace_gate_syscall, ztrace_gate_end
\\ .hidden ztrace_gate_sigreturn, ztrace_gate_restorer, ztrace_gate_syscall, ztrace_gate_end
\\ ztrace_gate_sigreturn:
\\ movq %rdi, %rsp
\\ ztrace_gate_restorer:
\\ movl $15, %eax
\\ syscall
\\ ztrace_gate_syscall:
\\ movq %rdi, %rax
\\ movq %rsi, %rdi
\\ movq %rdx, %rsi
\\ movq %rcx, %rdx
\\ movq %r8, %r10
\\ movq %r9, %r8
\\ movq 8(%rsp), %r9
\\ syscall
\\ retq
\\ ztrace_gate_end:
\\ .popsection
);
}
/// rt_sigreturn from the signal frame whose `Ucontext` is at `uc`.
pub extern fn ztrace_gate_sigreturn(uc: u64) callconv(.c) noreturn;
/// The same for a handler that returns: its stack pointer is there already.
extern fn ztrace_gate_restorer() callconv(.c) void;
/// Any syscall, by number.
pub extern fn ztrace_gate_syscall(number: u64, a0: u64, a1: u64, a2: u64, a3: u64, a4: u64, a5: u64) callconv(.c) u64;
extern const ztrace_gate_end: u8;
/// Where the gate is: start and length.
pub fn gate() [2]usize {
return .{ @intFromPtr(&ztrace_gate_sigreturn), @intFromPtr(&ztrace_gate_end) - @intFromPtr(&ztrace_gate_sigreturn) };
}
pub const Handler = *const fn (i32, *const linux.siginfo_t, *Ucontext) callconv(.c) void;
/// Null puts the default action back. The handler runs with no signal
/// blocked, its own included: inside it the thread is still the target, with
/// the target's mask.
pub fn install(sig: linux.SIG, handler: ?Handler) void {
const act: linux.k_sigaction = .{
.handler = @ptrCast(handler),
.flags = linux.SA.SIGINFO | linux.SA.RESTORER | linux.SA.NODEFER,
.restorer = @ptrCast(&ztrace_gate_restorer),
.mask = linux.sigemptyset(),
};
_ = linux.syscall4(.rt_sigaction, @intFromEnum(sig), @intFromPtr(&act), 0, @sizeOf(linux.sigset_t));
}
|