code review 4817054: runtime, syscall: use the vdso page on linux x86 for fa...

src/pkg/runtime/linux/386/sys.s

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 //
 // System calls and other sys.stuff for 386, Linux
 //
 
 #include "386/asm.h"
 
 TEXT runtime·exit(SB),7,$0
         MOVL    $252, AX        // syscall number
         MOVL    4(SP), BX
-        VDSO_SYSENTER
+        CALL    *runtime·_vdso(SB)
         INT $3  // not reached
         RET
 
 TEXT runtime·exit1(SB),7,$0
         MOVL    $1, AX  // exit - exit the current os thread
         MOVL    4(SP), BX
-        VDSO_SYSENTER
+        CALL    *runtime·_vdso(SB)
         INT $3  // not reached
+        RET
+
+TEXT runtime·open(SB),7,$0
+        MOVL    $5, AX          // syscall - open
+        MOVL    4(SP), BX
+        MOVL    8(SP), CX
+        MOVL    12(SP), DX
+        CALL    *runtime·_vdso(SB)
+        RET
+
+TEXT runtime·close(SB),7,$0
+        MOVL    $6, AX          // syscall - close
+        MOVL    4(SP), BX
+        CALL    *runtime·_vdso(SB)
         RET
 
 TEXT runtime·write(SB),7,$0
         MOVL    $4, AX          // syscall - write
-        MOVL    4(SP),  BX
-        MOVL    8(SP), CX
-        MOVL    12(SP), DX
-        VDSO_SYSENTER
+        MOVL    4(SP), BX
+        MOVL    8(SP), CX
+        MOVL    12(SP), DX
+        CALL    *runtime·_vdso(SB)
+        RET
+
+TEXT runtime·read(SB),7,$0
+        MOVL    $3, AX          // syscall - read
+        MOVL    4(SP), BX
+        MOVL    8(SP), CX
+        MOVL    12(SP), DX
+        CALL    *runtime·_vdso(SB)
         RET
 
 TEXT runtime·raisesigpipe(SB),7,$12
         MOVL    $224, AX        // syscall - gettid
-        VDSO_SYSENTER
+        CALL    *runtime·_vdso(SB)
         MOVL    AX, 0(SP)       // arg 1 tid
         MOVL    $13, 4(SP)      // arg 2 SIGPIPE
         MOVL    $238, AX        // syscall - tkill
-        VDSO_SYSENTER
+        CALL    *runtime·_vdso(SB)
         RET
 
 TEXT runtime·setitimer(SB),7,$0-24
         MOVL    $104, AX                        // syscall - setitimer
         MOVL    4(SP), BX
         MOVL    8(SP), CX
         MOVL    12(SP), DX
-        VDSO_SYSENTER
+        CALL    *runtime·_vdso(SB)
         RET
 
 TEXT runtime·mincore(SB),7,$0-24
         MOVL    $218, AX                        // syscall - mincore
         MOVL    4(SP), BX
         MOVL    8(SP), CX
         MOVL    12(SP), DX
-        VDSO_SYSENTER
+        CALL    *runtime·_vdso(SB)
         RET
 
 TEXT runtime·gettime(SB), 7, $32
         MOVL    $78, AX                 // syscall - gettimeofday
         LEAL    8(SP), BX
         MOVL    $0, CX
         MOVL    $0, DX
-        VDSO_SYSENTER
+        CALL    *runtime·_vdso(SB)
 
         MOVL    8(SP), BX       // sec
         MOVL    sec+0(FP), DI
         MOVL    BX, (DI)
         MOVL    $0, 4(DI)       // zero extend 32 -> 64 bits
 
         MOVL    12(SP), BX      // usec
         MOVL    usec+4(FP), DI
         MOVL    BX, (DI)
         RET
 
 TEXT runtime·rt_sigaction(SB),7,$0
         MOVL    $174, AX                // syscall - rt_sigaction
         MOVL    4(SP), BX
         MOVL    8(SP), CX
         MOVL    12(SP), DX
         MOVL    16(SP), SI
-        VDSO_SYSENTER
+        CALL    *runtime·_vdso(SB)
         RET
 
 TEXT runtime·sigtramp(SB),7,$44
         get_tls(CX)
 ········
         // save g
         MOVL    g(CX), DI
         MOVL    DI, 20(SP)
 ········
         // g = m->gsignal
@@ skipping 17 matching lines @@
         MOVL    20(SP), BX
         MOVL    BX, g(CX)
 ········
         RET
 
 TEXT runtime·sigignore(SB),7,$0
         RET
 
 TEXT runtime·sigreturn(SB),7,$0
         MOVL    $173, AX        // rt_sigreturn
+        // Sigreturn expects same SP as signal handler,
+        // so cannot CALL *runtime._vsdo(SB) here.
         INT     $0x80

[paulzhol, 2011/07/27 14:34:34]

using VDSO_SYSENTER instead causes http/cgi test to fail (SIGPIPE)

[rsc, 2011/08/03 20:15:04]

Please put that in a comment in the file.
I can believe that you have to INT $0x80 to
sigreturn.  Sigreturn is magic.

         INT $3  // not reached
         RET
 
 TEXT runtime·mmap(SB),7,$0
         MOVL    $192, AX        // mmap2
         MOVL    4(SP), BX
         MOVL    8(SP), CX
         MOVL    12(SP), DX
         MOVL    16(SP), SI
         MOVL    20(SP), DI
         MOVL    24(SP), BP
         SHRL    $12, BP
