...
Run Format

Source file src/runtime/runtime2.go

     1	// Copyright 2009 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	package runtime
     6	
     7	import (
     8		"runtime/internal/atomic"
     9		"runtime/internal/sys"
    10		"unsafe"
    11	)
    12	
    13	// defined constants
    14	const (
    15		// G status
    16		//
    17		// Beyond indicating the general state of a G, the G status
    18		// acts like a lock on the goroutine's stack (and hence its
    19		// ability to execute user code).
    20		//
    21		// If you add to this list, add to the list
    22		// of "okay during garbage collection" status
    23		// in mgcmark.go too.
    24	
    25		// _Gidle means this goroutine was just allocated and has not
    26		// yet been initialized.
    27		_Gidle = iota // 0
    28	
    29		// _Grunnable means this goroutine is on a run queue. It is
    30		// not currently executing user code. The stack is not owned.
    31		_Grunnable // 1
    32	
    33		// _Grunning means this goroutine may execute user code. The
    34		// stack is owned by this goroutine. It is not on a run queue.
    35		// It is assigned an M and a P.
    36		_Grunning // 2
    37	
    38		// _Gsyscall means this goroutine is executing a system call.
    39		// It is not executing user code. The stack is owned by this
    40		// goroutine. It is not on a run queue. It is assigned an M.
    41		_Gsyscall // 3
    42	
    43		// _Gwaiting means this goroutine is blocked in the runtime.
    44		// It is not executing user code. It is not on a run queue,
    45		// but should be recorded somewhere (e.g., a channel wait
    46		// queue) so it can be ready()d when necessary. The stack is
    47		// not owned *except* that a channel operation may read or
    48		// write parts of the stack under the appropriate channel
    49		// lock. Otherwise, it is not safe to access the stack after a
    50		// goroutine enters _Gwaiting (e.g., it may get moved).
    51		_Gwaiting // 4
    52	
    53		// _Gmoribund_unused is currently unused, but hardcoded in gdb
    54		// scripts.
    55		_Gmoribund_unused // 5
    56	
    57		// _Gdead means this goroutine is currently unused. It may be
    58		// just exited, on a free list, or just being initialized. It
    59		// is not executing user code. It may or may not have a stack
    60		// allocated. The G and its stack (if any) are owned by the M
    61		// that is exiting the G or that obtained the G from the free
    62		// list.
    63		_Gdead // 6
    64	
    65		// _Genqueue_unused is currently unused.
    66		_Genqueue_unused // 7
    67	
    68		// _Gcopystack means this goroutine's stack is being moved. It
    69		// is not executing user code and is not on a run queue. The
    70		// stack is owned by the goroutine that put it in _Gcopystack.
    71		_Gcopystack // 8
    72	
    73		// _Gscan combined with one of the above states other than
    74		// _Grunning indicates that GC is scanning the stack. The
    75		// goroutine is not executing user code and the stack is owned
    76		// by the goroutine that set the _Gscan bit.
    77		//
    78		// _Gscanrunning is different: it is used to briefly block
    79		// state transitions while GC signals the G to scan its own
    80		// stack. This is otherwise like _Grunning.
    81		//
    82		// atomicstatus&~Gscan gives the state the goroutine will
    83		// return to when the scan completes.
    84		_Gscan         = 0x1000
    85		_Gscanrunnable = _Gscan + _Grunnable // 0x1001
    86		_Gscanrunning  = _Gscan + _Grunning  // 0x1002
    87		_Gscansyscall  = _Gscan + _Gsyscall  // 0x1003
    88		_Gscanwaiting  = _Gscan + _Gwaiting  // 0x1004
    89	)
    90	
    91	const (
    92		// P status
    93		_Pidle    = iota
    94		_Prunning // Only this P is allowed to change from _Prunning.
    95		_Psyscall
    96		_Pgcstop
    97		_Pdead
    98	)
    99	
   100	// Mutual exclusion locks.  In the uncontended case,
   101	// as fast as spin locks (just a few user-level instructions),
   102	// but on the contention path they sleep in the kernel.
   103	// A zeroed Mutex is unlocked (no need to initialize each lock).
   104	type mutex struct {
   105		// Futex-based impl treats it as uint32 key,
   106		// while sema-based impl as M* waitm.
   107		// Used to be a union, but unions break precise GC.
   108		key uintptr
   109	}
   110	
   111	// sleep and wakeup on one-time events.
   112	// before any calls to notesleep or notewakeup,
   113	// must call noteclear to initialize the Note.
   114	// then, exactly one thread can call notesleep
   115	// and exactly one thread can call notewakeup (once).
   116	// once notewakeup has been called, the notesleep
   117	// will return.  future notesleep will return immediately.
   118	// subsequent noteclear must be called only after
   119	// previous notesleep has returned, e.g. it's disallowed
   120	// to call noteclear straight after notewakeup.
   121	//
   122	// notetsleep is like notesleep but wakes up after
   123	// a given number of nanoseconds even if the event
   124	// has not yet happened.  if a goroutine uses notetsleep to
   125	// wake up early, it must wait to call noteclear until it
   126	// can be sure that no other goroutine is calling
   127	// notewakeup.
   128	//
   129	// notesleep/notetsleep are generally called on g0,
   130	// notetsleepg is similar to notetsleep but is called on user g.
   131	type note struct {
   132		// Futex-based impl treats it as uint32 key,
   133		// while sema-based impl as M* waitm.
   134		// Used to be a union, but unions break precise GC.
   135		key uintptr
   136	}
   137	
   138	type funcval struct {
   139		fn uintptr
   140		// variable-size, fn-specific data here
   141	}
   142	
   143	type iface struct {
   144		tab  *itab
   145		data unsafe.Pointer
   146	}
   147	
   148	type eface struct {
   149		_type *_type
   150		data  unsafe.Pointer
   151	}
   152	
   153	func efaceOf(ep *interface{}) *eface {
   154		return (*eface)(unsafe.Pointer(ep))
   155	}
   156	
   157	// The guintptr, muintptr, and puintptr are all used to bypass write barriers.
   158	// It is particularly important to avoid write barriers when the current P has
   159	// been released, because the GC thinks the world is stopped, and an
   160	// unexpected write barrier would not be synchronized with the GC,
   161	// which can lead to a half-executed write barrier that has marked the object
   162	// but not queued it. If the GC skips the object and completes before the
   163	// queuing can occur, it will incorrectly free the object.
   164	//
   165	// We tried using special assignment functions invoked only when not
   166	// holding a running P, but then some updates to a particular memory
   167	// word went through write barriers and some did not. This breaks the
   168	// write barrier shadow checking mode, and it is also scary: better to have
   169	// a word that is completely ignored by the GC than to have one for which
   170	// only a few updates are ignored.
   171	//
   172	// Gs, Ms, and Ps are always reachable via true pointers in the
   173	// allgs, allm, and allp lists or (during allocation before they reach those lists)
   174	// from stack variables.
   175	
   176	// A guintptr holds a goroutine pointer, but typed as a uintptr
   177	// to bypass write barriers. It is used in the Gobuf goroutine state
   178	// and in scheduling lists that are manipulated without a P.
   179	//
   180	// The Gobuf.g goroutine pointer is almost always updated by assembly code.
   181	// In one of the few places it is updated by Go code - func save - it must be
   182	// treated as a uintptr to avoid a write barrier being emitted at a bad time.
   183	// Instead of figuring out how to emit the write barriers missing in the
   184	// assembly manipulation, we change the type of the field to uintptr,
   185	// so that it does not require write barriers at all.
   186	//
   187	// Goroutine structs are published in the allg list and never freed.
   188	// That will keep the goroutine structs from being collected.
   189	// There is never a time that Gobuf.g's contain the only references
   190	// to a goroutine: the publishing of the goroutine in allg comes first.
   191	// Goroutine pointers are also kept in non-GC-visible places like TLS,
   192	// so I can't see them ever moving. If we did want to start moving data
   193	// in the GC, we'd need to allocate the goroutine structs from an
   194	// alternate arena. Using guintptr doesn't make that problem any worse.
   195	type guintptr uintptr
   196	
   197	//go:nosplit
   198	func (gp guintptr) ptr() *g { return (*g)(unsafe.Pointer(gp)) }
   199	
   200	//go:nosplit
   201	func (gp *guintptr) set(g *g) { *gp = guintptr(unsafe.Pointer(g)) }
   202	
   203	//go:nosplit
   204	func (gp *guintptr) cas(old, new guintptr) bool {
   205		return atomic.Casuintptr((*uintptr)(unsafe.Pointer(gp)), uintptr(old), uintptr(new))
   206	}
   207	
   208	// setGNoWB performs *gp = new without a write barrier.
   209	// For times when it's impractical to use a guintptr.
   210	//go:nosplit
   211	//go:nowritebarrier
   212	func setGNoWB(gp **g, new *g) {
   213		(*guintptr)(unsafe.Pointer(gp)).set(new)
   214	}
   215	
   216	type puintptr uintptr
   217	
   218	//go:nosplit
   219	func (pp puintptr) ptr() *p { return (*p)(unsafe.Pointer(pp)) }
   220	
   221	//go:nosplit
   222	func (pp *puintptr) set(p *p) { *pp = puintptr(unsafe.Pointer(p)) }
   223	
   224	type muintptr uintptr
   225	
   226	//go:nosplit
   227	func (mp muintptr) ptr() *m { return (*m)(unsafe.Pointer(mp)) }
   228	
   229	//go:nosplit
   230	func (mp *muintptr) set(m *m) { *mp = muintptr(unsafe.Pointer(m)) }
   231	
   232	// setMNoWB performs *mp = new without a write barrier.
   233	// For times when it's impractical to use an muintptr.
   234	//go:nosplit
   235	//go:nowritebarrier
   236	func setMNoWB(mp **m, new *m) {
   237		(*muintptr)(unsafe.Pointer(mp)).set(new)
   238	}
   239	
   240	type gobuf struct {
   241		// The offsets of sp, pc, and g are known to (hard-coded in) libmach.
   242		//
   243		// ctxt is unusual with respect to GC: it may be a
   244		// heap-allocated funcval so write require a write barrier,
   245		// but gobuf needs to be cleared from assembly. We take
   246		// advantage of the fact that the only path that uses a
   247		// non-nil ctxt is morestack. As a result, gogo is the only
   248		// place where it may not already be nil, so gogo uses an
   249		// explicit write barrier. Everywhere else that resets the
   250		// gobuf asserts that ctxt is already nil.
   251		sp   uintptr
   252		pc   uintptr
   253		g    guintptr
   254		ctxt unsafe.Pointer // this has to be a pointer so that gc scans it
   255		ret  sys.Uintreg
   256		lr   uintptr
   257		bp   uintptr // for GOEXPERIMENT=framepointer
   258	}
   259	
   260	// sudog represents a g in a wait list, such as for sending/receiving
   261	// on a channel.
   262	//
   263	// sudog is necessary because the g ↔ synchronization object relation
   264	// is many-to-many. A g can be on many wait lists, so there may be
   265	// many sudogs for one g; and many gs may be waiting on the same
   266	// synchronization object, so there may be many sudogs for one object.
   267	//
   268	// sudogs are allocated from a special pool. Use acquireSudog and
   269	// releaseSudog to allocate and free them.
   270	type sudog struct {
   271		// The following fields are protected by the hchan.lock of the
   272		// channel this sudog is blocking on. shrinkstack depends on
   273		// this.
   274	
   275		g          *g
   276		selectdone *uint32 // CAS to 1 to win select race (may point to stack)
   277		next       *sudog
   278		prev       *sudog
   279		elem       unsafe.Pointer // data element (may point to stack)
   280	
   281		// The following fields are never accessed concurrently.
   282		// waitlink is only accessed by g.
   283	
   284		acquiretime int64
   285		releasetime int64
   286		ticket      uint32
   287		waitlink    *sudog // g.waiting list
   288		c           *hchan // channel
   289	}
   290	
   291	type gcstats struct {
   292		// the struct must consist of only uint64's,
   293		// because it is casted to uint64[].
   294		nhandoff    uint64
   295		nhandoffcnt uint64
   296		nprocyield  uint64
   297		nosyield    uint64
   298		nsleep      uint64
   299	}
   300	
   301	type libcall struct {
   302		fn   uintptr
   303		n    uintptr // number of parameters
   304		args uintptr // parameters
   305		r1   uintptr // return values
   306		r2   uintptr
   307		err  uintptr // error number
   308	}
   309	
   310	// describes how to handle callback
   311	type wincallbackcontext struct {
   312		gobody       unsafe.Pointer // go function to call
   313		argsize      uintptr        // callback arguments size (in bytes)
   314		restorestack uintptr        // adjust stack on return by (in bytes) (386 only)
   315		cleanstack   bool
   316	}
   317	
   318	// Stack describes a Go execution stack.
   319	// The bounds of the stack are exactly [lo, hi),
   320	// with no implicit data structures on either side.
   321	type stack struct {
   322		lo uintptr
   323		hi uintptr
   324	}
   325	
   326	// stkbar records the state of a G's stack barrier.
   327	type stkbar struct {
   328		savedLRPtr uintptr // location overwritten by stack barrier PC
   329		savedLRVal uintptr // value overwritten at savedLRPtr
   330	}
   331	
   332	type g struct {
   333		// Stack parameters.
   334		// stack describes the actual stack memory: [stack.lo, stack.hi).
   335		// stackguard0 is the stack pointer compared in the Go stack growth prologue.
   336		// It is stack.lo+StackGuard normally, but can be StackPreempt to trigger a preemption.
   337		// stackguard1 is the stack pointer compared in the C stack growth prologue.
   338		// It is stack.lo+StackGuard on g0 and gsignal stacks.
   339		// It is ~0 on other goroutine stacks, to trigger a call to morestackc (and crash).
   340		stack       stack   // offset known to runtime/cgo
   341		stackguard0 uintptr // offset known to liblink
   342		stackguard1 uintptr // offset known to liblink
   343	
   344		_panic         *_panic // innermost panic - offset known to liblink
   345		_defer         *_defer // innermost defer
   346		m              *m      // current m; offset known to arm liblink
   347		stackAlloc     uintptr // stack allocation is [stack.lo,stack.lo+stackAlloc)
   348		sched          gobuf
   349		syscallsp      uintptr        // if status==Gsyscall, syscallsp = sched.sp to use during gc
   350		syscallpc      uintptr        // if status==Gsyscall, syscallpc = sched.pc to use during gc
   351		stkbar         []stkbar       // stack barriers, from low to high (see top of mstkbar.go)
   352		stkbarPos      uintptr        // index of lowest stack barrier not hit
   353		stktopsp       uintptr        // expected sp at top of stack, to check in traceback
   354		param          unsafe.Pointer // passed parameter on wakeup
   355		atomicstatus   uint32
   356		stackLock      uint32 // sigprof/scang lock; TODO: fold in to atomicstatus
   357		goid           int64
   358		waitsince      int64  // approx time when the g become blocked
   359		waitreason     string // if status==Gwaiting
   360		schedlink      guintptr
   361		preempt        bool     // preemption signal, duplicates stackguard0 = stackpreempt
   362		paniconfault   bool     // panic (instead of crash) on unexpected fault address
   363		preemptscan    bool     // preempted g does scan for gc
   364		gcscandone     bool     // g has scanned stack; protected by _Gscan bit in status
   365		gcscanvalid    bool     // false at start of gc cycle, true if G has not run since last scan; transition from true to false by calling queueRescan and false to true by calling dequeueRescan
   366		throwsplit     bool     // must not split stack
   367		raceignore     int8     // ignore race detection events
   368		sysblocktraced bool     // StartTrace has emitted EvGoInSyscall about this goroutine
   369		sysexitticks   int64    // cputicks when syscall has returned (for tracing)
   370		traceseq       uint64   // trace event sequencer
   371		tracelastp     puintptr // last P emitted an event for this goroutine
   372		lockedm        *m
   373		sig            uint32
   374		writebuf       []byte
   375		sigcode0       uintptr
   376		sigcode1       uintptr
   377		sigpc          uintptr
   378		gopc           uintptr // pc of go statement that created this goroutine
   379		startpc        uintptr // pc of goroutine function
   380		racectx        uintptr
   381		waiting        *sudog    // sudog structures this g is waiting on (that have a valid elem ptr); in lock order
   382		cgoCtxt        []uintptr // cgo traceback context
   383	
   384		// Per-G GC state
   385	
   386		// gcRescan is this G's index in work.rescan.list. If this is
   387		// -1, this G is not on the rescan list.
   388		//
   389		// If gcphase != _GCoff and this G is visible to the garbage
   390		// collector, writes to this are protected by work.rescan.lock.
   391		gcRescan int32
   392	
   393		// gcAssistBytes is this G's GC assist credit in terms of
   394		// bytes allocated. If this is positive, then the G has credit
   395		// to allocate gcAssistBytes bytes without assisting. If this
   396		// is negative, then the G must correct this by performing
   397		// scan work. We track this in bytes to make it fast to update
   398		// and check for debt in the malloc hot path. The assist ratio
   399		// determines how this corresponds to scan work debt.
   400		gcAssistBytes int64
   401	}
   402	
   403	type m struct {
   404		g0      *g     // goroutine with scheduling stack
   405		morebuf gobuf  // gobuf arg to morestack
   406		divmod  uint32 // div/mod denominator for arm - known to liblink
   407	
   408		// Fields not known to debuggers.
   409		procid        uint64     // for debuggers, but offset not hard-coded
   410		gsignal       *g         // signal-handling g
   411		sigmask       sigset     // storage for saved signal mask
   412		tls           [6]uintptr // thread-local storage (for x86 extern register)
   413		mstartfn      func()
   414		curg          *g       // current running goroutine
   415		caughtsig     guintptr // goroutine running during fatal signal
   416		p             puintptr // attached p for executing go code (nil if not executing go code)
   417		nextp         puintptr
   418		id            int32
   419		mallocing     int32
   420		throwing      int32
   421		preemptoff    string // if != "", keep curg running on this m
   422		locks         int32
   423		softfloat     int32
   424		dying         int32
   425		profilehz     int32
   426		helpgc        int32
   427		spinning      bool // m is out of work and is actively looking for work
   428		blocked       bool // m is blocked on a note
   429		inwb          bool // m is executing a write barrier
   430		newSigstack   bool // minit on C thread called sigaltstack
   431		printlock     int8
   432		fastrand      uint32
   433		ncgocall      uint64      // number of cgo calls in total
   434		ncgo          int32       // number of cgo calls currently in progress
   435		cgoCallersUse uint32      // if non-zero, cgoCallers in use temporarily
   436		cgoCallers    *cgoCallers // cgo traceback if crashing in cgo call
   437		park          note
   438		alllink       *m // on allm
   439		schedlink     muintptr
   440		mcache        *mcache
   441		lockedg       *g
   442		createstack   [32]uintptr // stack that created this thread.
   443		freglo        [16]uint32  // d[i] lsb and f[i]
   444		freghi        [16]uint32  // d[i] msb and f[i+16]
   445		fflag         uint32      // floating point compare flags
   446		locked        uint32      // tracking for lockosthread
   447		nextwaitm     uintptr     // next m waiting for lock
   448		gcstats       gcstats
   449		needextram    bool
   450		traceback     uint8
   451		waitunlockf   unsafe.Pointer // todo go func(*g, unsafe.pointer) bool
   452		waitlock      unsafe.Pointer
   453		waittraceev   byte
   454		waittraceskip int
   455		startingtrace bool
   456		syscalltick   uint32
   457		thread        uintptr // thread handle
   458	
   459		// these are here because they are too large to be on the stack
   460		// of low-level NOSPLIT functions.
   461		libcall   libcall
   462		libcallpc uintptr // for cpu profiler
   463		libcallsp uintptr
   464		libcallg  guintptr
   465		syscall   libcall // stores syscall parameters on windows
   466	
   467		mOS
   468	}
   469	
   470	type p struct {
   471		lock mutex
   472	
   473		id          int32
   474		status      uint32 // one of pidle/prunning/...
   475		link        puintptr
   476		schedtick   uint32   // incremented on every scheduler call
   477		syscalltick uint32   // incremented on every system call
   478		m           muintptr // back-link to associated m (nil if idle)
   479		mcache      *mcache
   480		racectx     uintptr
   481	
   482		deferpool    [5][]*_defer // pool of available defer structs of different sizes (see panic.go)
   483		deferpoolbuf [5][32]*_defer
   484	
   485		// Cache of goroutine ids, amortizes accesses to runtime·sched.goidgen.
   486		goidcache    uint64
   487		goidcacheend uint64
   488	
   489		// Queue of runnable goroutines. Accessed without lock.
   490		runqhead uint32
   491		runqtail uint32
   492		runq     [256]guintptr
   493		// runnext, if non-nil, is a runnable G that was ready'd by
   494		// the current G and should be run next instead of what's in
   495		// runq if there's time remaining in the running G's time
   496		// slice. It will inherit the time left in the current time
   497		// slice. If a set of goroutines is locked in a
   498		// communicate-and-wait pattern, this schedules that set as a
   499		// unit and eliminates the (potentially large) scheduling
   500		// latency that otherwise arises from adding the ready'd
   501		// goroutines to the end of the run queue.
   502		runnext guintptr
   503	
   504		// Available G's (status == Gdead)
   505		gfree    *g
   506		gfreecnt int32
   507	
   508		sudogcache []*sudog
   509		sudogbuf   [128]*sudog
   510	
   511		tracebuf traceBufPtr
   512	
   513		palloc persistentAlloc // per-P to avoid mutex
   514	
   515		// Per-P GC state
   516		gcAssistTime     int64 // Nanoseconds in assistAlloc
   517		gcBgMarkWorker   guintptr
   518		gcMarkWorkerMode gcMarkWorkerMode
   519	
   520		// gcw is this P's GC work buffer cache. The work buffer is
   521		// filled by write barriers, drained by mutator assists, and
   522		// disposed on certain GC state transitions.
   523		gcw gcWork
   524	
   525		runSafePointFn uint32 // if 1, run sched.safePointFn at next safe point
   526	
   527		pad [sys.CacheLineSize]byte
   528	}
   529	
   530	const (
   531		// The max value of GOMAXPROCS.
   532		// There are no fundamental restrictions on the value.
   533		_MaxGomaxprocs = 1 << 8
   534	)
   535	
   536	type schedt struct {
   537		// accessed atomically. keep at top to ensure alignment on 32-bit systems.
   538		goidgen  uint64
   539		lastpoll uint64
   540	
   541		lock mutex
   542	
   543		midle        muintptr // idle m's waiting for work
   544		nmidle       int32    // number of idle m's waiting for work
   545		nmidlelocked int32    // number of locked m's waiting for work
   546		mcount       int32    // number of m's that have been created
   547		maxmcount    int32    // maximum number of m's allowed (or die)
   548	
   549		ngsys uint32 // number of system goroutines; updated atomically
   550	
   551		pidle      puintptr // idle p's
   552		npidle     uint32
   553		nmspinning uint32 // See "Worker thread parking/unparking" comment in proc.go.
   554	
   555		// Global runnable queue.
   556		runqhead guintptr
   557		runqtail guintptr
   558		runqsize int32
   559	
   560		// Global cache of dead G's.
   561		gflock       mutex
   562		gfreeStack   *g
   563		gfreeNoStack *g
   564		ngfree       int32
   565	
   566		// Central cache of sudog structs.
   567		sudoglock  mutex
   568		sudogcache *sudog
   569	
   570		// Central pool of available defer structs of different sizes.
   571		deferlock mutex
   572		deferpool [5]*_defer
   573	
   574		gcwaiting  uint32 // gc is waiting to run
   575		stopwait   int32
   576		stopnote   note
   577		sysmonwait uint32
   578		sysmonnote note
   579	
   580		// safepointFn should be called on each P at the next GC
   581		// safepoint if p.runSafePointFn is set.
   582		safePointFn   func(*p)
   583		safePointWait int32
   584		safePointNote note
   585	
   586		profilehz int32 // cpu profiling rate
   587	
   588		procresizetime int64 // nanotime() of last change to gomaxprocs
   589		totaltime      int64 // ∫gomaxprocs dt up to procresizetime
   590	}
   591	
   592	// The m.locked word holds two pieces of state counting active calls to LockOSThread/lockOSThread.
   593	// The low bit (LockExternal) is a boolean reporting whether any LockOSThread call is active.
   594	// External locks are not recursive; a second lock is silently ignored.
   595	// The upper bits of m.locked record the nesting depth of calls to lockOSThread
   596	// (counting up by LockInternal), popped by unlockOSThread (counting down by LockInternal).
   597	// Internal locks can be recursive. For instance, a lock for cgo can occur while the main
   598	// goroutine is holding the lock during the initialization phase.
   599	const (
   600		_LockExternal = 1
   601		_LockInternal = 2
   602	)
   603	
   604	const (
   605		_SigNotify   = 1 << iota // let signal.Notify have signal, even if from kernel
   606		_SigKill                 // if signal.Notify doesn't take it, exit quietly
   607		_SigThrow                // if signal.Notify doesn't take it, exit loudly
   608		_SigPanic                // if the signal is from the kernel, panic
   609		_SigDefault              // if the signal isn't explicitly requested, don't monitor it
   610		_SigHandling             // our signal handler is registered
   611		_SigGoExit               // cause all runtime procs to exit (only used on Plan 9).
   612		_SigSetStack             // add SA_ONSTACK to libc handler
   613		_SigUnblock              // unblocked in minit
   614	)
   615	
   616	// Layout of in-memory per-function information prepared by linker
   617	// See https://golang.org/s/go12symtab.
   618	// Keep in sync with linker (../cmd/link/internal/ld/pcln.go:/pclntab)
   619	// and with package debug/gosym and with symtab.go in package runtime.
   620	type _func struct {
   621		entry   uintptr // start pc
   622		nameoff int32   // function name
   623	
   624		args int32 // in/out args size
   625		_    int32 // previously legacy frame size; kept for layout compatibility
   626	
   627		pcsp      int32
   628		pcfile    int32
   629		pcln      int32
   630		npcdata   int32
   631		nfuncdata int32
   632	}
   633	
   634	// layout of Itab known to compilers
   635	// allocated in non-garbage-collected memory
   636	// Needs to be in sync with
   637	// ../cmd/compile/internal/gc/reflect.go:/^func.dumptypestructs.
   638	type itab struct {
   639		inter  *interfacetype
   640		_type  *_type
   641		link   *itab
   642		bad    int32
   643		inhash int32      // has this itab been added to hash?
   644		fun    [1]uintptr // variable sized
   645	}
   646	
   647	// Lock-free stack node.
   648	// // Also known to export_test.go.
   649	type lfnode struct {
   650		next    uint64
   651		pushcnt uintptr
   652	}
   653	
   654	type forcegcstate struct {
   655		lock mutex
   656		g    *g
   657		idle uint32
   658	}
   659	
   660	// startup_random_data holds random bytes initialized at startup. These come from
   661	// the ELF AT_RANDOM auxiliary vector (vdso_linux_amd64.go or os_linux_386.go).
   662	var startupRandomData []byte
   663	
   664	// extendRandom extends the random numbers in r[:n] to the whole slice r.
   665	// Treats n<0 as n==0.
   666	func extendRandom(r []byte, n int) {
   667		if n < 0 {
   668			n = 0
   669		}
   670		for n < len(r) {
   671			// Extend random bits using hash function & time seed
   672			w := n
   673			if w > 16 {
   674				w = 16
   675			}
   676			h := memhash(unsafe.Pointer(&r[n-w]), uintptr(nanotime()), uintptr(w))
   677			for i := 0; i < sys.PtrSize && n < len(r); i++ {
   678				r[n] = byte(h)
   679				n++
   680				h >>= 8
   681			}
   682		}
   683	}
   684	
   685	// deferred subroutine calls
   686	type _defer struct {
   687		siz     int32
   688		started bool
   689		sp      uintptr // sp at time of defer
   690		pc      uintptr
   691		fn      *funcval
   692		_panic  *_panic // panic that is running defer
   693		link    *_defer
   694	}
   695	
   696	// panics
   697	type _panic struct {
   698		argp      unsafe.Pointer // pointer to arguments of deferred call run during panic; cannot move - known to liblink
   699		arg       interface{}    // argument to panic
   700		link      *_panic        // link to earlier panic
   701		recovered bool           // whether this panic is over
   702		aborted   bool           // the panic was aborted
   703	}
   704	
   705	// stack traces
   706	type stkframe struct {
   707		fn       *_func     // function being run
   708		pc       uintptr    // program counter within fn
   709		continpc uintptr    // program counter where execution can continue, or 0 if not
   710		lr       uintptr    // program counter at caller aka link register
   711		sp       uintptr    // stack pointer at pc
   712		fp       uintptr    // stack pointer at caller aka frame pointer
   713		varp     uintptr    // top of local variables
   714		argp     uintptr    // pointer to function arguments
   715		arglen   uintptr    // number of bytes at argp
   716		argmap   *bitvector // force use of this argmap
   717	}
   718	
   719	const (
   720		_TraceRuntimeFrames = 1 << iota // include frames for internal runtime functions.
   721		_TraceTrap                      // the initial PC, SP are from a trap, not a return PC from a call
   722		_TraceJumpStack                 // if traceback is on a systemstack, resume trace at g that called into it
   723	)
   724	
   725	// The maximum number of frames we print for a traceback
   726	const _TracebackMaxFrames = 100
   727	
   728	var (
   729		emptystring string
   730		allglen     uintptr
   731		allm        *m
   732		allp        [_MaxGomaxprocs + 1]*p
   733		gomaxprocs  int32
   734		panicking   uint32
   735		ncpu        int32
   736		forcegc     forcegcstate
   737		sched       schedt
   738		newprocs    int32
   739	
   740		// Information about what cpu features are available.
   741		// Set on startup in asm_{x86,amd64}.s.
   742		cpuid_ecx         uint32
   743		cpuid_edx         uint32
   744		cpuid_ebx7        uint32
   745		lfenceBeforeRdtsc bool
   746		support_avx       bool
   747		support_avx2      bool
   748		support_bmi1      bool
   749		support_bmi2      bool
   750	
   751		goarm                uint8 // set by cmd/link on arm systems
   752		framepointer_enabled bool  // set by cmd/link
   753	)
   754	
   755	// Set by the linker so the runtime can determine the buildmode.
   756	var (
   757		islibrary bool // -buildmode=c-shared
   758		isarchive bool // -buildmode=c-archive
   759	)
   760	

View as plain text