summaryrefslogtreecommitdiff
path: root/src/agent/signal.zig
blob: 99aead02ce521255dd4fd467a8943da2cdf248cd (plain) (blame)
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));
}