stdgo

const (
	// StatusGidle means this goroutine was just allocated and has not
	// yet been initialized.
	StatusGidle Status = iota // 0

	// StatusGrunnable means this goroutine is on a run queue. It is
	// not currently executing user code. The stack is not owned.
	StatusGrunnable // 1

	// StatusGrunning means this goroutine may execute user code. The
	// stack is owned by this goroutine. It is not on a run queue.
	// It is assigned an M and a P (g.m and g.m.p are valid).
	StatusGrunning // 2

	// StatusGsyscall means this goroutine is executing a system call.
	// It is not executing user code. The stack is owned by this
	// goroutine. It is not on a run queue. It is assigned an M.
	StatusGsyscall // 3

	// StatusGwaiting means this goroutine is blocked in the runtime.
	// It is not executing user code. It is not on a run queue,
	// but should be recorded somewhere (e.g., a channel wait
	// queue) so it can be ready()d when necessary. The stack is
	// not owned *except* that a channel operation may read or
	// write parts of the stack under the appropriate channel
	// lock. Otherwise, it is not safe to access the stack after a
	// goroutine enters StatusGwaiting (e.g., it may get moved).
	StatusGwaiting // 4

	// StatusGmoribund_unused is currently unused, but hardcoded in gdb
	// scripts.
	StatusGmoribund_unused // 5

	// StatusGdead means this goroutine is currently unused. It may be
	// just exited, on a free list, or just being initialized. It
	// is not executing user code. It may or may not have a stack
	// allocated. The G and its stack (if any) are owned by the M
	// that is exiting the G or that obtained the G from the free
	// list.
	StatusGdead // 6

	// StatusGenqueue_unused is currently unused.
	StatusGenqueue_unused // 7

	// StatusGcopystack means this goroutine's stack is being moved. It
	// is not executing user code and is not on a run queue. The
	// stack is owned by the goroutine that put it in StatusGcopystack.
	StatusGcopystack // 8

	// StatusGpreempted means this goroutine stopped itself for a
	// suspendG preemption. It is like StatusGwaiting, but nothing is
	// yet responsible for ready()ing it. Some suspendG must CAS
	// the status to StatusGwaiting to take responsibility for
	// ready()ing this G.
	StatusGpreempted // 9

	// StatusGscan combined with one of the above states other than
	// StatusGrunning indicates that GC is scanning the stack. The
	// goroutine is not executing user code and the stack is owned
	// by the goroutine that set the StatusGscan bit.
	//
	// StatusGscanrunning is different: it is used to briefly block
	// state transitions while GC signals the G to scan its own
	// stack. This is otherwise like StatusGrunning.
	//
	// atomicstatus&~Gscan gives the state the goroutine will
	// return to when the scan completes.
	StatusGscan          Status = 0x1000
	StatusGscanrunnable  Status = StatusGscan + StatusGrunnable  // 0x1001
	StatusGscanrunning   Status = StatusGscan + StatusGrunning   // 0x1002
	StatusGscansyscall   Status = StatusGscan + StatusGsyscall   // 0x1003
	StatusGscanwaiting   Status = StatusGscan + StatusGwaiting   // 0x1004
	StatusGscanpreempted Status = StatusGscan + StatusGpreempted // 0x1009
)

const (
	WaitReasonZero                  WaitReason = iota // ""
	WaitReasonGCAssistMarking                         // "GC assist marking"
	WaitReasonIOWait                                  // "IO wait"
	WaitReasonChanReceiveNilChan                      // "chan receive (nil chan)"
	WaitReasonChanSendNilChan                         // "chan send (nil chan)"
	WaitReasonDumpingHeap                             // "dumping heap"
	WaitReasonGarbageCollection                       // "garbage collection"
	WaitReasonGarbageCollectionScan                   // "garbage collection scan"
	WaitReasonPanicWait                               // "panicwait"
	WaitReasonSelect                                  // "select"
	WaitReasonSelectNoCases                           // "select (no cases)"
	WaitReasonGCAssistWait                            // "GC assist wait"
	WaitReasonGCSweepWait                             // "GC sweep wait"
	WaitReasonGCScavengeWait                          // "GC scavenge wait"
	WaitReasonChanReceive                             // "chan receive"
	WaitReasonChanSend                                // "chan send"
	WaitReasonFinalizerWait                           // "finalizer wait"
	WaitReasonForceGCIdle                             // "force gc (idle)"
	WaitReasonSemacquire                              // "semacquire"
	WaitReasonSleep                                   // "sleep"
	WaitReasonSyncCondWait                            // "sync.Cond.Wait"
	WaitReasonSyncMutexLock                           // "sync.Mutex.Lock"
	WaitReasonSyncRWMutexRLock                        // "sync.RWMutex.RLock"
	WaitReasonSyncRWMutexLock                         // "sync.RWMutex.Lock"
	WaitReasonTraceReaderBlocked                      // "trace reader (blocked)"
	WaitReasonWaitForGCCycle                          // "wait for GC cycle"
	WaitReasonGCWorkerIdle                            // "GC worker (idle)"
	WaitReasonGCWorkerActive                          // "GC worker (active)"
	WaitReasonPreempted                               // "preempted"
	WaitReasonDebugCall                               // "debug call"
	WaitReasonGCMarkTermination                       // "GC mark termination"
	WaitReasonStoppingTheWorld                        // "stopping the world"
)