1 2/*--------------------------------------------------------------------*/ 3/*--- Support for doing system calls. syscall-amd64-linux.S ---*/ 4/*--------------------------------------------------------------------*/ 5 6/* 7 This file is part of Valgrind, a dynamic binary instrumentation 8 framework. 9 10 Copyright (C) 2000-2017 Julian Seward 11 jseward@acm.org 12 13 This program is free software; you can redistribute it and/or 14 modify it under the terms of the GNU General Public License as 15 published by the Free Software Foundation; either version 2 of the 16 License, or (at your option) any later version. 17 18 This program is distributed in the hope that it will be useful, but 19 WITHOUT ANY WARRANTY; without even the implied warranty of 20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 21 General Public License for more details. 22 23 You should have received a copy of the GNU General Public License 24 along with this program; if not, write to the Free Software 25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 26 02111-1307, USA. 27 28 The GNU General Public License is contained in the file COPYING. 29*/ 30 31#include "pub_core_basics_asm.h" 32 33#if defined(VGP_amd64_linux) 34 35#include "pub_core_vkiscnums_asm.h" 36#include "libvex_guest_offsets.h" 37 38 39/*----------------------------------------------------------------*/ 40/* 41 Perform a syscall for the client. This will run a syscall 42 with the client's specific per-thread signal mask. 43 44 The structure of this function is such that, if the syscall is 45 interrupted by a signal, we can determine exactly what 46 execution state we were in with respect to the execution of 47 the syscall by examining the value of %eip in the signal 48 handler. This means that we can always do the appropriate 49 thing to precisely emulate the kernel's signal/syscall 50 interactions. 51 52 The syscall number is taken from the argument, even though it 53 should also be in guest_state->guest_RAX. The syscall result 54 is written back to guest_state->guest_RAX on completion. 55 56 Returns 0 if the syscall was successfully called (even if the 57 syscall itself failed), or a -ve error code if one of the 58 sigprocmasks failed (there's no way to determine which one 59 failed). 60 61 VG_(fixup_guest_state_after_syscall_interrupted) does the 62 thread state fixup in the case where we were interrupted by a 63 signal. 64 65 Prototype: 66 67 Int ML_(do_syscall_for_client_WRK( 68 Int syscallno, // rdi 69 void* guest_state, // rsi 70 const vki_sigset_t *sysmask, // rdx 71 const vki_sigset_t *postmask, // rcx 72 Int sigsetSzB) // r8 73 74*/ 75 76/* from vki_arch.h */ 77#define VKI_SIG_SETMASK 2 78 79.globl ML_(do_syscall_for_client_WRK) 80ML_(do_syscall_for_client_WRK): 81 .cfi_startproc 82 /* save callee-saved regs */ 83 pushq %rbx 84 .cfi_adjust_cfa_offset 8 85 .cfi_offset %rbx, -16 86 pushq %rbp 87 .cfi_adjust_cfa_offset 8 88 .cfi_offset %rbp, -24 89 pushq %r12 90 .cfi_adjust_cfa_offset 8 91 .cfi_offset %r12, -32 92 pushq %r13 93 .cfi_adjust_cfa_offset 8 94 .cfi_offset %r13, -40 95 pushq %r14 96 .cfi_adjust_cfa_offset 8 97 .cfi_offset %r14, -48 98 pushq %r15 99 .cfi_adjust_cfa_offset 8 100 .cfi_offset %r15, -56 101 102#define FSZ ((4+1)*4) /* 4 args + ret addr */ 103 104#define PUSH_di_si_dx_cx_8 \ 105 pushq %rdi ; \ 106 .cfi_adjust_cfa_offset 8 ; \ 107 pushq %rsi ; \ 108 .cfi_adjust_cfa_offset 8 ; \ 109 pushq %rdx ; \ 110 .cfi_adjust_cfa_offset 8 ; \ 111 pushq %rcx ; \ 112 .cfi_adjust_cfa_offset 8 ; \ 113 pushq %r8 ; \ 114 .cfi_adjust_cfa_offset 8 115 116#define POP_di_si_dx_cx_8 \ 117 popq %r8 ; \ 118 .cfi_adjust_cfa_offset -8 ; \ 119 popq %rcx ; \ 120 .cfi_adjust_cfa_offset -8 ; \ 121 popq %rdx ; \ 122 .cfi_adjust_cfa_offset -8 ; \ 123 popq %rsi ; \ 124 .cfi_adjust_cfa_offset -8 ; \ 125 popq %rdi ; \ 126 .cfi_adjust_cfa_offset -8 127 1281: /* Even though we can't take a signal until the sigprocmask completes, 129 start the range early. 130 If eip is in the range [1,2), the syscall hasn't been started yet */ 131 132 /* Set the signal mask which should be current during the syscall. */ 133 /* Save and restore all 5 arg regs round the call. This is easier 134 than figuring out the minimal set to save/restore. */ 135 136 PUSH_di_si_dx_cx_8 137 138 movq $__NR_rt_sigprocmask, %rax // syscall # 139 movq $VKI_SIG_SETMASK, %rdi // how 140 movq %rdx, %rsi // sysmask 141 movq %rcx, %rdx // postmask 142 movq %r8, %r10 // sigsetSzB 143 syscall 144 145 POP_di_si_dx_cx_8 146 147 testq %rax, %rax 148 js 7f /* sigprocmask failed */ 149 150 /* OK, that worked. Now do the syscall proper. */ 151 152 PUSH_di_si_dx_cx_8 153 154 movq %rsi, %rax /* rax --> VexGuestAMD64State * */ 155 pushq %rdi /* syscallno -> stack */ 156 .cfi_adjust_cfa_offset 8 157 movq OFFSET_amd64_RDI(%rax), %rdi 158 movq OFFSET_amd64_RSI(%rax), %rsi 159 movq OFFSET_amd64_RDX(%rax), %rdx 160 movq OFFSET_amd64_R10(%rax), %r10 161 movq OFFSET_amd64_R8(%rax), %r8 162 movq OFFSET_amd64_R9(%rax), %r9 163 popq %rax /* syscallno -> %rax */ 164 .cfi_adjust_cfa_offset -8 165 166 /* If rip==2, then the syscall was either just about 167 to start, or was interrupted and the kernel was 168 restarting it. */ 1692: syscall 1703: /* In the range [3, 4), the syscall result is in %rax, 171 but hasn't been committed to RAX. */ 172 173 POP_di_si_dx_cx_8 174 175 movq %rax, OFFSET_amd64_RAX(%rsi) /* save back to RAX */ 176 1774: /* Re-block signals. If eip is in [4,5), then the syscall 178 is complete and we needn't worry about it. */ 179 180 PUSH_di_si_dx_cx_8 181 182 movq $__NR_rt_sigprocmask, %rax // syscall # 183 movq $VKI_SIG_SETMASK, %rdi // how 184 movq %rcx, %rsi // postmask 185 xorq %rdx, %rdx // NULL 186 movq %r8, %r10 // sigsetSzB 187 syscall 188 189 POP_di_si_dx_cx_8 190 191 testq %rax, %rax 192 js 7f /* sigprocmask failed */ 193 1945: /* now safe from signals */ 195 movq $0, %rax /* SUCCESS */ 196 popq %r15 197 .cfi_adjust_cfa_offset -8 198 popq %r14 199 .cfi_adjust_cfa_offset -8 200 popq %r13 201 .cfi_adjust_cfa_offset -8 202 popq %r12 203 .cfi_adjust_cfa_offset -8 204 popq %rbp 205 .cfi_adjust_cfa_offset -8 206 popq %rbx 207 .cfi_adjust_cfa_offset -8 208 ret 209 .cfi_adjust_cfa_offset 6*8 210 2117: /* failure: return 0x8000 | error code */ 212 negq %rax 213 andq $0x7FFF, %rax 214 orq $0x8000, %rax 215 popq %r15 216 .cfi_adjust_cfa_offset -8 217 popq %r14 218 .cfi_adjust_cfa_offset -8 219 popq %r13 220 .cfi_adjust_cfa_offset -8 221 popq %r12 222 .cfi_adjust_cfa_offset -8 223 popq %rbp 224 .cfi_adjust_cfa_offset -8 225 popq %rbx 226 .cfi_adjust_cfa_offset -8 227 ret 228 .cfi_endproc 229#undef FSZ 230 231.section .rodata 232/* export the ranges so that 233 VG_(fixup_guest_state_after_syscall_interrupted) can do the 234 right thing */ 235 236.globl ML_(blksys_setup) 237.globl ML_(blksys_restart) 238.globl ML_(blksys_complete) 239.globl ML_(blksys_committed) 240.globl ML_(blksys_finished) 241ML_(blksys_setup): .quad 1b 242ML_(blksys_restart): .quad 2b 243ML_(blksys_complete): .quad 3b 244ML_(blksys_committed): .quad 4b 245ML_(blksys_finished): .quad 5b 246.previous 247 248#endif // defined(VGP_amd64_linux) 249 250/* Let the linker know we don't need an executable stack */ 251MARK_STACK_NO_EXEC 252 253/*--------------------------------------------------------------------*/ 254/*--- end ---*/ 255/*--------------------------------------------------------------------*/ 256