//! 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_clone, ztrace_gate_end \\ .hidden ztrace_gate_sigreturn, ztrace_gate_restorer, ztrace_gate_syscall, ztrace_gate_clone, 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_clone: \\ pushq %rbx \\ pushq %r12 \\ movq 32(%rsp), %rbx \\ movq 40(%rsp), %r12 \\ movq %rdi, %rax \\ movq %rsi, %rdi \\ movq %rdx, %rsi \\ movq %rcx, %rdx \\ movq %r8, %r10 \\ movq %r9, %r8 \\ movq 24(%rsp), %r9 \\ syscall \\ testq %rax, %rax \\ jz 1f \\ popq %r12 \\ popq %rbx \\ retq \\ 1: movq %rsp, %rdx \\ andq $-16, %rsp \\ subq $112, %rsp \\ movq %rbx, %rdi \\ movq %rsp, %rsi \\ callq *%r12 \\ popq %r8 \\ popq %r9 \\ popq %r10 \\ popq %r12 \\ popq %r13 \\ popq %r14 \\ popq %r15 \\ popq %rdi \\ popq %rsi \\ popq %rbp \\ popq %rbx \\ popq %rdx \\ popq %rcx \\ popq %rsp \\ xorl %eax, %eax \\ jmpq *%rcx \\ 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; /// A clone-family syscall whose child cannot come back the way its parent /// does (another stack, or its parent's own). The parent returns like /// `ztrace_gate_syscall`. The child calls `start(context, regs, sp)` on the /// stack it was given, then continues with the fourteen registers `start` /// wrote (r8 r9 r10 r12 r13 r14 r15 rdi rsi rbp rbx rdx, then the /// instruction pointer and the stack pointer) and 0 in rax: where the /// target's own clone would have returned. pub extern fn ztrace_gate_clone(number: u64, a0: u64, a1: u64, a2: u64, a3: u64, a4: u64, a5: u64, context: *anyopaque, start: *const anyopaque) 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. On the alternate stack, where the thread has one. 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 | linux.SA.ONSTACK, .restorer = @ptrCast(&ztrace_gate_restorer), .mask = linux.sigemptyset(), }; _ = linux.syscall4(.rt_sigaction, @intFromEnum(sig), @intFromPtr(&act), 0, @sizeOf(linux.sigset_t)); }