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  	"internal/abi"
     9  	"internal/chacha8rand"
    10  	"internal/goarch"
    11  	"runtime/internal/atomic"
    12  	"runtime/internal/sys"
    13  	"unsafe"
    14  )
    15  
    16  // defined constants
    17  const (
    18  	// G status
    19  	//
    20  	// Beyond indicating the general state of a G, the G status
    21  	// acts like a lock on the goroutine's stack (and hence its
    22  	// ability to execute user code).
    23  	//
    24  	// If you add to this list, add to the list
    25  	// of "okay during garbage collection" status
    26  	// in mgcmark.go too.
    27  	//
    28  	// TODO(austin): The _Gscan bit could be much lighter-weight.
    29  	// For example, we could choose not to run _Gscanrunnable
    30  	// goroutines found in the run queue, rather than CAS-looping
    31  	// until they become _Grunnable. And transitions like
    32  	// _Gscanwaiting -> _Gscanrunnable are actually okay because
    33  	// they don't affect stack ownership.
    34  
    35  	// _Gidle means this goroutine was just allocated and has not
    36  	// yet been initialized.
    37  	_Gidle = iota // 0
    38  
    39  	// _Grunnable means this goroutine is on a run queue. It is
    40  	// not currently executing user code. The stack is not owned.
    41  	_Grunnable // 1
    42  
    43  	// _Grunning means this goroutine may execute user code. The
    44  	// stack is owned by this goroutine. It is not on a run queue.
    45  	// It is assigned an M and a P (g.m and g.m.p are valid).
    46  	_Grunning // 2
    47  
    48  	// _Gsyscall means this goroutine is executing a system call.
    49  	// It is not executing user code. The stack is owned by this
    50  	// goroutine. It is not on a run queue. It is assigned an M.
    51  	_Gsyscall // 3
    52  
    53  	// _Gwaiting means this goroutine is blocked in the runtime.
    54  	// It is not executing user code. It is not on a run queue,
    55  	// but should be recorded somewhere (e.g., a channel wait
    56  	// queue) so it can be ready()d when necessary. The stack is
    57  	// not owned *except* that a channel operation may read or
    58  	// write parts of the stack under the appropriate channel
    59  	// lock. Otherwise, it is not safe to access the stack after a
    60  	// goroutine enters _Gwaiting (e.g., it may get moved).
    61  	_Gwaiting // 4
    62  
    63  	// _Gmoribund_unused is currently unused, but hardcoded in gdb
    64  	// scripts.
    65  	_Gmoribund_unused // 5
    66  
    67  	// _Gdead means this goroutine is currently unused. It may be
    68  	// just exited, on a free list, or just being initialized. It
    69  	// is not executing user code. It may or may not have a stack
    70  	// allocated. The G and its stack (if any) are owned by the M
    71  	// that is exiting the G or that obtained the G from the free
    72  	// list.
    73  	_Gdead // 6
    74  
    75  	// _Genqueue_unused is currently unused.
    76  	_Genqueue_unused // 7
    77  
    78  	// _Gcopystack means this goroutine's stack is being moved. It
    79  	// is not executing user code and is not on a run queue. The
    80  	// stack is owned by the goroutine that put it in _Gcopystack.
    81  	_Gcopystack // 8
    82  
    83  	// _Gpreempted means this goroutine stopped itself for a
    84  	// suspendG preemption. It is like _Gwaiting, but nothing is
    85  	// yet responsible for ready()ing it. Some suspendG must CAS
    86  	// the status to _Gwaiting to take responsibility for
    87  	// ready()ing this G.
    88  	_Gpreempted // 9
    89  
    90  	// _Gscan combined with one of the above states other than
    91  	// _Grunning indicates that GC is scanning the stack. The
    92  	// goroutine is not executing user code and the stack is owned
    93  	// by the goroutine that set the _Gscan bit.
    94  	//
    95  	// _Gscanrunning is different: it is used to briefly block
    96  	// state transitions while GC signals the G to scan its own
    97  	// stack. This is otherwise like _Grunning.
    98  	//
    99  	// atomicstatus&~Gscan gives the state the goroutine will
   100  	// return to when the scan completes.
   101  	_Gscan          = 0x1000
   102  	_Gscanrunnable  = _Gscan + _Grunnable  // 0x1001
   103  	_Gscanrunning   = _Gscan + _Grunning   // 0x1002
   104  	_Gscansyscall   = _Gscan + _Gsyscall   // 0x1003
   105  	_Gscanwaiting   = _Gscan + _Gwaiting   // 0x1004
   106  	_Gscanpreempted = _Gscan + _Gpreempted // 0x1009
   107  )
   108  
   109  const (
   110  	// P status
   111  
   112  	// _Pidle means a P is not being used to run user code or the
   113  	// scheduler. Typically, it's on the idle P list and available
   114  	// to the scheduler, but it may just be transitioning between
   115  	// other states.
   116  	//
   117  	// The P is owned by the idle list or by whatever is
   118  	// transitioning its state. Its run queue is empty.
   119  	_Pidle = iota
   120  
   121  	// _Prunning means a P is owned by an M and is being used to
   122  	// run user code or the scheduler. Only the M that owns this P
   123  	// is allowed to change the P's status from _Prunning. The M
   124  	// may transition the P to _Pidle (if it has no more work to
   125  	// do), _Psyscall (when entering a syscall), or _Pgcstop (to
   126  	// halt for the GC). The M may also hand ownership of the P
   127  	// off directly to another M (e.g., to schedule a locked G).
   128  	_Prunning
   129  
   130  	// _Psyscall means a P is not running user code. It has
   131  	// affinity to an M in a syscall but is not owned by it and
   132  	// may be stolen by another M. This is similar to _Pidle but
   133  	// uses lightweight transitions and maintains M affinity.
   134  	//
   135  	// Leaving _Psyscall must be done with a CAS, either to steal
   136  	// or retake the P. Note that there's an ABA hazard: even if
   137  	// an M successfully CASes its original P back to _Prunning
   138  	// after a syscall, it must understand the P may have been
   139  	// used by another M in the interim.
   140  	_Psyscall
   141  
   142  	// _Pgcstop means a P is halted for STW and owned by the M
   143  	// that stopped the world. The M that stopped the world
   144  	// continues to use its P, even in _Pgcstop. Transitioning
   145  	// from _Prunning to _Pgcstop causes an M to release its P and
   146  	// park.
   147  	//
   148  	// The P retains its run queue and startTheWorld will restart
   149  	// the scheduler on Ps with non-empty run queues.
   150  	_Pgcstop
   151  
   152  	// _Pdead means a P is no longer used (GOMAXPROCS shrank). We
   153  	// reuse Ps if GOMAXPROCS increases. A dead P is mostly
   154  	// stripped of its resources, though a few things remain
   155  	// (e.g., trace buffers).
   156  	_Pdead
   157  )
   158  
   159  // Mutual exclusion locks.  In the uncontended case,
   160  // as fast as spin locks (just a few user-level instructions),
   161  // but on the contention path they sleep in the kernel.
   162  // A zeroed Mutex is unlocked (no need to initialize each lock).
   163  // Initialization is helpful for static lock ranking, but not required.
   164  type mutex struct {
   165  	// Empty struct if lock ranking is disabled, otherwise includes the lock rank
   166  	lockRankStruct
   167  	// Futex-based impl treats it as uint32 key,
   168  	// while sema-based impl as M* waitm.
   169  	// Used to be a union, but unions break precise GC.
   170  	key uintptr
   171  }
   172  
   173  // sleep and wakeup on one-time events.
   174  // before any calls to notesleep or notewakeup,
   175  // must call noteclear to initialize the Note.
   176  // then, exactly one thread can call notesleep
   177  // and exactly one thread can call notewakeup (once).
   178  // once notewakeup has been called, the notesleep
   179  // will return.  future notesleep will return immediately.
   180  // subsequent noteclear must be called only after
   181  // previous notesleep has returned, e.g. it's disallowed
   182  // to call noteclear straight after notewakeup.
   183  //
   184  // notetsleep is like notesleep but wakes up after
   185  // a given number of nanoseconds even if the event
   186  // has not yet happened.  if a goroutine uses notetsleep to
   187  // wake up early, it must wait to call noteclear until it
   188  // can be sure that no other goroutine is calling
   189  // notewakeup.
   190  //
   191  // notesleep/notetsleep are generally called on g0,
   192  // notetsleepg is similar to notetsleep but is called on user g.
   193  type note struct {
   194  	// Futex-based impl treats it as uint32 key,
   195  	// while sema-based impl as M* waitm.
   196  	// Used to be a union, but unions break precise GC.
   197  	key uintptr
   198  }
   199  
   200  type funcval struct {
   201  	fn uintptr
   202  	// variable-size, fn-specific data here
   203  }
   204  
   205  type iface struct {
   206  	tab  *itab
   207  	data unsafe.Pointer
   208  }
   209  
   210  type eface struct {
   211  	_type *_type
   212  	data  unsafe.Pointer
   213  }
   214  
   215  func efaceOf(ep *any) *eface {
   216  	return (*eface)(unsafe.Pointer(ep))
   217  }
   218  
   219  // The guintptr, muintptr, and puintptr are all used to bypass write barriers.
   220  // It is particularly important to avoid write barriers when the current P has
   221  // been released, because the GC thinks the world is stopped, and an
   222  // unexpected write barrier would not be synchronized with the GC,
   223  // which can lead to a half-executed write barrier that has marked the object
   224  // but not queued it. If the GC skips the object and completes before the
   225  // queuing can occur, it will incorrectly free the object.
   226  //
   227  // We tried using special assignment functions invoked only when not
   228  // holding a running P, but then some updates to a particular memory
   229  // word went through write barriers and some did not. This breaks the
   230  // write barrier shadow checking mode, and it is also scary: better to have
   231  // a word that is completely ignored by the GC than to have one for which
   232  // only a few updates are ignored.
   233  //
   234  // Gs and Ps are always reachable via true pointers in the
   235  // allgs and allp lists or (during allocation before they reach those lists)
   236  // from stack variables.
   237  //
   238  // Ms are always reachable via true pointers either from allm or
   239  // freem. Unlike Gs and Ps we do free Ms, so it's important that
   240  // nothing ever hold an muintptr across a safe point.
   241  
   242  // A guintptr holds a goroutine pointer, but typed as a uintptr
   243  // to bypass write barriers. It is used in the Gobuf goroutine state
   244  // and in scheduling lists that are manipulated without a P.
   245  //
   246  // The Gobuf.g goroutine pointer is almost always updated by assembly code.
   247  // In one of the few places it is updated by Go code - func save - it must be
   248  // treated as a uintptr to avoid a write barrier being emitted at a bad time.
   249  // Instead of figuring out how to emit the write barriers missing in the
   250  // assembly manipulation, we change the type of the field to uintptr,
   251  // so that it does not require write barriers at all.
   252  //
   253  // Goroutine structs are published in the allg list and never freed.
   254  // That will keep the goroutine structs from being collected.
   255  // There is never a time that Gobuf.g's contain the only references
   256  // to a goroutine: the publishing of the goroutine in allg comes first.
   257  // Goroutine pointers are also kept in non-GC-visible places like TLS,
   258  // so I can't see them ever moving. If we did want to start moving data
   259  // in the GC, we'd need to allocate the goroutine structs from an
   260  // alternate arena. Using guintptr doesn't make that problem any worse.
   261  // Note that pollDesc.rg, pollDesc.wg also store g in uintptr form,
   262  // so they would need to be updated too if g's start moving.
   263  type guintptr uintptr
   264  
   265  //go:nosplit
   266  func (gp guintptr) ptr() *g { return (*g)(unsafe.Pointer(gp)) }
   267  
   268  //go:nosplit
   269  func (gp *guintptr) set(g *g) { *gp = guintptr(unsafe.Pointer(g)) }
   270  
   271  //go:nosplit
   272  func (gp *guintptr) cas(old, new guintptr) bool {
   273  	return atomic.Casuintptr((*uintptr)(unsafe.Pointer(gp)), uintptr(old), uintptr(new))
   274  }
   275  
   276  //go:nosplit
   277  func (gp *g) guintptr() guintptr {
   278  	return guintptr(unsafe.Pointer(gp))
   279  }
   280  
   281  // setGNoWB performs *gp = new without a write barrier.
   282  // For times when it's impractical to use a guintptr.
   283  //
   284  //go:nosplit
   285  //go:nowritebarrier
   286  func setGNoWB(gp **g, new *g) {
   287  	(*guintptr)(unsafe.Pointer(gp)).set(new)
   288  }
   289  
   290  type puintptr uintptr
   291  
   292  //go:nosplit
   293  func (pp puintptr) ptr() *p { return (*p)(unsafe.Pointer(pp)) }
   294  
   295  //go:nosplit
   296  func (pp *puintptr) set(p *p) { *pp = puintptr(unsafe.Pointer(p)) }
   297  
   298  // muintptr is a *m that is not tracked by the garbage collector.
   299  //
   300  // Because we do free Ms, there are some additional constrains on
   301  // muintptrs:
   302  //
   303  //  1. Never hold an muintptr locally across a safe point.
   304  //
   305  //  2. Any muintptr in the heap must be owned by the M itself so it can
   306  //     ensure it is not in use when the last true *m is released.
   307  type muintptr uintptr
   308  
   309  //go:nosplit
   310  func (mp muintptr) ptr() *m { return (*m)(unsafe.Pointer(mp)) }
   311  
   312  //go:nosplit
   313  func (mp *muintptr) set(m *m) { *mp = muintptr(unsafe.Pointer(m)) }
   314  
   315  // setMNoWB performs *mp = new without a write barrier.
   316  // For times when it's impractical to use an muintptr.
   317  //
   318  //go:nosplit
   319  //go:nowritebarrier
   320  func setMNoWB(mp **m, new *m) {
   321  	(*muintptr)(unsafe.Pointer(mp)).set(new)
   322  }
   323  
   324  type gobuf struct {
   325  	// The offsets of sp, pc, and g are known to (hard-coded in) libmach.
   326  	//
   327  	// ctxt is unusual with respect to GC: it may be a
   328  	// heap-allocated funcval, so GC needs to track it, but it
   329  	// needs to be set and cleared from assembly, where it's
   330  	// difficult to have write barriers. However, ctxt is really a
   331  	// saved, live register, and we only ever exchange it between
   332  	// the real register and the gobuf. Hence, we treat it as a
   333  	// root during stack scanning, which means assembly that saves
   334  	// and restores it doesn't need write barriers. It's still
   335  	// typed as a pointer so that any other writes from Go get
   336  	// write barriers.
   337  	sp   uintptr
   338  	pc   uintptr
   339  	g    guintptr
   340  	ctxt unsafe.Pointer
   341  	ret  uintptr
   342  	lr   uintptr
   343  	bp   uintptr // for framepointer-enabled architectures
   344  }
   345  
   346  // sudog (pseudo-g) represents a g in a wait list, such as for sending/receiving
   347  // on a channel.
   348  //
   349  // sudog is necessary because the g ↔ synchronization object relation
   350  // is many-to-many. A g can be on many wait lists, so there may be
   351  // many sudogs for one g; and many gs may be waiting on the same
   352  // synchronization object, so there may be many sudogs for one object.
   353  //
   354  // sudogs are allocated from a special pool. Use acquireSudog and
   355  // releaseSudog to allocate and free them.
   356  type sudog struct {
   357  	// The following fields are protected by the hchan.lock of the
   358  	// channel this sudog is blocking on. shrinkstack depends on
   359  	// this for sudogs involved in channel ops.
   360  
   361  	g *g
   362  
   363  	next *sudog
   364  	prev *sudog
   365  	elem unsafe.Pointer // data element (may point to stack)
   366  
   367  	// The following fields are never accessed concurrently.
   368  	// For channels, waitlink is only accessed by g.
   369  	// For semaphores, all fields (including the ones above)
   370  	// are only accessed when holding a semaRoot lock.
   371  
   372  	acquiretime int64
   373  	releasetime int64
   374  	ticket      uint32
   375  
   376  	// isSelect indicates g is participating in a select, so
   377  	// g.selectDone must be CAS'd to win the wake-up race.
   378  	isSelect bool
   379  
   380  	// success indicates whether communication over channel c
   381  	// succeeded. It is true if the goroutine was awoken because a
   382  	// value was delivered over channel c, and false if awoken
   383  	// because c was closed.
   384  	success bool
   385  
   386  	// waiters is a count of semaRoot waiting list other than head of list,
   387  	// clamped to a uint16 to fit in unused space.
   388  	// Only meaningful at the head of the list.
   389  	// (If we wanted to be overly clever, we could store a high 16 bits
   390  	// in the second entry in the list.)
   391  	waiters uint16
   392  
   393  	parent   *sudog // semaRoot binary tree
   394  	waitlink *sudog // g.waiting list or semaRoot
   395  	waittail *sudog // semaRoot
   396  	c        *hchan // channel
   397  }
   398  
   399  type libcall struct {
   400  	fn   uintptr
   401  	n    uintptr // number of parameters
   402  	args uintptr // parameters
   403  	r1   uintptr // return values
   404  	r2   uintptr
   405  	err  uintptr // error number
   406  }
   407  
   408  // Stack describes a Go execution stack.
   409  // The bounds of the stack are exactly [lo, hi),
   410  // with no implicit data structures on either side.
   411  type stack struct {
   412  	lo uintptr
   413  	hi uintptr
   414  }
   415  
   416  // heldLockInfo gives info on a held lock and the rank of that lock
   417  type heldLockInfo struct {
   418  	lockAddr uintptr
   419  	rank     lockRank
   420  }
   421  
   422  type g struct {
   423  	// Stack parameters.
   424  	// stack describes the actual stack memory: [stack.lo, stack.hi).
   425  	// stackguard0 is the stack pointer compared in the Go stack growth prologue.
   426  	// It is stack.lo+StackGuard normally, but can be StackPreempt to trigger a preemption.
   427  	// stackguard1 is the stack pointer compared in the //go:systemstack stack growth prologue.
   428  	// It is stack.lo+StackGuard on g0 and gsignal stacks.
   429  	// It is ~0 on other goroutine stacks, to trigger a call to morestackc (and crash).
   430  	stack       stack   // offset known to runtime/cgo
   431  	stackguard0 uintptr // offset known to liblink
   432  	stackguard1 uintptr // offset known to liblink
   433  
   434  	_panic    *_panic // innermost panic - offset known to liblink
   435  	_defer    *_defer // innermost defer
   436  	m         *m      // current m; offset known to arm liblink
   437  	sched     gobuf
   438  	syscallsp uintptr // if status==Gsyscall, syscallsp = sched.sp to use during gc
   439  	syscallpc uintptr // if status==Gsyscall, syscallpc = sched.pc to use during gc
   440  	stktopsp  uintptr // expected sp at top of stack, to check in traceback
   441  	// param is a generic pointer parameter field used to pass
   442  	// values in particular contexts where other storage for the
   443  	// parameter would be difficult to find. It is currently used
   444  	// in four ways:
   445  	// 1. When a channel operation wakes up a blocked goroutine, it sets param to
   446  	//    point to the sudog of the completed blocking operation.
   447  	// 2. By gcAssistAlloc1 to signal back to its caller that the goroutine completed
   448  	//    the GC cycle. It is unsafe to do so in any other way, because the goroutine's
   449  	//    stack may have moved in the meantime.
   450  	// 3. By debugCallWrap to pass parameters to a new goroutine because allocating a
   451  	//    closure in the runtime is forbidden.
   452  	// 4. When a panic is recovered and control returns to the respective frame,
   453  	//    param may point to a savedOpenDeferState.
   454  	param        unsafe.Pointer
   455  	atomicstatus atomic.Uint32
   456  	stackLock    uint32 // sigprof/scang lock; TODO: fold in to atomicstatus
   457  	goid         uint64
   458  	schedlink    guintptr
   459  	waitsince    int64      // approx time when the g become blocked
   460  	waitreason   waitReason // if status==Gwaiting
   461  
   462  	preempt       bool // preemption signal, duplicates stackguard0 = stackpreempt
   463  	preemptStop   bool // transition to _Gpreempted on preemption; otherwise, just deschedule
   464  	preemptShrink bool // shrink stack at synchronous safe point
   465  
   466  	// asyncSafePoint is set if g is stopped at an asynchronous
   467  	// safe point. This means there are frames on the stack
   468  	// without precise pointer information.
   469  	asyncSafePoint bool
   470  
   471  	paniconfault bool // panic (instead of crash) on unexpected fault address
   472  	gcscandone   bool // g has scanned stack; protected by _Gscan bit in status
   473  	throwsplit   bool // must not split stack
   474  	// activeStackChans indicates that there are unlocked channels
   475  	// pointing into this goroutine's stack. If true, stack
   476  	// copying needs to acquire channel locks to protect these
   477  	// areas of the stack.
   478  	activeStackChans bool
   479  	// parkingOnChan indicates that the goroutine is about to
   480  	// park on a chansend or chanrecv. Used to signal an unsafe point
   481  	// for stack shrinking.
   482  	parkingOnChan atomic.Bool
   483  	// inMarkAssist indicates whether the goroutine is in mark assist.
   484  	// Used by the execution tracer.
   485  	inMarkAssist bool
   486  	coroexit     bool // argument to coroswitch_m
   487  
   488  	raceignore    int8  // ignore race detection events
   489  	nocgocallback bool  // whether disable callback from C
   490  	tracking      bool  // whether we're tracking this G for sched latency statistics
   491  	trackingSeq   uint8 // used to decide whether to track this G
   492  	trackingStamp int64 // timestamp of when the G last started being tracked
   493  	runnableTime  int64 // the amount of time spent runnable, cleared when running, only used when tracking
   494  	lockedm       muintptr
   495  	sig           uint32
   496  	writebuf      []byte
   497  	sigcode0      uintptr
   498  	sigcode1      uintptr
   499  	sigpc         uintptr
   500  	parentGoid    uint64          // goid of goroutine that created this goroutine
   501  	gopc          uintptr         // pc of go statement that created this goroutine
   502  	ancestors     *[]ancestorInfo // ancestor information goroutine(s) that created this goroutine (only used if debug.tracebackancestors)
   503  	startpc       uintptr         // pc of goroutine function
   504  	racectx       uintptr
   505  	waiting       *sudog         // sudog structures this g is waiting on (that have a valid elem ptr); in lock order
   506  	cgoCtxt       []uintptr      // cgo traceback context
   507  	labels        unsafe.Pointer // profiler labels
   508  	timer         *timer         // cached timer for time.Sleep
   509  	selectDone    atomic.Uint32  // are we participating in a select and did someone win the race?
   510  
   511  	coroarg *coro // argument during coroutine transfers
   512  
   513  	// goroutineProfiled indicates the status of this goroutine's stack for the
   514  	// current in-progress goroutine profile
   515  	goroutineProfiled goroutineProfileStateHolder
   516  
   517  	// Per-G tracer state.
   518  	trace gTraceState
   519  
   520  	// Per-G GC state
   521  
   522  	// gcAssistBytes is this G's GC assist credit in terms of
   523  	// bytes allocated. If this is positive, then the G has credit
   524  	// to allocate gcAssistBytes bytes without assisting. If this
   525  	// is negative, then the G must correct this by performing
   526  	// scan work. We track this in bytes to make it fast to update
   527  	// and check for debt in the malloc hot path. The assist ratio
   528  	// determines how this corresponds to scan work debt.
   529  	gcAssistBytes int64
   530  }
   531  
   532  // gTrackingPeriod is the number of transitions out of _Grunning between
   533  // latency tracking runs.
   534  const gTrackingPeriod = 8
   535  
   536  const (
   537  	// tlsSlots is the number of pointer-sized slots reserved for TLS on some platforms,
   538  	// like Windows.
   539  	tlsSlots = 6
   540  	tlsSize  = tlsSlots * goarch.PtrSize
   541  )
   542  
   543  // Values for m.freeWait.
   544  const (
   545  	freeMStack = 0 // M done, free stack and reference.
   546  	freeMRef   = 1 // M done, free reference.
   547  	freeMWait  = 2 // M still in use.
   548  )
   549  
   550  type m struct {
   551  	g0      *g     // goroutine with scheduling stack
   552  	morebuf gobuf  // gobuf arg to morestack
   553  	divmod  uint32 // div/mod denominator for arm - known to liblink
   554  	_       uint32 // align next field to 8 bytes
   555  
   556  	// Fields not known to debuggers.
   557  	procid        uint64            // for debuggers, but offset not hard-coded
   558  	gsignal       *g                // signal-handling g
   559  	goSigStack    gsignalStack      // Go-allocated signal handling stack
   560  	sigmask       sigset            // storage for saved signal mask
   561  	tls           [tlsSlots]uintptr // thread-local storage (for x86 extern register)
   562  	mstartfn      func()
   563  	curg          *g       // current running goroutine
   564  	caughtsig     guintptr // goroutine running during fatal signal
   565  	p             puintptr // attached p for executing go code (nil if not executing go code)
   566  	nextp         puintptr
   567  	oldp          puintptr // the p that was attached before executing a syscall
   568  	id            int64
   569  	mallocing     int32
   570  	throwing      throwType
   571  	preemptoff    string // if != "", keep curg running on this m
   572  	locks         int32
   573  	dying         int32
   574  	profilehz     int32
   575  	spinning      bool // m is out of work and is actively looking for work
   576  	blocked       bool // m is blocked on a note
   577  	newSigstack   bool // minit on C thread called sigaltstack
   578  	printlock     int8
   579  	incgo         bool          // m is executing a cgo call
   580  	isextra       bool          // m is an extra m
   581  	isExtraInC    bool          // m is an extra m that is not executing Go code
   582  	isExtraInSig  bool          // m is an extra m in a signal handler
   583  	freeWait      atomic.Uint32 // Whether it is safe to free g0 and delete m (one of freeMRef, freeMStack, freeMWait)
   584  	needextram    bool
   585  	traceback     uint8
   586  	ncgocall      uint64        // number of cgo calls in total
   587  	ncgo          int32         // number of cgo calls currently in progress
   588  	cgoCallersUse atomic.Uint32 // if non-zero, cgoCallers in use temporarily
   589  	cgoCallers    *cgoCallers   // cgo traceback if crashing in cgo call
   590  	park          note
   591  	alllink       *m // on allm
   592  	schedlink     muintptr
   593  	lockedg       guintptr
   594  	createstack   [32]uintptr // stack that created this thread, it's used for StackRecord.Stack0, so it must align with it.
   595  	lockedExt     uint32      // tracking for external LockOSThread
   596  	lockedInt     uint32      // tracking for internal lockOSThread
   597  	nextwaitm     muintptr    // next m waiting for lock
   598  
   599  	mLockProfile mLockProfile // fields relating to runtime.lock contention
   600  
   601  	// wait* are used to carry arguments from gopark into park_m, because
   602  	// there's no stack to put them on. That is their sole purpose.
   603  	waitunlockf          func(*g, unsafe.Pointer) bool
   604  	waitlock             unsafe.Pointer
   605  	waitTraceBlockReason traceBlockReason
   606  	waitTraceSkip        int
   607  
   608  	syscalltick uint32
   609  	freelink    *m // on sched.freem
   610  	trace       mTraceState
   611  
   612  	// these are here because they are too large to be on the stack
   613  	// of low-level NOSPLIT functions.
   614  	libcall   libcall
   615  	libcallpc uintptr // for cpu profiler
   616  	libcallsp uintptr
   617  	libcallg  guintptr
   618  	syscall   libcall // stores syscall parameters on windows
   619  
   620  	vdsoSP uintptr // SP for traceback while in VDSO call (0 if not in call)
   621  	vdsoPC uintptr // PC for traceback while in VDSO call
   622  
   623  	// preemptGen counts the number of completed preemption
   624  	// signals. This is used to detect when a preemption is
   625  	// requested, but fails.
   626  	preemptGen atomic.Uint32
   627  
   628  	// Whether this is a pending preemption signal on this M.
   629  	signalPending atomic.Uint32
   630  
   631  	// pcvalue lookup cache
   632  	pcvalueCache pcvalueCache
   633  
   634  	dlogPerM
   635  
   636  	mOS
   637  
   638  	chacha8   chacha8rand.State
   639  	cheaprand uint64
   640  
   641  	// Up to 10 locks held by this m, maintained by the lock ranking code.
   642  	locksHeldLen int
   643  	locksHeld    [10]heldLockInfo
   644  }
   645  
   646  type p struct {
   647  	id          int32
   648  	status      uint32 // one of pidle/prunning/...
   649  	link        puintptr
   650  	schedtick   uint32     // incremented on every scheduler call
   651  	syscalltick uint32     // incremented on every system call
   652  	sysmontick  sysmontick // last tick observed by sysmon
   653  	m           muintptr   // back-link to associated m (nil if idle)
   654  	mcache      *mcache
   655  	pcache      pageCache
   656  	raceprocctx uintptr
   657  
   658  	deferpool    []*_defer // pool of available defer structs (see panic.go)
   659  	deferpoolbuf [32]*_defer
   660  
   661  	// Cache of goroutine ids, amortizes accesses to runtime·sched.goidgen.
   662  	goidcache    uint64
   663  	goidcacheend uint64
   664  
   665  	// Queue of runnable goroutines. Accessed without lock.
   666  	runqhead uint32
   667  	runqtail uint32
   668  	runq     [256]guintptr
   669  	// runnext, if non-nil, is a runnable G that was ready'd by
   670  	// the current G and should be run next instead of what's in
   671  	// runq if there's time remaining in the running G's time
   672  	// slice. It will inherit the time left in the current time
   673  	// slice. If a set of goroutines is locked in a
   674  	// communicate-and-wait pattern, this schedules that set as a
   675  	// unit and eliminates the (potentially large) scheduling
   676  	// latency that otherwise arises from adding the ready'd
   677  	// goroutines to the end of the run queue.
   678  	//
   679  	// Note that while other P's may atomically CAS this to zero,
   680  	// only the owner P can CAS it to a valid G.
   681  	runnext guintptr
   682  
   683  	// Available G's (status == Gdead)
   684  	gFree struct {
   685  		gList
   686  		n int32
   687  	}
   688  
   689  	sudogcache []*sudog
   690  	sudogbuf   [128]*sudog
   691  
   692  	// Cache of mspan objects from the heap.
   693  	mspancache struct {
   694  		// We need an explicit length here because this field is used
   695  		// in allocation codepaths where write barriers are not allowed,
   696  		// and eliminating the write barrier/keeping it eliminated from
   697  		// slice updates is tricky, more so than just managing the length
   698  		// ourselves.
   699  		len int
   700  		buf [128]*mspan
   701  	}
   702  
   703  	// Cache of a single pinner object to reduce allocations from repeated
   704  	// pinner creation.
   705  	pinnerCache *pinner
   706  
   707  	trace pTraceState
   708  
   709  	palloc persistentAlloc // per-P to avoid mutex
   710  
   711  	// The when field of the first entry on the timer heap.
   712  	// This is 0 if the timer heap is empty.
   713  	timer0When atomic.Int64
   714  
   715  	// The earliest known nextwhen field of a timer with
   716  	// timerModifiedEarlier status. Because the timer may have been
   717  	// modified again, there need not be any timer with this value.
   718  	// This is 0 if there are no timerModifiedEarlier timers.
   719  	timerModifiedEarliest atomic.Int64
   720  
   721  	// Per-P GC state
   722  	gcAssistTime         int64 // Nanoseconds in assistAlloc
   723  	gcFractionalMarkTime int64 // Nanoseconds in fractional mark worker (atomic)
   724  
   725  	// limiterEvent tracks events for the GC CPU limiter.
   726  	limiterEvent limiterEvent
   727  
   728  	// gcMarkWorkerMode is the mode for the next mark worker to run in.
   729  	// That is, this is used to communicate with the worker goroutine
   730  	// selected for immediate execution by
   731  	// gcController.findRunnableGCWorker. When scheduling other goroutines,
   732  	// this field must be set to gcMarkWorkerNotWorker.
   733  	gcMarkWorkerMode gcMarkWorkerMode
   734  	// gcMarkWorkerStartTime is the nanotime() at which the most recent
   735  	// mark worker started.
   736  	gcMarkWorkerStartTime int64
   737  
   738  	// gcw is this P's GC work buffer cache. The work buffer is
   739  	// filled by write barriers, drained by mutator assists, and
   740  	// disposed on certain GC state transitions.
   741  	gcw gcWork
   742  
   743  	// wbBuf is this P's GC write barrier buffer.
   744  	//
   745  	// TODO: Consider caching this in the running G.
   746  	wbBuf wbBuf
   747  
   748  	runSafePointFn uint32 // if 1, run sched.safePointFn at next safe point
   749  
   750  	// statsSeq is a counter indicating whether this P is currently
   751  	// writing any stats. Its value is even when not, odd when it is.
   752  	statsSeq atomic.Uint32
   753  
   754  	// Lock for timers. We normally access the timers while running
   755  	// on this P, but the scheduler can also do it from a different P.
   756  	timersLock mutex
   757  
   758  	// Actions to take at some time. This is used to implement the
   759  	// standard library's time package.
   760  	// Must hold timersLock to access.
   761  	timers []*timer
   762  
   763  	// Number of timers in P's heap.
   764  	numTimers atomic.Uint32
   765  
   766  	// Number of timerDeleted timers in P's heap.
   767  	deletedTimers atomic.Uint32
   768  
   769  	// Race context used while executing timer functions.
   770  	timerRaceCtx uintptr
   771  
   772  	// maxStackScanDelta accumulates the amount of stack space held by
   773  	// live goroutines (i.e. those eligible for stack scanning).
   774  	// Flushed to gcController.maxStackScan once maxStackScanSlack
   775  	// or -maxStackScanSlack is reached.
   776  	maxStackScanDelta int64
   777  
   778  	// gc-time statistics about current goroutines
   779  	// Note that this differs from maxStackScan in that this
   780  	// accumulates the actual stack observed to be used at GC time (hi - sp),
   781  	// not an instantaneous measure of the total stack size that might need
   782  	// to be scanned (hi - lo).
   783  	scannedStackSize uint64 // stack size of goroutines scanned by this P
   784  	scannedStacks    uint64 // number of goroutines scanned by this P
   785  
   786  	// preempt is set to indicate that this P should be enter the
   787  	// scheduler ASAP (regardless of what G is running on it).
   788  	preempt bool
   789  
   790  	// pageTraceBuf is a buffer for writing out page allocation/free/scavenge traces.
   791  	//
   792  	// Used only if GOEXPERIMENT=pagetrace.
   793  	pageTraceBuf pageTraceBuf
   794  
   795  	// Padding is no longer needed. False sharing is now not a worry because p is large enough
   796  	// that its size class is an integer multiple of the cache line size (for any of our architectures).
   797  }
   798  
   799  type schedt struct {
   800  	goidgen   atomic.Uint64
   801  	lastpoll  atomic.Int64 // time of last network poll, 0 if currently polling
   802  	pollUntil atomic.Int64 // time to which current poll is sleeping
   803  
   804  	lock mutex
   805  
   806  	// When increasing nmidle, nmidlelocked, nmsys, or nmfreed, be
   807  	// sure to call checkdead().
   808  
   809  	midle        muintptr // idle m's waiting for work
   810  	nmidle       int32    // number of idle m's waiting for work
   811  	nmidlelocked int32    // number of locked m's waiting for work
   812  	mnext        int64    // number of m's that have been created and next M ID
   813  	maxmcount    int32    // maximum number of m's allowed (or die)
   814  	nmsys        int32    // number of system m's not counted for deadlock
   815  	nmfreed      int64    // cumulative number of freed m's
   816  
   817  	ngsys atomic.Int32 // number of system goroutines
   818  
   819  	pidle        puintptr // idle p's
   820  	npidle       atomic.Int32
   821  	nmspinning   atomic.Int32  // See "Worker thread parking/unparking" comment in proc.go.
   822  	needspinning atomic.Uint32 // See "Delicate dance" comment in proc.go. Boolean. Must hold sched.lock to set to 1.
   823  
   824  	// Global runnable queue.
   825  	runq     gQueue
   826  	runqsize int32
   827  
   828  	// disable controls selective disabling of the scheduler.
   829  	//
   830  	// Use schedEnableUser to control this.
   831  	//
   832  	// disable is protected by sched.lock.
   833  	disable struct {
   834  		// user disables scheduling of user goroutines.
   835  		user     bool
   836  		runnable gQueue // pending runnable Gs
   837  		n        int32  // length of runnable
   838  	}
   839  
   840  	// Global cache of dead G's.
   841  	gFree struct {
   842  		lock    mutex
   843  		stack   gList // Gs with stacks
   844  		noStack gList // Gs without stacks
   845  		n       int32
   846  	}
   847  
   848  	// Central cache of sudog structs.
   849  	sudoglock  mutex
   850  	sudogcache *sudog
   851  
   852  	// Central pool of available defer structs.
   853  	deferlock mutex
   854  	deferpool *_defer
   855  
   856  	// freem is the list of m's waiting to be freed when their
   857  	// m.exited is set. Linked through m.freelink.
   858  	freem *m
   859  
   860  	gcwaiting  atomic.Bool // gc is waiting to run
   861  	stopwait   int32
   862  	stopnote   note
   863  	sysmonwait atomic.Bool
   864  	sysmonnote note
   865  
   866  	// safePointFn should be called on each P at the next GC
   867  	// safepoint if p.runSafePointFn is set.
   868  	safePointFn   func(*p)
   869  	safePointWait int32
   870  	safePointNote note
   871  
   872  	profilehz int32 // cpu profiling rate
   873  
   874  	procresizetime int64 // nanotime() of last change to gomaxprocs
   875  	totaltime      int64 // ∫gomaxprocs dt up to procresizetime
   876  
   877  	// sysmonlock protects sysmon's actions on the runtime.
   878  	//
   879  	// Acquire and hold this mutex to block sysmon from interacting
   880  	// with the rest of the runtime.
   881  	sysmonlock mutex
   882  
   883  	// timeToRun is a distribution of scheduling latencies, defined
   884  	// as the sum of time a G spends in the _Grunnable state before
   885  	// it transitions to _Grunning.
   886  	timeToRun timeHistogram
   887  
   888  	// idleTime is the total CPU time Ps have "spent" idle.
   889  	//
   890  	// Reset on each GC cycle.
   891  	idleTime atomic.Int64
   892  
   893  	// totalMutexWaitTime is the sum of time goroutines have spent in _Gwaiting
   894  	// with a waitreason of the form waitReasonSync{RW,}Mutex{R,}Lock.
   895  	totalMutexWaitTime atomic.Int64
   896  
   897  	// stwStoppingTimeGC/Other are distributions of stop-the-world stopping
   898  	// latencies, defined as the time taken by stopTheWorldWithSema to get
   899  	// all Ps to stop. stwStoppingTimeGC covers all GC-related STWs,
   900  	// stwStoppingTimeOther covers the others.
   901  	stwStoppingTimeGC    timeHistogram
   902  	stwStoppingTimeOther timeHistogram
   903  
   904  	// stwTotalTimeGC/Other are distributions of stop-the-world total
   905  	// latencies, defined as the total time from stopTheWorldWithSema to
   906  	// startTheWorldWithSema. This is a superset of
   907  	// stwStoppingTimeGC/Other. stwTotalTimeGC covers all GC-related STWs,
   908  	// stwTotalTimeOther covers the others.
   909  	stwTotalTimeGC    timeHistogram
   910  	stwTotalTimeOther timeHistogram
   911  
   912  	// totalRuntimeLockWaitTime (plus the value of lockWaitTime on each M in
   913  	// allm) is the sum of time goroutines have spent in _Grunnable and with an
   914  	// M, but waiting for locks within the runtime. This field stores the value
   915  	// for Ms that have exited.
   916  	totalRuntimeLockWaitTime atomic.Int64
   917  }
   918  
   919  // Values for the flags field of a sigTabT.
   920  const (
   921  	_SigNotify   = 1 << iota // let signal.Notify have signal, even if from kernel
   922  	_SigKill                 // if signal.Notify doesn't take it, exit quietly
   923  	_SigThrow                // if signal.Notify doesn't take it, exit loudly
   924  	_SigPanic                // if the signal is from the kernel, panic
   925  	_SigDefault              // if the signal isn't explicitly requested, don't monitor it
   926  	_SigGoExit               // cause all runtime procs to exit (only used on Plan 9).
   927  	_SigSetStack             // Don't explicitly install handler, but add SA_ONSTACK to existing libc handler
   928  	_SigUnblock              // always unblock; see blockableSig
   929  	_SigIgn                  // _SIG_DFL action is to ignore the signal
   930  )
   931  
   932  // Layout of in-memory per-function information prepared by linker
   933  // See https://golang.org/s/go12symtab.
   934  // Keep in sync with linker (../cmd/link/internal/ld/pcln.go:/pclntab)
   935  // and with package debug/gosym and with symtab.go in package runtime.
   936  type _func struct {
   937  	sys.NotInHeap // Only in static data
   938  
   939  	entryOff uint32 // start pc, as offset from moduledata.text/pcHeader.textStart
   940  	nameOff  int32  // function name, as index into moduledata.funcnametab.
   941  
   942  	args        int32  // in/out args size
   943  	deferreturn uint32 // offset of start of a deferreturn call instruction from entry, if any.
   944  
   945  	pcsp      uint32
   946  	pcfile    uint32
   947  	pcln      uint32
   948  	npcdata   uint32
   949  	cuOffset  uint32     // runtime.cutab offset of this function's CU
   950  	startLine int32      // line number of start of function (func keyword/TEXT directive)
   951  	funcID    abi.FuncID // set for certain special runtime functions
   952  	flag      abi.FuncFlag
   953  	_         [1]byte // pad
   954  	nfuncdata uint8   // must be last, must end on a uint32-aligned boundary
   955  
   956  	// The end of the struct is followed immediately by two variable-length
   957  	// arrays that reference the pcdata and funcdata locations for this
   958  	// function.
   959  
   960  	// pcdata contains the offset into moduledata.pctab for the start of
   961  	// that index's table. e.g.,
   962  	// &moduledata.pctab[_func.pcdata[_PCDATA_UnsafePoint]] is the start of
   963  	// the unsafe point table.
   964  	//
   965  	// An offset of 0 indicates that there is no table.
   966  	//
   967  	// pcdata [npcdata]uint32
   968  
   969  	// funcdata contains the offset past moduledata.gofunc which contains a
   970  	// pointer to that index's funcdata. e.g.,
   971  	// *(moduledata.gofunc +  _func.funcdata[_FUNCDATA_ArgsPointerMaps]) is
   972  	// the argument pointer map.
   973  	//
   974  	// An offset of ^uint32(0) indicates that there is no entry.
   975  	//
   976  	// funcdata [nfuncdata]uint32
   977  }
   978  
   979  // Pseudo-Func that is returned for PCs that occur in inlined code.
   980  // A *Func can be either a *_func or a *funcinl, and they are distinguished
   981  // by the first uintptr.
   982  //
   983  // TODO(austin): Can we merge this with inlinedCall?
   984  type funcinl struct {
   985  	ones      uint32  // set to ^0 to distinguish from _func
   986  	entry     uintptr // entry of the real (the "outermost") frame
   987  	name      string
   988  	file      string
   989  	line      int32
   990  	startLine int32
   991  }
   992  
   993  // layout of Itab known to compilers
   994  // allocated in non-garbage-collected memory
   995  // Needs to be in sync with
   996  // ../cmd/compile/internal/reflectdata/reflect.go:/^func.WritePluginTable.
   997  type itab struct {
   998  	inter *interfacetype
   999  	_type *_type
  1000  	hash  uint32 // copy of _type.hash. Used for type switches.
  1001  	_     [4]byte
  1002  	fun   [1]uintptr // variable sized. fun[0]==0 means _type does not implement inter.
  1003  }
  1004  
  1005  // Lock-free stack node.
  1006  // Also known to export_test.go.
  1007  type lfnode struct {
  1008  	next    uint64
  1009  	pushcnt uintptr
  1010  }
  1011  
  1012  type forcegcstate struct {
  1013  	lock mutex
  1014  	g    *g
  1015  	idle atomic.Bool
  1016  }
  1017  
  1018  // A _defer holds an entry on the list of deferred calls.
  1019  // If you add a field here, add code to clear it in deferProcStack.
  1020  // This struct must match the code in cmd/compile/internal/ssagen/ssa.go:deferstruct
  1021  // and cmd/compile/internal/ssagen/ssa.go:(*state).call.
  1022  // Some defers will be allocated on the stack and some on the heap.
  1023  // All defers are logically part of the stack, so write barriers to
  1024  // initialize them are not required. All defers must be manually scanned,
  1025  // and for heap defers, marked.
  1026  type _defer struct {
  1027  	heap      bool
  1028  	rangefunc bool    // true for rangefunc list
  1029  	sp        uintptr // sp at time of defer
  1030  	pc        uintptr // pc at time of defer
  1031  	fn        func()  // can be nil for open-coded defers
  1032  	link      *_defer // next defer on G; can point to either heap or stack!
  1033  
  1034  	// If rangefunc is true, *head is the head of the atomic linked list
  1035  	// during a range-over-func execution.
  1036  	head *atomic.Pointer[_defer]
  1037  }
  1038  
  1039  // A _panic holds information about an active panic.
  1040  //
  1041  // A _panic value must only ever live on the stack.
  1042  //
  1043  // The argp and link fields are stack pointers, but don't need special
  1044  // handling during stack growth: because they are pointer-typed and
  1045  // _panic values only live on the stack, regular stack pointer
  1046  // adjustment takes care of them.
  1047  type _panic struct {
  1048  	argp unsafe.Pointer // pointer to arguments of deferred call run during panic; cannot move - known to liblink
  1049  	arg  any            // argument to panic
  1050  	link *_panic        // link to earlier panic
  1051  
  1052  	// startPC and startSP track where _panic.start was called.
  1053  	startPC uintptr
  1054  	startSP unsafe.Pointer
  1055  
  1056  	// The current stack frame that we're running deferred calls for.
  1057  	sp unsafe.Pointer
  1058  	lr uintptr
  1059  	fp unsafe.Pointer
  1060  
  1061  	// retpc stores the PC where the panic should jump back to, if the
  1062  	// function last returned by _panic.next() recovers the panic.
  1063  	retpc uintptr
  1064  
  1065  	// Extra state for handling open-coded defers.
  1066  	deferBitsPtr *uint8
  1067  	slotsPtr     unsafe.Pointer
  1068  
  1069  	recovered   bool // whether this panic has been recovered
  1070  	goexit      bool
  1071  	deferreturn bool
  1072  }
  1073  
  1074  // savedOpenDeferState tracks the extra state from _panic that's
  1075  // necessary for deferreturn to pick up where gopanic left off,
  1076  // without needing to unwind the stack.
  1077  type savedOpenDeferState struct {
  1078  	retpc           uintptr
  1079  	deferBitsOffset uintptr
  1080  	slotsOffset     uintptr
  1081  }
  1082  
  1083  // ancestorInfo records details of where a goroutine was started.
  1084  type ancestorInfo struct {
  1085  	pcs  []uintptr // pcs from the stack of this goroutine
  1086  	goid uint64    // goroutine id of this goroutine; original goroutine possibly dead
  1087  	gopc uintptr   // pc of go statement that created this goroutine
  1088  }
  1089  
  1090  // A waitReason explains why a goroutine has been stopped.
  1091  // See gopark. Do not re-use waitReasons, add new ones.
  1092  type waitReason uint8
  1093  
  1094  const (
  1095  	waitReasonZero                  waitReason = iota // ""
  1096  	waitReasonGCAssistMarking                         // "GC assist marking"
  1097  	waitReasonIOWait                                  // "IO wait"
  1098  	waitReasonChanReceiveNilChan                      // "chan receive (nil chan)"
  1099  	waitReasonChanSendNilChan                         // "chan send (nil chan)"
  1100  	waitReasonDumpingHeap                             // "dumping heap"
  1101  	waitReasonGarbageCollection                       // "garbage collection"
  1102  	waitReasonGarbageCollectionScan                   // "garbage collection scan"
  1103  	waitReasonPanicWait                               // "panicwait"
  1104  	waitReasonSelect                                  // "select"
  1105  	waitReasonSelectNoCases                           // "select (no cases)"
  1106  	waitReasonGCAssistWait                            // "GC assist wait"
  1107  	waitReasonGCSweepWait                             // "GC sweep wait"
  1108  	waitReasonGCScavengeWait                          // "GC scavenge wait"
  1109  	waitReasonChanReceive                             // "chan receive"
  1110  	waitReasonChanSend                                // "chan send"
  1111  	waitReasonFinalizerWait                           // "finalizer wait"
  1112  	waitReasonForceGCIdle                             // "force gc (idle)"
  1113  	waitReasonSemacquire                              // "semacquire"
  1114  	waitReasonSleep                                   // "sleep"
  1115  	waitReasonSyncCondWait                            // "sync.Cond.Wait"
  1116  	waitReasonSyncMutexLock                           // "sync.Mutex.Lock"
  1117  	waitReasonSyncRWMutexRLock                        // "sync.RWMutex.RLock"
  1118  	waitReasonSyncRWMutexLock                         // "sync.RWMutex.Lock"
  1119  	waitReasonTraceReaderBlocked                      // "trace reader (blocked)"
  1120  	waitReasonWaitForGCCycle                          // "wait for GC cycle"
  1121  	waitReasonGCWorkerIdle                            // "GC worker (idle)"
  1122  	waitReasonGCWorkerActive                          // "GC worker (active)"
  1123  	waitReasonPreempted                               // "preempted"
  1124  	waitReasonDebugCall                               // "debug call"
  1125  	waitReasonGCMarkTermination                       // "GC mark termination"
  1126  	waitReasonStoppingTheWorld                        // "stopping the world"
  1127  	waitReasonFlushProcCaches                         // "flushing proc caches"
  1128  	waitReasonTraceGoroutineStatus                    // "trace goroutine status"
  1129  	waitReasonTraceProcStatus                         // "trace proc status"
  1130  	waitReasonPageTraceFlush                          // "page trace flush"
  1131  	waitReasonCoroutine                               // "coroutine"
  1132  )
  1133  
  1134  var waitReasonStrings = [...]string{
  1135  	waitReasonZero:                  "",
  1136  	waitReasonGCAssistMarking:       "GC assist marking",
  1137  	waitReasonIOWait:                "IO wait",
  1138  	waitReasonChanReceiveNilChan:    "chan receive (nil chan)",
  1139  	waitReasonChanSendNilChan:       "chan send (nil chan)",
  1140  	waitReasonDumpingHeap:           "dumping heap",
  1141  	waitReasonGarbageCollection:     "garbage collection",
  1142  	waitReasonGarbageCollectionScan: "garbage collection scan",
  1143  	waitReasonPanicWait:             "panicwait",
  1144  	waitReasonSelect:                "select",
  1145  	waitReasonSelectNoCases:         "select (no cases)",
  1146  	waitReasonGCAssistWait:          "GC assist wait",
  1147  	waitReasonGCSweepWait:           "GC sweep wait",
  1148  	waitReasonGCScavengeWait:        "GC scavenge wait",
  1149  	waitReasonChanReceive:           "chan receive",
  1150  	waitReasonChanSend:              "chan send",
  1151  	waitReasonFinalizerWait:         "finalizer wait",
  1152  	waitReasonForceGCIdle:           "force gc (idle)",
  1153  	waitReasonSemacquire:            "semacquire",
  1154  	waitReasonSleep:                 "sleep",
  1155  	waitReasonSyncCondWait:          "sync.Cond.Wait",
  1156  	waitReasonSyncMutexLock:         "sync.Mutex.Lock",
  1157  	waitReasonSyncRWMutexRLock:      "sync.RWMutex.RLock",
  1158  	waitReasonSyncRWMutexLock:       "sync.RWMutex.Lock",
  1159  	waitReasonTraceReaderBlocked:    "trace reader (blocked)",
  1160  	waitReasonWaitForGCCycle:        "wait for GC cycle",
  1161  	waitReasonGCWorkerIdle:          "GC worker (idle)",
  1162  	waitReasonGCWorkerActive:        "GC worker (active)",
  1163  	waitReasonPreempted:             "preempted",
  1164  	waitReasonDebugCall:             "debug call",
  1165  	waitReasonGCMarkTermination:     "GC mark termination",
  1166  	waitReasonStoppingTheWorld:      "stopping the world",
  1167  	waitReasonFlushProcCaches:       "flushing proc caches",
  1168  	waitReasonTraceGoroutineStatus:  "trace goroutine status",
  1169  	waitReasonTraceProcStatus:       "trace proc status",
  1170  	waitReasonPageTraceFlush:        "page trace flush",
  1171  	waitReasonCoroutine:             "coroutine",
  1172  }
  1173  
  1174  func (w waitReason) String() string {
  1175  	if w < 0 || w >= waitReason(len(waitReasonStrings)) {
  1176  		return "unknown wait reason"
  1177  	}
  1178  	return waitReasonStrings[w]
  1179  }
  1180  
  1181  func (w waitReason) isMutexWait() bool {
  1182  	return w == waitReasonSyncMutexLock ||
  1183  		w == waitReasonSyncRWMutexRLock ||
  1184  		w == waitReasonSyncRWMutexLock
  1185  }
  1186  
  1187  var (
  1188  	allm       *m
  1189  	gomaxprocs int32
  1190  	ncpu       int32
  1191  	forcegc    forcegcstate
  1192  	sched      schedt
  1193  	newprocs   int32
  1194  
  1195  	// allpLock protects P-less reads and size changes of allp, idlepMask,
  1196  	// and timerpMask, and all writes to allp.
  1197  	allpLock mutex
  1198  	// len(allp) == gomaxprocs; may change at safe points, otherwise
  1199  	// immutable.
  1200  	allp []*p
  1201  	// Bitmask of Ps in _Pidle list, one bit per P. Reads and writes must
  1202  	// be atomic. Length may change at safe points.
  1203  	//
  1204  	// Each P must update only its own bit. In order to maintain
  1205  	// consistency, a P going idle must the idle mask simultaneously with
  1206  	// updates to the idle P list under the sched.lock, otherwise a racing
  1207  	// pidleget may clear the mask before pidleput sets the mask,
  1208  	// corrupting the bitmap.
  1209  	//
  1210  	// N.B., procresize takes ownership of all Ps in stopTheWorldWithSema.
  1211  	idlepMask pMask
  1212  	// Bitmask of Ps that may have a timer, one bit per P. Reads and writes
  1213  	// must be atomic. Length may change at safe points.
  1214  	timerpMask pMask
  1215  
  1216  	// Pool of GC parked background workers. Entries are type
  1217  	// *gcBgMarkWorkerNode.
  1218  	gcBgMarkWorkerPool lfstack
  1219  
  1220  	// Total number of gcBgMarkWorker goroutines. Protected by worldsema.
  1221  	gcBgMarkWorkerCount int32
  1222  
  1223  	// Information about what cpu features are available.
  1224  	// Packages outside the runtime should not use these
  1225  	// as they are not an external api.
  1226  	// Set on startup in asm_{386,amd64}.s
  1227  	processorVersionInfo uint32
  1228  	isIntel              bool
  1229  
  1230  	// set by cmd/link on arm systems
  1231  	goarm       uint8
  1232  	goarmsoftfp uint8
  1233  )
  1234  
  1235  // Set by the linker so the runtime can determine the buildmode.
  1236  var (
  1237  	islibrary bool // -buildmode=c-shared
  1238  	isarchive bool // -buildmode=c-archive
  1239  )
  1240  
  1241  // Must agree with internal/buildcfg.FramePointerEnabled.
  1242  const framepointer_enabled = GOARCH == "amd64" || GOARCH == "arm64"
  1243  

View as plain text