Collect goroutine leaks via profiling.

Remove debug flag.

Author: VladSaiocUber

src/net/http/pprof/pprof.go

@@ -351,25 +351,27 @@ func collectProfile(p *pprof.Profile) (*profile.Profile, error) {
 }
 
 var profileSupportsDelta = map[handler]bool{
-	"allocs":       true,
-	"block":        true,
-	"goroutine":    true,
-	"heap":         true,
-	"mutex":        true,
-	"threadcreate": true,
+	"allocs":        true,
+	"block":         true,
+	"goroutine":     true,
+	"goroutineleak": true,
+	"heap":          true,
+	"mutex":         true,
+	"threadcreate":  true,
 }
 
 var profileDescriptions = map[string]string{
-	"allocs":       "A sampling of all past memory allocations",
-	"block":        "Stack traces that led to blocking on synchronization primitives",
-	"cmdline":      "The command line invocation of the current program",
-	"goroutine":    "Stack traces of all current goroutines. Use debug=2 as a query parameter to export in the same format as an unrecovered panic.",
-	"heap":         "A sampling of memory allocations of live objects. You can specify the gc GET parameter to run GC before taking the heap sample.",
-	"mutex":        "Stack traces of holders of contended mutexes",
-	"profile":      "CPU profile. You can specify the duration in the seconds GET parameter. After you get the profile file, use the go tool pprof command to investigate the profile.",
-	"symbol":       "Maps given program counters to function names. Counters can be specified in a GET raw query or POST body, multiple counters are separated by '+'.",
-	"threadcreate": "Stack traces that led to the creation of new OS threads",
-	"trace":        "A trace of execution of the current program. You can specify the duration in the seconds GET parameter. After you get the trace file, use the go tool trace command to investigate the trace.",
+	"allocs":        "A sampling of all past memory allocations",
+	"block":         "Stack traces that led to blocking on synchronization primitives",
+	"cmdline":       "The command line invocation of the current program",
+	"goroutine":     "Stack traces of all current goroutines. Use debug=2 as a query parameter to export in the same format as an unrecovered panic.",
+	"goroutineleak": "Stack traces of all leaked goroutines. Use debug=2 as a query parameter to export in the same format as an unrecovered panic.",
+	"heap":          "A sampling of memory allocations of live objects. You can specify the gc GET parameter to run GC before taking the heap sample.",
+	"mutex":         "Stack traces of holders of contended mutexes",
+	"profile":       "CPU profile. You can specify the duration in the seconds GET parameter. After you get the profile file, use the go tool pprof command to investigate the profile.",
+	"symbol":        "Maps given program counters to function names. Counters can be specified in a GET raw query or POST body, multiple counters are separated by '+'.",
+	"threadcreate":  "Stack traces that led to the creation of new OS threads",
+	"trace":         "A trace of execution of the current program. You can specify the duration in the seconds GET parameter. After you get the trace file, use the go tool trace command to investigate the trace.",
 }
 
 type profileEntry struct {

src/runtime/mgc.go

@@ -569,6 +569,25 @@ func GC() {
 	releasem(mp)
 }
 
+//go:linkname runtime_goroutineLeakGC runtime/pprof.runtime_goroutineLeakGC
+func runtime_goroutineLeakGC() {
+	goroutineLeakGC()
+}
+
+// goroutineLeakGC runs a GC cycle that performs goroutine leak detection.
+func goroutineLeakGC() {
+	// Set the pending flag to true, instructing the next GC cycle to
+	// perform goroutine leak detection.
+	work.goroutineLeakFinder.pending.Store(true)
+
+	// Spin GC cycles until the pending flag is unset.
+	// This ensures that goroutineLeakGC waits for a GC cycle that
+	// actually performs goroutine leak detection.
+	for work.goroutineLeakFinder.pending.Load() {
+		GC()
+	}
+}
+
 // gcWaitOnMark blocks until GC finishes the Nth mark phase. If GC has
 // already completed this mark phase, it returns immediately.
 func gcWaitOnMark(n uint32) {
@@ -714,9 +733,9 @@ func gcStart(trigger gcTrigger) {
 		mode = gcForceMode
 	} else if debug.gcstoptheworld == 2 {
 		mode = gcForceBlockMode
-	} else if work.goroutineLeakFinder.pending.Load() || debug.gcgoroutineleaks > 0 {
-		// If goroutine leak detection has been enabled (via GODEBUG=gcgoroutineleaks=1),
-		// or via profiling, stop the world during the marking phase.
+	} else if work.goroutineLeakFinder.pending.Load() {
+		// If goroutine leak detection has been enabled via profiling,
+		// stop the world during the marking phase.
 		mode = gcForceMode
 	}
 
@@ -795,8 +814,7 @@ func gcStart(trigger gcTrigger) {
 		schedEnableUser(false)
 	}
 
-	if work.goroutineLeakFinder.pending.Load() ||
-		debug.gcgoroutineleaks > 0 {
+	if work.goroutineLeakFinder.pending.Load() {
 		work.goroutineLeakFinder.enabled = true
 		work.goroutineLeakFinder.pending.Store(false)
 		gcUntrackSyncObjects()
@@ -1199,16 +1217,6 @@ func findGoleaks() bool {
 	for i := work.nMaybeRunnableStackRoots; i < work.nStackRoots; i++ {
 		gp := work.stackRoots[i]
 		casgstatus(gp, _Gwaiting, _Gleaked)
-		fn := findfunc(gp.startpc)
-		if fn.valid() {
-			print("goroutine leak! goroutine ", gp.goid, ": ", funcname(fn), " Stack size: ", gp.stack.hi-gp.stack.lo, " bytes ",
-				"[", waitReasonStrings[gp.waitreason], "]\n")
-		} else {
-			print("goroutine leak! goroutine ", gp.goid, ": !unnamed goroutine!", " Stack size: ", gp.stack.hi-gp.stack.lo, " bytes ",
-				"[", waitReasonStrings[gp.waitreason], "]\n")
-		}
-		traceback(gp.sched.pc, gp.sched.sp, gp.sched.lr, gp)
-		println()
 	}
 	// Put the remaining roots as ready for marking and drain them.
 	work.markrootJobs.Add(int32(work.nStackRoots - work.nMaybeRunnableStackRoots))

src/runtime/mprof.go

@@ -1259,6 +1259,20 @@ func goroutineProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.P
 	return goroutineProfileWithLabelsConcurrent(p, labels)
 }
 
+//go:linkname pprof_goroutineLeakProfileWithLabels
+func pprof_goroutineLeakProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
+	return goroutineLeakProfileWithLabelsConcurrent(p, labels)
+}
+
+// labels may be nil. If labels is non-nil, it must have the same length as p.
+func goroutineLeakProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
+	if labels != nil && len(labels) != len(p) {
+		labels = nil
+	}
+
+	return goroutineLeakProfileWithLabelsConcurrent(p, labels)
+}
+
 var goroutineProfile = struct {
 	sema    uint32
 	active  bool
@@ -1302,6 +1316,89 @@ func (p *goroutineProfileStateHolder) CompareAndSwap(old, new goroutineProfileSt
 	return (*atomic.Uint32)(p).CompareAndSwap(uint32(old), uint32(new))
 }
 
+func goroutineLeakProfileWithLabelsConcurrent(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
+	if len(p) == 0 {
+		// An empty slice is obviously too small. Return a rough
+		// allocation estimate without bothering to STW. As long as
+		// this is close, then we'll only need to STW once (on the next
+		// call).
+		return int(gleakcount()), false
+	}
+
+	// Use the same semaphore as goroutineProfileWithLabelsConcurrent,
+	// because ultimately we still use goroutine profiles.
+	semacquire(&goroutineProfile.sema)
+
+	// Unlike in goroutineProfileWithLabelsConcurrent, we don't save the current
+	// goroutine stack, because it is obviously not a leaked goroutine.
+
+	pcbuf := makeProfStack() // see saveg() for explanation
+	stw := stopTheWorld(stwGoroutineProfile)
+	// Using gleakcount while the world is stopped should give us a consistent view
+	// of the number of leaked goroutines.
+	n = int(gleakcount())
+
+	if n > len(p) {
+		// There's not enough space in p to store the whole profile, so (per the
+		// contract of runtime.GoroutineProfile) we're not allowed to write to p
+		// at all and must return n, false.
+		startTheWorld(stw)
+		semrelease(&goroutineProfile.sema)
+		return n, false
+	}
+
+	// Prepare for all other goroutines to enter the profile. Every goroutine struct in the allgs list
+	// has its goroutineProfiled field cleared. Any goroutine created from this point on (while
+	// goroutineProfile.active is set) will start with its goroutineProfiled
+	// field set to goroutineProfileSatisfied.
+	goroutineProfile.active = true
+	goroutineProfile.records = p
+	goroutineProfile.labels = labels
+	startTheWorld(stw)
+
+	// Visit each leaked goroutine that existed as of the startTheWorld call above.
+	forEachGRace(func(gp1 *g) {
+		if readgstatus(gp1) == _Gleaked {
+			tryRecordGoroutineProfile(gp1, pcbuf, Gosched)
+		}
+	})
+
+	stw = stopTheWorld(stwGoroutineProfileCleanup)
+	endOffset := goroutineProfile.offset.Swap(0)
+	goroutineProfile.active = false
+	goroutineProfile.records = nil
+	goroutineProfile.labels = nil
+	startTheWorld(stw)
+
+	// Restore the invariant that every goroutine struct in allgs has its
+	// goroutineProfiled field cleared.
+	forEachGRace(func(gp1 *g) {
+		gp1.goroutineProfiled.Store(goroutineProfileAbsent)
+	})
+
+	if raceenabled {
+		raceacquire(unsafe.Pointer(&labelSync))
+	}
+
+	if n != int(endOffset) {
+		// It's a big surprise that the number of goroutines changed while we
+		// were collecting the profile. But probably better to return a
+		// truncated profile than to crash the whole process.
+		//
+		// For instance, needm moves a goroutine out of the _Gdead state and so
+		// might be able to change the goroutine count without interacting with
+		// the scheduler. For code like that, the race windows are small and the
+		// combination of features is uncommon, so it's hard to be (and remain)
+		// sure we've caught them all.
+		//
+		// FIXME(vsaioc): I kept this in because goroutineProfileWithLabelsConcurrent
+		// also uses it, but... is this dead code?
+	}
+
+	semrelease(&goroutineProfile.sema)
+	return n, true
+}
+
 func goroutineProfileWithLabelsConcurrent(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
 	if len(p) == 0 {
 		// An empty slice is obviously too small. Return a rough

src/runtime/pprof/pprof.go

@@ -105,12 +105,13 @@ import (
 //
 // Each Profile has a unique name. A few profiles are predefined:
 //
-//	goroutine    - stack traces of all current goroutines
-//	heap         - a sampling of memory allocations of live objects
-//	allocs       - a sampling of all past memory allocations
-//	threadcreate - stack traces that led to the creation of new OS threads
-//	block        - stack traces that led to blocking on synchronization primitives
-//	mutex        - stack traces of holders of contended mutexes
+//	goroutine      - stack traces of all current goroutines
+//	goroutineleak  - stack traces of all leaked goroutines
+//	allocs         - a sampling of all past memory allocations
+//	heap           - a sampling of memory allocations of live objects
+//	threadcreate   - stack traces that led to the creation of new OS threads
+//	block          - stack traces that led to blocking on synchronization primitives
+//	mutex          - stack traces of holders of contended mutexes
 //
 // These predefined profiles maintain themselves and panic on an explicit
 // [Profile.Add] or [Profile.Remove] method call.
@@ -169,6 +170,7 @@ import (
 // holds a lock for 1s while 5 other goroutines are waiting for the entire
 // second to acquire the lock, its unlock call stack will report 5s of
 // contention.
+
 type Profile struct {
 	name  string
 	mu    sync.Mutex
@@ -189,6 +191,12 @@ var goroutineProfile = &Profile{
 	write: writeGoroutine,
 }
 
+var goroutineLeakProfile = &Profile{
+	name:  "goroutineleak",
+	count: countGoroutineLeak,
+	write: writeGoroutineLeak,
+}
+
 var threadcreateProfile = &Profile{
 	name:  "threadcreate",
 	count: countThreadCreate,
@@ -224,12 +232,13 @@ func lockProfiles() {
 	if profiles.m == nil {
 		// Initial built-in profiles.
 		profiles.m = map[string]*Profile{
-			"goroutine":    goroutineProfile,
-			"threadcreate": threadcreateProfile,
-			"heap":         heapProfile,
-			"allocs":       allocsProfile,
-			"block":        blockProfile,
-			"mutex":        mutexProfile,
+			"goroutine":     goroutineProfile,
+			"goroutineleak": goroutineLeakProfile,
+			"threadcreate":  threadcreateProfile,
+			"heap":          heapProfile,
+			"allocs":        allocsProfile,
+			"block":         blockProfile,
+			"mutex":         mutexProfile,
 		}
 	}
 }
@@ -739,6 +748,11 @@ func countGoroutine() int {
 	return runtime.NumGoroutine()
 }
 
+// countGoroutineLeak returns the number of leaked goroutines.
+func countGoroutineLeak() int {
+	return int(runtime_gleakcount())
+}
+
 // writeGoroutine writes the current runtime GoroutineProfile to w.
 func writeGoroutine(w io.Writer, debug int) error {
 	if debug >= 2 {
@@ -747,6 +761,23 @@ func writeGoroutine(w io.Writer, debug int) error {
 	return writeRuntimeProfile(w, debug, "goroutine", pprof_goroutineProfileWithLabels)
 }
 
+// writeGoroutineLeak first invokes a GC cycle that performs goroutine leak detection.
+// It then writes the goroutine profile, filtering for leaked goroutines.
+func writeGoroutineLeak(w io.Writer, debug int) error {
+	// Run the GC with leak detection first so that leaked goroutines
+	// may transition to the leaked state.
+	runtime_goroutineLeakGC()
+
+	// If the debug flag is set sufficiently high, just defer to writing goroutine stacks
+	// like in a regular goroutine profile. Include non-leaked goroutines, too.
+	if debug >= 2 {
+		return writeGoroutineStacks(w)
+	}
+
+	// Otherwise, write the goroutine leak profile.
+	return writeRuntimeProfile(w, debug, "goroutineleak", pprof_goroutineLeakProfileWithLabels)
+}
+
 func writeGoroutineStacks(w io.Writer) error {
 	// We don't know how big the buffer needs to be to collect
 	// all the goroutines. Start with 1 MB and try a few times, doubling each time.
@@ -969,6 +1000,9 @@ func writeProfileInternal(w io.Writer, debug int, name string, runtimeProfile fu
 //go:linkname pprof_goroutineProfileWithLabels runtime.pprof_goroutineProfileWithLabels
 func pprof_goroutineProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool)
 
+//go:linkname pprof_goroutineLeakProfileWithLabels runtime.pprof_goroutineLeakProfileWithLabels
+func pprof_goroutineLeakProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool)
+
 //go:linkname pprof_cyclesPerSecond runtime/pprof.runtime_cyclesPerSecond
 func pprof_cyclesPerSecond() int64
 

src/runtime/pprof/runtime.go

@@ -29,6 +29,12 @@ func runtime_setProfLabel(labels unsafe.Pointer)
 // runtime_getProfLabel is defined in runtime/proflabel.go.
 func runtime_getProfLabel() unsafe.Pointer
 
+// runtime_gleakcount is defined in runtime/proc.go.
+func runtime_gleakcount() int32
+
+// runtime_goroutineLeakGC is defined in runtime/mgc.go.
+func runtime_goroutineLeakGC()
+
 // SetGoroutineLabels sets the current goroutine's labels to match ctx.
 // A new goroutine inherits the labels of the goroutine that created it.
 // This is a lower-level API than [Do], which should be used instead when possible.

src/runtime/proc.go

@@ -5553,6 +5553,25 @@ func gcount() int32 {
 	return n
 }
 
+//go:linkname runtime_gleakcount runtime/pprof.runtime_gleakcount
+func runtime_gleakcount() int32 {
+	return gleakcount()
+}
+
+// gleakcount returns the number of leaked goroutines currently reported by
+// the runtime. Protected by allglock.
+func gleakcount() int32 {
+	n := int32(0)
+	lock(&allglock)
+	for _, g := range allgs {
+		if readgstatus(g) == _Gleaked {
+			n++
+		}
+	}
+	unlock(&allglock)
+	return n
+}
+
 func mcount() int32 {
 	return int32(sched.mnext - sched.nmfreed)
 }

src/runtime/runtime1.go

@@ -316,7 +316,6 @@ var debug struct {
 	dontfreezetheworld       int32
 	efence                   int32
 	gccheckmark              int32
-	gcgoroutineleaks         int32
 	gcpacertrace             int32
 	gcshrinkstackoff         int32
 	gcstoptheworld           int32
@@ -382,7 +381,6 @@ var dbgvars = []*dbgVar{
 	{name: "efence", value: &debug.efence},
 	{name: "gccheckmark", value: &debug.gccheckmark},
 	{name: "gcpacertrace", value: &debug.gcpacertrace},
-	{name: "gcgoroutineleaks", value: &debug.gcgoroutineleaks},
 	{name: "gcshrinkstackoff", value: &debug.gcshrinkstackoff},
 	{name: "gcstoptheworld", value: &debug.gcstoptheworld},
 	{name: "gctrace", value: &debug.gctrace},