-        VDSO_SYSENTER
+        CALL    *runtime·_vdso(SB)
         CMPL    AX, $0xfffff001
         JLS     3(PC)
         NOTL    AX
         INCL    AX
         RET
 
 TEXT runtime·munmap(SB),7,$0
         MOVL    $91, AX // munmap
         MOVL    4(SP), BX
         MOVL    8(SP), CX
-        VDSO_SYSENTER
+        CALL    *runtime·_vdso(SB)
         CMPL    AX, $0xfffff001
         JLS     2(PC)
         INT $3
         RET
 
 // int32 futex(int32 *uaddr, int32 op, int32 val,
 //      struct timespec *timeout, int32 *uaddr2, int32 val2);
 TEXT runtime·futex(SB),7,$0
         MOVL    $240, AX        // futex
         MOVL    4(SP), BX
         MOVL    8(SP), CX
         MOVL    12(SP), DX
         MOVL    16(SP), SI
         MOVL    20(SP), DI
         MOVL    24(SP), BP
-        VDSO_SYSENTER
+        CALL    *runtime·_vdso(SB)
         RET
 
 // int32 clone(int32 flags, void *stack, M *m, G *g, void (*fn)(void));
 TEXT runtime·clone(SB),7,$0
         MOVL    $120, AX        // clone
         MOVL    flags+4(SP), BX
         MOVL    stack+8(SP), CX
         MOVL    $0, DX  // parent tid ptr
         MOVL    $0, DI  // child tid ptr
 
         // Copy m, g, fn off parent stack for use by child.
         SUBL    $16, CX
         MOVL    mm+12(SP), SI
         MOVL    SI, 0(CX)
         MOVL    gg+16(SP), SI
         MOVL    SI, 4(CX)
         MOVL    fn+20(SP), SI
         MOVL    SI, 8(CX)
         MOVL    $1234, 12(CX)
 
+        // cannot use CALL *runtime·_vdso(SB) here, because
+        // the stack changes during the system call (after·
+        // CALL *runtime·_vdso(SB), the child is still using
+        // the parent's stack when executing its RET instruction).
         INT     $0x80

[paulzhol, 2011/07/27 14:34:34]

using VDSO_SYSENTER instead causes cgo to segfault when building os/user.

[rsc, 2011/08/03 20:15:04]

Add comment here too.
Clone is even more magic, because it returns in the
child on a different stack.  If you throw away the
VDSO_SYSENTER macro and use CALL instructions this will
be clearer:

// Cannot CALL *runtime·vdso(SB) here, because
// the stack changes during the system call
INT $0x80

[paulzhol, 2011/08/05 16:14:23]

Why is the stack change affecting an address in the .data segment? The child
gettid call is working.

 
         // In parent, return.
         CMPL    AX, $0
         JEQ     2(PC)
         RET
 
         // Paranoia: check that SP is as we expect.
         MOVL    12(SP), BP
         CMPL    BP, $1234
         JEQ     2(PC)
         INT     $3
 
         // Initialize AX to Linux tid
         MOVL    $224, AX
-        VDSO_SYSENTER
+        CALL    *runtime·_vdso(SB)
 
         // In child on new stack.  Reload registers (paranoia).
         MOVL    0(SP), BX       // m
         MOVL    4(SP), DX       // g
         MOVL    8(SP), SI       // fn
 
         MOVL    AX, m_procid(BX)        // save tid as m->procid
 
         // set up ldt 7+id to point at m->tls.
         // newosproc left the id in tls[0].
@@ skipping 27 matching lines @@
 
         CALL    SI      // fn()
         CALL    runtime·exit1(SB)
         MOVL    $0x1234, 0x1005
         RET
 
 TEXT runtime·sigaltstack(SB),7,$-8
         MOVL    $186, AX        // sigaltstack
         MOVL    new+4(SP), BX
         MOVL    old+8(SP), CX
-        VDSO_SYSENTER
+        CALL    *runtime·_vdso(SB)
         CMPL    AX, $0xfffff001
         JLS     2(PC)
         INT     $3
         RET
 
 // <asm-i386/ldt.h>
 // struct user_desc {
 //      unsigned int  entry_number;
 //      unsigned long base_addr;
 //      unsigned int  limit;
@@ skipping 40 matching lines @@
         MOVL    BX, 0(AX)
         MOVL    CX, 4(AX)
         MOVL    $0xfffff, 8(AX)
         MOVL    $(SEG_32BIT|LIMIT_IN_PAGES|USEABLE|CONTENTS_DATA), 12(AX)       // flag bits
 
         // call modify_ldt
         MOVL    $1, BX  // func = 1 (write)
         MOVL    AX, CX  // user_desc
         MOVL    $16, DX // sizeof(user_desc)
         MOVL    $123, AX        // syscall - modify_ldt
-        VDSO_SYSENTER
+        CALL    *runtime·_vdso(SB)
 
         // breakpoint on error
         CMPL AX, $0xfffff001
         JLS 2(PC)
         INT $3
 
         // compute segment selector - (entry*8+7)
         MOVL    entry+0(FP), AX
         SHLL    $3, AX
         ADDL    $7, AX
         MOVW    AX, GS
 
         RET
+
+TEXT runtime·osyield(SB),7,$0
+        MOVL    $158, AX
+        CALL    *runtime·_vdso(SB)
+        RET