1/* 2 * Compatibility mode system call entry point for x86-64. 3 * 4 * Copyright 2000-2002 Andi Kleen, SuSE Labs. 5 */ 6#include "calling.h" 7#include <asm/asm-offsets.h> 8#include <asm/current.h> 9#include <asm/errno.h> 10#include <asm/ia32_unistd.h> 11#include <asm/thread_info.h> 12#include <asm/segment.h> 13#include <asm/irqflags.h> 14#include <asm/asm.h> 15#include <asm/smap.h> 16#include <linux/linkage.h> 17#include <linux/err.h> 18 19 .section .entry.text, "ax" 20 21/* 22 * 32-bit SYSENTER instruction entry. 23 * 24 * SYSENTER loads ss, rsp, cs, and rip from previously programmed MSRs. 25 * IF and VM in rflags are cleared (IOW: interrupts are off). 26 * SYSENTER does not save anything on the stack, 27 * and does not save old rip (!!!) and rflags. 28 * 29 * Arguments: 30 * eax system call number 31 * ebx arg1 32 * ecx arg2 33 * edx arg3 34 * esi arg4 35 * edi arg5 36 * ebp user stack 37 * 0(%ebp) arg6 38 * 39 * This is purely a fast path. For anything complicated we use the int 0x80 40 * path below. We set up a complete hardware stack frame to share code 41 * with the int 0x80 path. 42 */ 43ENTRY(entry_SYSENTER_compat) 44 /* Interrupts are off on entry. */ 45 SWAPGS_UNSAFE_STACK 46 movq PER_CPU_VAR(cpu_current_top_of_stack), %rsp 47 48 /* 49 * User tracing code (ptrace or signal handlers) might assume that 50 * the saved RAX contains a 32-bit number when we're invoking a 32-bit 51 * syscall. Just in case the high bits are nonzero, zero-extend 52 * the syscall number. (This could almost certainly be deleted 53 * with no ill effects.) 54 */ 55 movl %eax, %eax 56 57 /* Construct struct pt_regs on stack */ 58 pushq $__USER32_DS /* pt_regs->ss */ 59 pushq %rbp /* pt_regs->sp (stashed in bp) */ 60 61 /* 62 * Push flags. This is nasty. First, interrupts are currently 63 * off, but we need pt_regs->flags to have IF set. Second, even 64 * if TF was set when SYSENTER started, it's clear by now. We fix 65 * that later using TIF_SINGLESTEP. 66 */ 67 pushfq /* pt_regs->flags (except IF = 0) */ 68 orl $X86_EFLAGS_IF, (%rsp) /* Fix saved flags */ 69 ASM_CLAC /* Clear AC after saving FLAGS */ 70 71 pushq $__USER32_CS /* pt_regs->cs */ 72 xorq %r8,%r8 73 pushq %r8 /* pt_regs->ip = 0 (placeholder) */ 74 pushq %rax /* pt_regs->orig_ax */ 75 pushq %rdi /* pt_regs->di */ 76 pushq %rsi /* pt_regs->si */ 77 pushq %rdx /* pt_regs->dx */ 78 pushq %rcx /* pt_regs->cx */ 79 pushq $-ENOSYS /* pt_regs->ax */ 80 pushq %r8 /* pt_regs->r8 = 0 */ 81 pushq %r8 /* pt_regs->r9 = 0 */ 82 pushq %r8 /* pt_regs->r10 = 0 */ 83 pushq %r8 /* pt_regs->r11 = 0 */ 84 pushq %rbx /* pt_regs->rbx */ 85 pushq %rbp /* pt_regs->rbp (will be overwritten) */ 86 pushq %r8 /* pt_regs->r12 = 0 */ 87 pushq %r8 /* pt_regs->r13 = 0 */ 88 pushq %r8 /* pt_regs->r14 = 0 */ 89 pushq %r8 /* pt_regs->r15 = 0 */ 90 cld 91 92 /* 93 * Sysenter doesn't filter flags, so we need to clear NT 94 * ourselves. To save a few cycles, we can check whether 95 * NT was set instead of doing an unconditional popfq. 96 * This needs to happen before enabling interrupts so that 97 * we don't get preempted with NT set. 98 * 99 * NB.: .Lsysenter_fix_flags is a label with the code under it moved 100 * out-of-line as an optimization: NT is unlikely to be set in the 101 * majority of the cases and instead of polluting the I$ unnecessarily, 102 * we're keeping that code behind a branch which will predict as 103 * not-taken and therefore its instructions won't be fetched. 104 */ 105 testl $X86_EFLAGS_NT, EFLAGS(%rsp) 106 jnz .Lsysenter_fix_flags 107.Lsysenter_flags_fixed: 108 109 /* 110 * User mode is traced as though IRQs are on, and SYSENTER 111 * turned them off. 112 */ 113 TRACE_IRQS_OFF 114 115 movq %rsp, %rdi 116 call do_fast_syscall_32 117 /* XEN PV guests always use IRET path */ 118 ALTERNATIVE "testl %eax, %eax; jz .Lsyscall_32_done", \ 119 "jmp .Lsyscall_32_done", X86_FEATURE_XENPV 120 jmp sysret32_from_system_call 121 122.Lsysenter_fix_flags: 123 pushq $X86_EFLAGS_FIXED 124 popfq 125 jmp .Lsysenter_flags_fixed 126ENDPROC(entry_SYSENTER_compat) 127 128/* 129 * 32-bit SYSCALL instruction entry. 130 * 131 * 32-bit SYSCALL saves rip to rcx, clears rflags.RF, then saves rflags to r11, 132 * then loads new ss, cs, and rip from previously programmed MSRs. 133 * rflags gets masked by a value from another MSR (so CLD and CLAC 134 * are not needed). SYSCALL does not save anything on the stack 135 * and does not change rsp. 136 * 137 * Note: rflags saving+masking-with-MSR happens only in Long mode 138 * (in legacy 32-bit mode, IF, RF and VM bits are cleared and that's it). 139 * Don't get confused: rflags saving+masking depends on Long Mode Active bit 140 * (EFER.LMA=1), NOT on bitness of userspace where SYSCALL executes 141 * or target CS descriptor's L bit (SYSCALL does not read segment descriptors). 142 * 143 * Arguments: 144 * eax system call number 145 * ecx return address 146 * ebx arg1 147 * ebp arg2 (note: not saved in the stack frame, should not be touched) 148 * edx arg3 149 * esi arg4 150 * edi arg5 151 * esp user stack 152 * 0(%esp) arg6 153 */ 154ENTRY(entry_SYSCALL_compat) 155 /* Interrupts are off on entry. */ 156 SWAPGS_UNSAFE_STACK 157 158 /* Stash user ESP and switch to the kernel stack. */ 159 movl %esp, %r8d 160 movq PER_CPU_VAR(cpu_current_top_of_stack), %rsp 161 162 /* Zero-extending 32-bit regs, do not remove */ 163 movl %eax, %eax 164 165 /* Construct struct pt_regs on stack */ 166 pushq $__USER32_DS /* pt_regs->ss */ 167 pushq %r8 /* pt_regs->sp */ 168 pushq %r11 /* pt_regs->flags */ 169 pushq $__USER32_CS /* pt_regs->cs */ 170 pushq %rcx /* pt_regs->ip */ 171 pushq %rax /* pt_regs->orig_ax */ 172 pushq %rdi /* pt_regs->di */ 173 pushq %rsi /* pt_regs->si */ 174 pushq %rdx /* pt_regs->dx */ 175 pushq %rbp /* pt_regs->cx (stashed in bp) */ 176 pushq $-ENOSYS /* pt_regs->ax */ 177 xorq %r8,%r8 178 pushq %r8 /* pt_regs->r8 = 0 */ 179 pushq %r8 /* pt_regs->r9 = 0 */ 180 pushq %r8 /* pt_regs->r10 = 0 */ 181 pushq %r8 /* pt_regs->r11 = 0 */ 182 pushq %rbx /* pt_regs->rbx */ 183 pushq %rbp /* pt_regs->rbp (will be overwritten) */ 184 pushq %r8 /* pt_regs->r12 = 0 */ 185 pushq %r8 /* pt_regs->r13 = 0 */ 186 pushq %r8 /* pt_regs->r14 = 0 */ 187 pushq %r8 /* pt_regs->r15 = 0 */ 188 189 /* 190 * User mode is traced as though IRQs are on, and SYSENTER 191 * turned them off. 192 */ 193 TRACE_IRQS_OFF 194 195 movq %rsp, %rdi 196 call do_fast_syscall_32 197 /* XEN PV guests always use IRET path */ 198 ALTERNATIVE "testl %eax, %eax; jz .Lsyscall_32_done", \ 199 "jmp .Lsyscall_32_done", X86_FEATURE_XENPV 200 201 /* Opportunistic SYSRET */ 202sysret32_from_system_call: 203 TRACE_IRQS_ON /* User mode traces as IRQs on. */ 204 movq RBX(%rsp), %rbx /* pt_regs->rbx */ 205 movq RBP(%rsp), %rbp /* pt_regs->rbp */ 206 movq EFLAGS(%rsp), %r11 /* pt_regs->flags (in r11) */ 207 movq RIP(%rsp), %rcx /* pt_regs->ip (in rcx) */ 208 addq $RAX, %rsp /* Skip r8-r15 */ 209 popq %rax /* pt_regs->rax */ 210 popq %rdx /* Skip pt_regs->cx */ 211 popq %rdx /* pt_regs->dx */ 212 popq %rsi /* pt_regs->si */ 213 popq %rdi /* pt_regs->di */ 214 215 /* 216 * USERGS_SYSRET32 does: 217 * GSBASE = user's GS base 218 * EIP = ECX 219 * RFLAGS = R11 220 * CS = __USER32_CS 221 * SS = __USER_DS 222 * 223 * ECX will not match pt_regs->cx, but we're returning to a vDSO 224 * trampoline that will fix up RCX, so this is okay. 225 * 226 * R12-R15 are callee-saved, so they contain whatever was in them 227 * when the system call started, which is already known to user 228 * code. We zero R8-R10 to avoid info leaks. 229 */ 230 xorq %r8, %r8 231 xorq %r9, %r9 232 xorq %r10, %r10 233 movq RSP-ORIG_RAX(%rsp), %rsp 234 swapgs 235 sysretl 236END(entry_SYSCALL_compat) 237 238/* 239 * Emulated IA32 system calls via int 0x80. 240 * 241 * Arguments: 242 * eax system call number 243 * ebx arg1 244 * ecx arg2 245 * edx arg3 246 * esi arg4 247 * edi arg5 248 * ebp arg6 (note: not saved in the stack frame, should not be touched) 249 * 250 * Notes: 251 * Uses the same stack frame as the x86-64 version. 252 * All registers except eax must be saved (but ptrace may violate that). 253 * Arguments are zero extended. For system calls that want sign extension and 254 * take long arguments a wrapper is needed. Most calls can just be called 255 * directly. 256 * Assumes it is only called from user space and entered with interrupts off. 257 */ 258 259ENTRY(entry_INT80_compat) 260 /* 261 * Interrupts are off on entry. 262 */ 263 PARAVIRT_ADJUST_EXCEPTION_FRAME 264 SWAPGS 265 266 /* 267 * User tracing code (ptrace or signal handlers) might assume that 268 * the saved RAX contains a 32-bit number when we're invoking a 32-bit 269 * syscall. Just in case the high bits are nonzero, zero-extend 270 * the syscall number. (This could almost certainly be deleted 271 * with no ill effects.) 272 */ 273 movl %eax, %eax 274 275 /* Construct struct pt_regs on stack (iret frame is already on stack) */ 276 pushq %rax /* pt_regs->orig_ax */ 277 pushq %rdi /* pt_regs->di */ 278 pushq %rsi /* pt_regs->si */ 279 pushq %rdx /* pt_regs->dx */ 280 pushq %rcx /* pt_regs->cx */ 281 pushq $-ENOSYS /* pt_regs->ax */ 282 xorq %r8,%r8 283 pushq %r8 /* pt_regs->r8 = 0 */ 284 pushq %r8 /* pt_regs->r9 = 0 */ 285 pushq %r8 /* pt_regs->r10 = 0 */ 286 pushq %r8 /* pt_regs->r11 = 0 */ 287 pushq %rbx /* pt_regs->rbx */ 288 pushq %rbp /* pt_regs->rbp */ 289 pushq %r12 /* pt_regs->r12 */ 290 pushq %r13 /* pt_regs->r13 */ 291 pushq %r14 /* pt_regs->r14 */ 292 pushq %r15 /* pt_regs->r15 */ 293 cld 294 295 /* 296 * User mode is traced as though IRQs are on, and the interrupt 297 * gate turned them off. 298 */ 299 TRACE_IRQS_OFF 300 301 movq %rsp, %rdi 302 call do_syscall_32_irqs_off 303.Lsyscall_32_done: 304 305 /* Go back to user mode. */ 306 TRACE_IRQS_ON 307 SWAPGS 308 jmp restore_regs_and_iret 309END(entry_INT80_compat) 310 311 ALIGN 312GLOBAL(stub32_clone) 313 /* 314 * The 32-bit clone ABI is: clone(..., int tls_val, int *child_tidptr). 315 * The 64-bit clone ABI is: clone(..., int *child_tidptr, int tls_val). 316 * 317 * The native 64-bit kernel's sys_clone() implements the latter, 318 * so we need to swap arguments here before calling it: 319 */ 320 xchg %r8, %rcx 321 jmp sys_clone 322