/*----------------------------------------------------------------*/ /* Perform a syscall for the client. This will run a syscall with the client's specific per-thread signal mask. The structure of this function is such that, if the syscall is interrupted by a signal, we can determine exactly what execution state we were in with respect to the execution of the syscall by examining the value of %eip in the signal handler. This means that we can always do the appropriate thing to precisely emulate the kernel's signal/syscall interactions. The syscall number is taken from the argument, even though it should also be in regs->m_eax. The syscall result is written back to regs->m_eax on completion. Returns 0 if the syscall was successfully called (even if the syscall itself failed), or a nonzero error code in the lowest 8 bits if one of the sigprocmasks failed (there's no way to determine which one failed). And there's no obvious way to recover from that either, but nevertheless we want to know. VG_(fixup_guest_state_after_syscall_interrupted) does the thread state fixup in the case where we were interrupted by a signal. Prototype: UWord ML_(do_syscall_for_client_WRK)( Int syscallno, // 0 void* guest_state, // 4 const vki_sigset_t *sysmask, // 8 const vki_sigset_t *postmask, // 12 Int nsigwords) // 16 */ /* from vki_arch.h */ #define VKI_SIG_SETMASK 2 /* QQQ translate syscall abi conventions */ .globl ML_(do_syscall_for_client_WRK) ML_(do_syscall_for_client_WRK): /* save callee-saved regs */ push %esi push %edi push %ebx push %ebp #define FSZ ((4+1)*4) /* 4 args + ret addr */ 1: /* Even though we can't take a signal until the sigprocmask completes, start the range early. If eip is in the range [1,2], the syscall hasn't been started yet */ /* Set the signal mask which should be current during the syscall. */ movl $__NR_sigprocmask, %eax movl $VKI_SIG_SETMASK, %ebx movl 8+FSZ(%esp), %ecx movl 12+FSZ(%esp), %edx movl 16+FSZ(%esp), %esi subl $4, %esp /* fake return address */ int $0x80 addl $4, %esp /* fake return address */ jb 7f /* sigprocmask failed */ /* sc 1 2 3 4 5 6 ret x86 eax ebx ecx edx esi edi ebp eax (== NUM) */ /* Do extra special magic here to copy the stack based args that can be in any of three formats. */ subl $(9*4), %esp /* space for 8 args plus ret addr */ movl (9*4)+0+FSZ(%esp), %eax /* syscall number */ cmpl $198, %eax /* 198 = __syscall(2) */ jne 11f /* do __syscall copy. __syscall takes max 10 args! 1st is syscall number. 2 is padding */ movl (9*4)+4+FSZ(%esp), %eax /* eax == ThreadState * */ movl OFFSET_x86_ESP(%eax), %ebx movl 4(%ebx), %eax /* use syscallno from stack args */ /* copy 8 args, skipping first two */ movl 12(%ebx), %ecx movl 16(%ebx), %edx movl 20(%ebx), %esi movl 24(%ebx), %edi movl %ecx, 4(%esp) movl %edx, 8(%esp) movl %esi, 12(%esp) movl %edi, 16(%esp) movl 28(%ebx), %ecx movl 32(%ebx), %edx movl 36(%ebx), %esi movl 40(%ebx), %edi movl %ecx, 20(%esp) movl %edx, 24(%esp) movl %esi, 28(%esp) movl %edi, 32(%esp) jmp 2f 11: testl %eax, %eax /* 0 = syscall(2) */ jne 12f /* do syscall copy. syscall takes max 9 args! 1st is syscall number and is skipped */ movl (9*4)+4+FSZ(%esp), %eax /* eax == ThreadState * */ movl OFFSET_x86_ESP(%eax), %ebx movl 4(%ebx), %eax /* use syscallno from stack args */ /* copy 8 args, skipping first one */ movl 8(%ebx), %ecx movl 12(%ebx), %edx movl 16(%ebx), %esi movl 20(%ebx), %edi movl %ecx, 4(%esp) movl %edx, 8(%esp) movl %esi, 12(%esp) movl %edi, 16(%esp) movl 24(%ebx), %ecx movl 28(%ebx), %edx movl 32(%ebx), %esi movl 36(%ebx), %edi movl %ecx, 20(%esp) movl %edx, 24(%esp) movl %esi, 28(%esp) movl %edi, 32(%esp) hlt jmp 2f 12: /* regular syscall */ movl (9*4)+4+FSZ(%esp), %eax /* eax == ThreadState * */ movl OFFSET_x86_ESP(%eax), %ebx movl (9*4)+0+FSZ(%esp), %eax /* use syscallno argument rather than thread EAX */ /* copy 8 args */ movl 4(%ebx), %ecx movl 8(%ebx), %edx movl 12(%ebx), %esi movl 16(%ebx), %edi movl %ecx, 4(%esp) movl %edx, 8(%esp) movl %esi, 12(%esp) movl %edi, 16(%esp) movl 20(%ebx), %ecx movl 24(%ebx), %edx movl 28(%ebx), %esi movl 32(%ebx), %edi movl %ecx, 20(%esp) movl %edx, 24(%esp) movl %esi, 28(%esp) movl %edi, 32(%esp) /* If eip==2, then the syscall was either just about to start, or was interrupted and the kernel was restarting it. */ 2: int $0x80 3: /* In the range [3, 4], the syscall result is in %eax, but hasn't been committed to EAX. */ jb 31f /* failed! */ movl (9*4)+4+FSZ(%esp), %ebx movl %eax, OFFSET_x86_EAX(%ebx) /* save back to EAX */ addl $(9*4), %esp /* fake return address */ pushl %ebx /* guest state * */ pushl $0 /* carry true */ /* XXX leaves %eip space that sniffer is looking for!! */ call LibVEX_GuestX86_put_eflag_c addl $8, %esp jmp 4f 31: /* have to export failed carry state */ movl (9*4)+4+FSZ(%esp), %ebx movl %eax, OFFSET_x86_EAX(%ebx) /* save back to EAX */ addl $(9*4), %esp /* fake return address */ pushl %ebx /* guest state * */ pushl $1 /* carry true */ /* XXX leaves %eip space that sniffer is looking for!! */ call LibVEX_GuestX86_put_eflag_c addl $8, %esp 4: /* Re-block signals. If eip is in [4,5], then the syscall is complete and we needn't worry about it. */ movl $__NR_sigprocmask, %eax movl $VKI_SIG_SETMASK, %ebx movl 12+FSZ(%esp), %ecx xorl %edx, %edx movl 16+FSZ(%esp), %esi subl $4, %esp /* fake return address */ int $0x80 addl $4, %esp /* fake return address */ jb 7f /* sigprocmask failed */ 5: /* now safe from signals */ movl $0, %eax /* SUCCESS */ popl %ebp popl %ebx popl %edi popl %esi ret 7: /* failure: return 0x8000 | error code */ orl $0x8000, %eax popl %ebp popl %ebx popl %edi popl %esi ret #undef FSZ