2011-02-22 15:40:40 -07:00
|
|
|
// Copyright 2011 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.
|
|
|
|
|
|
|
|
/*
|
|
|
|
Stack layout parameters.
|
|
|
|
Included both by runtime (compiled via 6c) and linkers (compiled via gcc).
|
|
|
|
|
|
|
|
The per-goroutine g->stackguard is set to point StackGuard bytes
|
|
|
|
above the bottom of the stack. Each function compares its stack
|
|
|
|
pointer against g->stackguard to check for overflow. To cut one
|
|
|
|
instruction from the check sequence for functions with tiny frames,
|
|
|
|
the stack is allowed to protrude StackSmall bytes below the stack
|
|
|
|
guard. Functions with large frames don't bother with the check and
|
|
|
|
always call morestack. The sequences are (for amd64, others are
|
|
|
|
similar):
|
|
|
|
|
|
|
|
guard = g->stackguard
|
|
|
|
frame = function's stack frame size
|
|
|
|
argsize = size of function arguments (call + return)
|
|
|
|
|
|
|
|
stack frame size <= StackSmall:
|
|
|
|
CMPQ guard, SP
|
|
|
|
JHI 3(PC)
|
|
|
|
MOVQ m->morearg, $(argsize << 32)
|
|
|
|
CALL morestack(SB)
|
|
|
|
|
|
|
|
stack frame size > StackSmall but < StackBig
|
|
|
|
LEAQ (frame-StackSmall)(SP), R0
|
|
|
|
CMPQ guard, R0
|
|
|
|
JHI 3(PC)
|
|
|
|
MOVQ m->morearg, $(argsize << 32)
|
|
|
|
CALL morestack(SB)
|
|
|
|
|
|
|
|
stack frame size >= StackBig:
|
|
|
|
MOVQ m->morearg, $((argsize << 32) | frame)
|
|
|
|
CALL morestack(SB)
|
|
|
|
|
|
|
|
The bottom StackGuard - StackSmall bytes are important: there has
|
|
|
|
to be enough room to execute functions that refuse to check for
|
|
|
|
stack overflow, either because they need to be adjacent to the
|
|
|
|
actual caller's frame (deferproc) or because they handle the imminent
|
|
|
|
stack overflow (morestack).
|
|
|
|
|
|
|
|
For example, deferproc might call malloc, which does one of the
|
|
|
|
above checks (without allocating a full frame), which might trigger
|
|
|
|
a call to morestack. This sequence needs to fit in the bottom
|
|
|
|
section of the stack. On amd64, morestack's frame is 40 bytes, and
|
|
|
|
deferproc's frame is 56 bytes. That fits well within the
|
|
|
|
StackGuard - StackSmall = 128 bytes at the bottom.
|
|
|
|
The linkers explore all possible call traces involving non-splitting
|
|
|
|
functions to make sure that this limit cannot be violated.
|
|
|
|
*/
|
|
|
|
|
|
|
|
enum {
|
2011-05-16 14:57:49 -06:00
|
|
|
// StackSystem is a number of additional bytes to add
|
|
|
|
// to each stack below the usual guard area for OS-specific
|
2013-01-30 03:53:56 -07:00
|
|
|
// purposes like signal handling. Used on Windows and on
|
|
|
|
// Plan 9 because they do not use a separate stack.
|
2011-12-16 13:33:58 -07:00
|
|
|
#ifdef GOOS_windows
|
2011-09-17 04:39:29 -06:00
|
|
|
StackSystem = 512 * sizeof(uintptr),
|
2013-01-30 03:53:56 -07:00
|
|
|
#else
|
|
|
|
#ifdef GOOS_plan9
|
|
|
|
// The size of the note handler frame varies among architectures,
|
|
|
|
// but 512 bytes should be enough for every implementation.
|
|
|
|
StackSystem = 512,
|
2011-05-16 14:57:49 -06:00
|
|
|
#else
|
|
|
|
StackSystem = 0,
|
2013-01-30 03:53:56 -07:00
|
|
|
#endif // Plan 9
|
|
|
|
#endif // Windows
|
2011-05-16 14:57:49 -06:00
|
|
|
|
2011-02-22 15:40:40 -07:00
|
|
|
// The amount of extra stack to allocate beyond the size
|
|
|
|
// needed for the single frame that triggered the split.
|
|
|
|
StackExtra = 1024,
|
|
|
|
|
|
|
|
// The minimum stack segment size to allocate.
|
|
|
|
// If the amount needed for the splitting frame + StackExtra
|
|
|
|
// is less than this number, the stack will have this size instead.
|
|
|
|
StackMin = 4096,
|
2011-07-13 17:13:39 -06:00
|
|
|
FixedStack = StackMin + StackSystem,
|
2011-02-22 15:40:40 -07:00
|
|
|
|
runtime: record proper goroutine state during stack split
Until now, the goroutine state has been scattered during the
execution of newstack and oldstack. It's all there, and those routines
know how to get back to a working goroutine, but other pieces of
the system, like stack traces, do not. If something does interrupt
the newstack or oldstack execution, the rest of the system can't
understand the goroutine. For example, if newstack decides there
is an overflow and calls throw, the stack tracer wouldn't dump the
goroutine correctly.
For newstack to save a useful state snapshot, it needs to be able
to rewind the PC in the function that triggered the split back to
the beginning of the function. (The PC is a few instructions in, just
after the call to morestack.) To make that possible, we change the
prologues to insert a jmp back to the beginning of the function
after the call to morestack. That is, the prologue used to be roughly:
TEXT myfunc
check for split
jmpcond nosplit
call morestack
nosplit:
sub $xxx, sp
Now an extra instruction is inserted after the call:
TEXT myfunc
start:
check for split
jmpcond nosplit
call morestack
jmp start
nosplit:
sub $xxx, sp
The jmp is not executed directly. It is decoded and simulated by
runtime.rewindmorestack to discover the beginning of the function,
and then the call to morestack returns directly to the start label
instead of to the jump instruction. So logically the jmp is still
executed, just not by the cpu.
The prologue thus repeats in the case of a function that needs a
stack split, but against the cost of the split itself, the extra few
instructions are noise. The repeated prologue has the nice effect of
making a stack split double-check that the new stack is big enough:
if morestack happens to return on a too-small stack, we'll now notice
before corruption happens.
The ability for newstack to rewind to the beginning of the function
should help preemption too. If newstack decides that it was called
for preemption instead of a stack split, it now has the goroutine state
correctly paused if rescheduling is needed, and when the goroutine
can run again, it can return to the start label on its original stack
and re-execute the split check.
Here is an example of a split stack overflow showing the full
trace, without any special cases in the stack printer.
(This one was triggered by making the split check incorrect.)
runtime: newstack framesize=0x0 argsize=0x18 sp=0x6aebd0 stack=[0x6b0000, 0x6b0fa0]
morebuf={pc:0x69f5b sp:0x6aebd8 lr:0x0}
sched={pc:0x68880 sp:0x6aebd0 lr:0x0 ctxt:0x34e700}
runtime: split stack overflow: 0x6aebd0 < 0x6b0000
fatal error: runtime: split stack overflow
goroutine 1 [stack split]:
runtime.mallocgc(0x290, 0x100000000, 0x1)
/Users/rsc/g/go/src/pkg/runtime/zmalloc_darwin_amd64.c:21 fp=0x6aebd8
runtime.new()
/Users/rsc/g/go/src/pkg/runtime/zmalloc_darwin_amd64.c:682 +0x5b fp=0x6aec08
go/build.(*Context).Import(0x5ae340, 0xc210030c71, 0xa, 0xc2100b4380, 0x1b, ...)
/Users/rsc/g/go/src/pkg/go/build/build.go:424 +0x3a fp=0x6b00a0
main.loadImport(0xc210030c71, 0xa, 0xc2100b4380, 0x1b, 0xc2100b42c0, ...)
/Users/rsc/g/go/src/cmd/go/pkg.go:249 +0x371 fp=0x6b01a8
main.(*Package).load(0xc21017c800, 0xc2100b42c0, 0xc2101828c0, 0x0, 0x0, ...)
/Users/rsc/g/go/src/cmd/go/pkg.go:431 +0x2801 fp=0x6b0c98
main.loadPackage(0x369040, 0x7, 0xc2100b42c0, 0x0)
/Users/rsc/g/go/src/cmd/go/pkg.go:709 +0x857 fp=0x6b0f80
----- stack segment boundary -----
main.(*builder).action(0xc2100902a0, 0x0, 0x0, 0xc2100e6c00, 0xc2100e5750, ...)
/Users/rsc/g/go/src/cmd/go/build.go:539 +0x437 fp=0x6b14a0
main.(*builder).action(0xc2100902a0, 0x0, 0x0, 0xc21015b400, 0x2, ...)
/Users/rsc/g/go/src/cmd/go/build.go:528 +0x1d2 fp=0x6b1658
main.(*builder).test(0xc2100902a0, 0xc210092000, 0x0, 0x0, 0xc21008ff60, ...)
/Users/rsc/g/go/src/cmd/go/test.go:622 +0x1b53 fp=0x6b1f68
----- stack segment boundary -----
main.runTest(0x5a6b20, 0xc21000a020, 0x2, 0x2)
/Users/rsc/g/go/src/cmd/go/test.go:366 +0xd09 fp=0x6a5cf0
main.main()
/Users/rsc/g/go/src/cmd/go/main.go:161 +0x4f9 fp=0x6a5f78
runtime.main()
/Users/rsc/g/go/src/pkg/runtime/proc.c:183 +0x92 fp=0x6a5fa0
runtime.goexit()
/Users/rsc/g/go/src/pkg/runtime/proc.c:1266 fp=0x6a5fa8
And here is a seg fault during oldstack:
SIGSEGV: segmentation violation
PC=0x1b2a6
runtime.oldstack()
/Users/rsc/g/go/src/pkg/runtime/stack.c:159 +0x76
runtime.lessstack()
/Users/rsc/g/go/src/pkg/runtime/asm_amd64.s:270 +0x22
goroutine 1 [stack unsplit]:
fmt.(*pp).printArg(0x2102e64e0, 0xe5c80, 0x2102c9220, 0x73, 0x0, ...)
/Users/rsc/g/go/src/pkg/fmt/print.go:818 +0x3d3 fp=0x221031e6f8
fmt.(*pp).doPrintf(0x2102e64e0, 0x12fb20, 0x2, 0x221031eb98, 0x1, ...)
/Users/rsc/g/go/src/pkg/fmt/print.go:1183 +0x15cb fp=0x221031eaf0
fmt.Sprintf(0x12fb20, 0x2, 0x221031eb98, 0x1, 0x1, ...)
/Users/rsc/g/go/src/pkg/fmt/print.go:234 +0x67 fp=0x221031eb40
flag.(*stringValue).String(0x2102c9210, 0x1, 0x0)
/Users/rsc/g/go/src/pkg/flag/flag.go:180 +0xb3 fp=0x221031ebb0
flag.(*FlagSet).Var(0x2102f6000, 0x293d38, 0x2102c9210, 0x143490, 0xa, ...)
/Users/rsc/g/go/src/pkg/flag/flag.go:633 +0x40 fp=0x221031eca0
flag.(*FlagSet).StringVar(0x2102f6000, 0x2102c9210, 0x143490, 0xa, 0x12fa60, ...)
/Users/rsc/g/go/src/pkg/flag/flag.go:550 +0x91 fp=0x221031ece8
flag.(*FlagSet).String(0x2102f6000, 0x143490, 0xa, 0x12fa60, 0x0, ...)
/Users/rsc/g/go/src/pkg/flag/flag.go:563 +0x87 fp=0x221031ed38
flag.String(0x143490, 0xa, 0x12fa60, 0x0, 0x161950, ...)
/Users/rsc/g/go/src/pkg/flag/flag.go:570 +0x6b fp=0x221031ed80
testing.init()
/Users/rsc/g/go/src/pkg/testing/testing.go:-531 +0xbb fp=0x221031edc0
strings_test.init()
/Users/rsc/g/go/src/pkg/strings/strings_test.go:1115 +0x62 fp=0x221031ef70
main.init()
strings/_test/_testmain.go:90 +0x3d fp=0x221031ef78
runtime.main()
/Users/rsc/g/go/src/pkg/runtime/proc.c:180 +0x8a fp=0x221031efa0
runtime.goexit()
/Users/rsc/g/go/src/pkg/runtime/proc.c:1269 fp=0x221031efa8
goroutine 2 [runnable]:
runtime.MHeap_Scavenger()
/Users/rsc/g/go/src/pkg/runtime/mheap.c:438
runtime.goexit()
/Users/rsc/g/go/src/pkg/runtime/proc.c:1269
created by runtime.main
/Users/rsc/g/go/src/pkg/runtime/proc.c:166
rax 0x23ccc0
rbx 0x23ccc0
rcx 0x0
rdx 0x38
rdi 0x2102c0170
rsi 0x221032cfe0
rbp 0x221032cfa0
rsp 0x7fff5fbff5b0
r8 0x2102c0120
r9 0x221032cfa0
r10 0x221032c000
r11 0x104ce8
r12 0xe5c80
r13 0x1be82baac718
r14 0x13091135f7d69200
r15 0x0
rip 0x1b2a6
rflags 0x10246
cs 0x2b
fs 0x0
gs 0x0
Fixes #5723.
R=r, dvyukov, go.peter.90, dave, iant
CC=golang-dev
https://golang.org/cl/10360048
2013-06-27 09:32:01 -06:00
|
|
|
// Functions that need frames bigger than this use an extra
|
|
|
|
// instruction to do the stack split check, to avoid overflow
|
|
|
|
// in case SP - framesize wraps below zero.
|
|
|
|
// This value can be no bigger than the size of the unmapped
|
|
|
|
// space at zero.
|
2011-02-22 15:40:40 -07:00
|
|
|
StackBig = 4096,
|
|
|
|
|
|
|
|
// The stack guard is a pointer this many bytes above the
|
|
|
|
// bottom of the stack.
|
2011-05-16 14:57:49 -06:00
|
|
|
StackGuard = 256 + StackSystem,
|
2011-02-22 15:40:40 -07:00
|
|
|
|
|
|
|
// After a stack split check the SP is allowed to be this
|
|
|
|
// many bytes below the stack guard. This saves an instruction
|
|
|
|
// in the checking sequence for tiny frames.
|
|
|
|
StackSmall = 128,
|
|
|
|
|
|
|
|
// The maximum number of bytes that a chain of NOSPLIT
|
|
|
|
// functions can use.
|
2011-05-16 14:57:49 -06:00
|
|
|
StackLimit = StackGuard - StackSystem - StackSmall,
|
2012-03-15 13:22:30 -06:00
|
|
|
|
|
|
|
// The assumed size of the top-of-stack data block.
|
|
|
|
// The actual size can be smaller than this but cannot be larger.
|
|
|
|
// Checked in proc.c's runtime.malg.
|
2013-06-12 13:22:26 -06:00
|
|
|
StackTop = 96,
|
2011-02-22 15:40:40 -07:00
|
|
|
};
|
2013-06-28 07:52:17 -06:00
|
|
|
|
|
|
|
// Goroutine preemption request.
|
|
|
|
// Stored into g->stackguard0 to cause split stack check failure.
|
|
|
|
// Must be greater than any real sp.
|
|
|
|
// 0xfffffade in hex.
|
|
|
|
#define StackPreempt ((uintptr)-1314)
|