Source file src/runtime/mprof.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  // Malloc profiling.
     6  // Patterned after tcmalloc's algorithms; shorter code.
     7  
     8  package runtime
     9  
    10  import (
    11  	"internal/abi"
    12  	"internal/goarch"
    13  	"internal/profilerecord"
    14  	"internal/runtime/atomic"
    15  	"internal/runtime/sys"
    16  	"unsafe"
    17  )
    18  
    19  // NOTE(rsc): Everything here could use cas if contention became an issue.
    20  var (
    21  	// profInsertLock protects changes to the start of all *bucket linked lists
    22  	profInsertLock mutex
    23  	// profBlockLock protects the contents of every blockRecord struct
    24  	profBlockLock mutex
    25  	// profMemActiveLock protects the active field of every memRecord struct
    26  	profMemActiveLock mutex
    27  	// profMemFutureLock is a set of locks that protect the respective elements
    28  	// of the future array of every memRecord struct
    29  	profMemFutureLock [len(memRecord{}.future)]mutex
    30  )
    31  
    32  // All memory allocations are local and do not escape outside of the profiler.
    33  // The profiler is forbidden from referring to garbage-collected memory.
    34  
    35  const (
    36  	// profile types
    37  	memProfile bucketType = 1 + iota
    38  	blockProfile
    39  	mutexProfile
    40  
    41  	// size of bucket hash table
    42  	buckHashSize = 179999
    43  
    44  	// maxSkip is to account for deferred inline expansion
    45  	// when using frame pointer unwinding. We record the stack
    46  	// with "physical" frame pointers but handle skipping "logical"
    47  	// frames at some point after collecting the stack. So
    48  	// we need extra space in order to avoid getting fewer than the
    49  	// desired maximum number of frames after expansion.
    50  	// This should be at least as large as the largest skip value
    51  	// used for profiling; otherwise stacks may be truncated inconsistently
    52  	maxSkip = 6
    53  
    54  	// maxProfStackDepth is the highest valid value for debug.profstackdepth.
    55  	// It's used for the bucket.stk func.
    56  	// TODO(fg): can we get rid of this?
    57  	maxProfStackDepth = 1024
    58  )
    59  
    60  type bucketType int
    61  
    62  // A bucket holds per-call-stack profiling information.
    63  // The representation is a bit sleazy, inherited from C.
    64  // This struct defines the bucket header. It is followed in
    65  // memory by the stack words and then the actual record
    66  // data, either a memRecord or a blockRecord.
    67  //
    68  // Per-call-stack profiling information.
    69  // Lookup by hashing call stack into a linked-list hash table.
    70  //
    71  // None of the fields in this bucket header are modified after
    72  // creation, including its next and allnext links.
    73  //
    74  // No heap pointers.
    75  type bucket struct {
    76  	_       sys.NotInHeap
    77  	next    *bucket
    78  	allnext *bucket
    79  	typ     bucketType // memBucket or blockBucket (includes mutexProfile)
    80  	hash    uintptr
    81  	size    uintptr
    82  	nstk    uintptr
    83  }
    84  
    85  // A memRecord is the bucket data for a bucket of type memProfile,
    86  // part of the memory profile.
    87  type memRecord struct {
    88  	// The following complex 3-stage scheme of stats accumulation
    89  	// is required to obtain a consistent picture of mallocs and frees
    90  	// for some point in time.
    91  	// The problem is that mallocs come in real time, while frees
    92  	// come only after a GC during concurrent sweeping. So if we would
    93  	// naively count them, we would get a skew toward mallocs.
    94  	//
    95  	// Hence, we delay information to get consistent snapshots as
    96  	// of mark termination. Allocations count toward the next mark
    97  	// termination's snapshot, while sweep frees count toward the
    98  	// previous mark termination's snapshot:
    99  	//
   100  	//              MT          MT          MT          MT
   101  	//             .·|         .·|         .·|         .·|
   102  	//          .·˙  |      .·˙  |      .·˙  |      .·˙  |
   103  	//       .·˙     |   .·˙     |   .·˙     |   .·˙     |
   104  	//    .·˙        |.·˙        |.·˙        |.·˙        |
   105  	//
   106  	//       alloc → ▲ ← free
   107  	//               ┠┅┅┅┅┅┅┅┅┅┅┅P
   108  	//       C+2     →    C+1    →  C
   109  	//
   110  	//                   alloc → ▲ ← free
   111  	//                           ┠┅┅┅┅┅┅┅┅┅┅┅P
   112  	//                   C+2     →    C+1    →  C
   113  	//
   114  	// Since we can't publish a consistent snapshot until all of
   115  	// the sweep frees are accounted for, we wait until the next
   116  	// mark termination ("MT" above) to publish the previous mark
   117  	// termination's snapshot ("P" above). To do this, allocation
   118  	// and free events are accounted to *future* heap profile
   119  	// cycles ("C+n" above) and we only publish a cycle once all
   120  	// of the events from that cycle must be done. Specifically:
   121  	//
   122  	// Mallocs are accounted to cycle C+2.
   123  	// Explicit frees are accounted to cycle C+2.
   124  	// GC frees (done during sweeping) are accounted to cycle C+1.
   125  	//
   126  	// After mark termination, we increment the global heap
   127  	// profile cycle counter and accumulate the stats from cycle C
   128  	// into the active profile.
   129  
   130  	// active is the currently published profile. A profiling
   131  	// cycle can be accumulated into active once its complete.
   132  	active memRecordCycle
   133  
   134  	// future records the profile events we're counting for cycles
   135  	// that have not yet been published. This is ring buffer
   136  	// indexed by the global heap profile cycle C and stores
   137  	// cycles C, C+1, and C+2. Unlike active, these counts are
   138  	// only for a single cycle; they are not cumulative across
   139  	// cycles.
   140  	//
   141  	// We store cycle C here because there's a window between when
   142  	// C becomes the active cycle and when we've flushed it to
   143  	// active.
   144  	future [3]memRecordCycle
   145  }
   146  
   147  // memRecordCycle
   148  type memRecordCycle struct {
   149  	allocs, frees           uintptr
   150  	alloc_bytes, free_bytes uintptr
   151  }
   152  
   153  // add accumulates b into a. It does not zero b.
   154  func (a *memRecordCycle) add(b *memRecordCycle) {
   155  	a.allocs += b.allocs
   156  	a.frees += b.frees
   157  	a.alloc_bytes += b.alloc_bytes
   158  	a.free_bytes += b.free_bytes
   159  }
   160  
   161  // A blockRecord is the bucket data for a bucket of type blockProfile,
   162  // which is used in blocking and mutex profiles.
   163  type blockRecord struct {
   164  	count  float64
   165  	cycles int64
   166  }
   167  
   168  var (
   169  	mbuckets atomic.UnsafePointer // *bucket, memory profile buckets
   170  	bbuckets atomic.UnsafePointer // *bucket, blocking profile buckets
   171  	xbuckets atomic.UnsafePointer // *bucket, mutex profile buckets
   172  	buckhash atomic.UnsafePointer // *buckhashArray
   173  
   174  	mProfCycle mProfCycleHolder
   175  )
   176  
   177  type buckhashArray [buckHashSize]atomic.UnsafePointer // *bucket
   178  
   179  const mProfCycleWrap = uint32(len(memRecord{}.future)) * (2 << 24)
   180  
   181  // mProfCycleHolder holds the global heap profile cycle number (wrapped at
   182  // mProfCycleWrap, stored starting at bit 1), and a flag (stored at bit 0) to
   183  // indicate whether future[cycle] in all buckets has been queued to flush into
   184  // the active profile.
   185  type mProfCycleHolder struct {
   186  	value atomic.Uint32
   187  }
   188  
   189  // read returns the current cycle count.
   190  func (c *mProfCycleHolder) read() (cycle uint32) {
   191  	v := c.value.Load()
   192  	cycle = v >> 1
   193  	return cycle
   194  }
   195  
   196  // setFlushed sets the flushed flag. It returns the current cycle count and the
   197  // previous value of the flushed flag.
   198  func (c *mProfCycleHolder) setFlushed() (cycle uint32, alreadyFlushed bool) {
   199  	for {
   200  		prev := c.value.Load()
   201  		cycle = prev >> 1
   202  		alreadyFlushed = (prev & 0x1) != 0
   203  		next := prev | 0x1
   204  		if c.value.CompareAndSwap(prev, next) {
   205  			return cycle, alreadyFlushed
   206  		}
   207  	}
   208  }
   209  
   210  // increment increases the cycle count by one, wrapping the value at
   211  // mProfCycleWrap. It clears the flushed flag.
   212  func (c *mProfCycleHolder) increment() {
   213  	// We explicitly wrap mProfCycle rather than depending on
   214  	// uint wraparound because the memRecord.future ring does not
   215  	// itself wrap at a power of two.
   216  	for {
   217  		prev := c.value.Load()
   218  		cycle := prev >> 1
   219  		cycle = (cycle + 1) % mProfCycleWrap
   220  		next := cycle << 1
   221  		if c.value.CompareAndSwap(prev, next) {
   222  			break
   223  		}
   224  	}
   225  }
   226  
   227  // newBucket allocates a bucket with the given type and number of stack entries.
   228  func newBucket(typ bucketType, nstk int) *bucket {
   229  	size := unsafe.Sizeof(bucket{}) + uintptr(nstk)*unsafe.Sizeof(uintptr(0))
   230  	switch typ {
   231  	default:
   232  		throw("invalid profile bucket type")
   233  	case memProfile:
   234  		size += unsafe.Sizeof(memRecord{})
   235  	case blockProfile, mutexProfile:
   236  		size += unsafe.Sizeof(blockRecord{})
   237  	}
   238  
   239  	b := (*bucket)(persistentalloc(size, 0, &memstats.buckhash_sys))
   240  	b.typ = typ
   241  	b.nstk = uintptr(nstk)
   242  	return b
   243  }
   244  
   245  // stk returns the slice in b holding the stack. The caller can assume that the
   246  // backing array is immutable.
   247  func (b *bucket) stk() []uintptr {
   248  	stk := (*[maxProfStackDepth]uintptr)(add(unsafe.Pointer(b), unsafe.Sizeof(*b)))
   249  	if b.nstk > maxProfStackDepth {
   250  		// prove that slicing works; otherwise a failure requires a P
   251  		throw("bad profile stack count")
   252  	}
   253  	return stk[:b.nstk:b.nstk]
   254  }
   255  
   256  // mp returns the memRecord associated with the memProfile bucket b.
   257  func (b *bucket) mp() *memRecord {
   258  	if b.typ != memProfile {
   259  		throw("bad use of bucket.mp")
   260  	}
   261  	data := add(unsafe.Pointer(b), unsafe.Sizeof(*b)+b.nstk*unsafe.Sizeof(uintptr(0)))
   262  	return (*memRecord)(data)
   263  }
   264  
   265  // bp returns the blockRecord associated with the blockProfile bucket b.
   266  func (b *bucket) bp() *blockRecord {
   267  	if b.typ != blockProfile && b.typ != mutexProfile {
   268  		throw("bad use of bucket.bp")
   269  	}
   270  	data := add(unsafe.Pointer(b), unsafe.Sizeof(*b)+b.nstk*unsafe.Sizeof(uintptr(0)))
   271  	return (*blockRecord)(data)
   272  }
   273  
   274  // Return the bucket for stk[0:nstk], allocating new bucket if needed.
   275  func stkbucket(typ bucketType, size uintptr, stk []uintptr, alloc bool) *bucket {
   276  	bh := (*buckhashArray)(buckhash.Load())
   277  	if bh == nil {
   278  		lock(&profInsertLock)
   279  		// check again under the lock
   280  		bh = (*buckhashArray)(buckhash.Load())
   281  		if bh == nil {
   282  			bh = (*buckhashArray)(sysAlloc(unsafe.Sizeof(buckhashArray{}), &memstats.buckhash_sys, "profiler hash buckets"))
   283  			if bh == nil {
   284  				throw("runtime: cannot allocate memory")
   285  			}
   286  			buckhash.StoreNoWB(unsafe.Pointer(bh))
   287  		}
   288  		unlock(&profInsertLock)
   289  	}
   290  
   291  	// Hash stack.
   292  	var h uintptr
   293  	for _, pc := range stk {
   294  		h += pc
   295  		h += h << 10
   296  		h ^= h >> 6
   297  	}
   298  	// hash in size
   299  	h += size
   300  	h += h << 10
   301  	h ^= h >> 6
   302  	// finalize
   303  	h += h << 3
   304  	h ^= h >> 11
   305  
   306  	i := int(h % buckHashSize)
   307  	// first check optimistically, without the lock
   308  	for b := (*bucket)(bh[i].Load()); b != nil; b = b.next {
   309  		if b.typ == typ && b.hash == h && b.size == size && eqslice(b.stk(), stk) {
   310  			return b
   311  		}
   312  	}
   313  
   314  	if !alloc {
   315  		return nil
   316  	}
   317  
   318  	lock(&profInsertLock)
   319  	// check again under the insertion lock
   320  	for b := (*bucket)(bh[i].Load()); b != nil; b = b.next {
   321  		if b.typ == typ && b.hash == h && b.size == size && eqslice(b.stk(), stk) {
   322  			unlock(&profInsertLock)
   323  			return b
   324  		}
   325  	}
   326  
   327  	// Create new bucket.
   328  	b := newBucket(typ, len(stk))
   329  	copy(b.stk(), stk)
   330  	b.hash = h
   331  	b.size = size
   332  
   333  	var allnext *atomic.UnsafePointer
   334  	if typ == memProfile {
   335  		allnext = &mbuckets
   336  	} else if typ == mutexProfile {
   337  		allnext = &xbuckets
   338  	} else {
   339  		allnext = &bbuckets
   340  	}
   341  
   342  	b.next = (*bucket)(bh[i].Load())
   343  	b.allnext = (*bucket)(allnext.Load())
   344  
   345  	bh[i].StoreNoWB(unsafe.Pointer(b))
   346  	allnext.StoreNoWB(unsafe.Pointer(b))
   347  
   348  	unlock(&profInsertLock)
   349  	return b
   350  }
   351  
   352  func eqslice(x, y []uintptr) bool {
   353  	if len(x) != len(y) {
   354  		return false
   355  	}
   356  	for i, xi := range x {
   357  		if xi != y[i] {
   358  			return false
   359  		}
   360  	}
   361  	return true
   362  }
   363  
   364  // mProf_NextCycle publishes the next heap profile cycle and creates a
   365  // fresh heap profile cycle. This operation is fast and can be done
   366  // during STW. The caller must call mProf_Flush before calling
   367  // mProf_NextCycle again.
   368  //
   369  // This is called by mark termination during STW so allocations and
   370  // frees after the world is started again count towards a new heap
   371  // profiling cycle.
   372  func mProf_NextCycle() {
   373  	mProfCycle.increment()
   374  }
   375  
   376  // mProf_Flush flushes the events from the current heap profiling
   377  // cycle into the active profile. After this it is safe to start a new
   378  // heap profiling cycle with mProf_NextCycle.
   379  //
   380  // This is called by GC after mark termination starts the world. In
   381  // contrast with mProf_NextCycle, this is somewhat expensive, but safe
   382  // to do concurrently.
   383  func mProf_Flush() {
   384  	cycle, alreadyFlushed := mProfCycle.setFlushed()
   385  	if alreadyFlushed {
   386  		return
   387  	}
   388  
   389  	index := cycle % uint32(len(memRecord{}.future))
   390  	lock(&profMemActiveLock)
   391  	lock(&profMemFutureLock[index])
   392  	mProf_FlushLocked(index)
   393  	unlock(&profMemFutureLock[index])
   394  	unlock(&profMemActiveLock)
   395  }
   396  
   397  // mProf_FlushLocked flushes the events from the heap profiling cycle at index
   398  // into the active profile. The caller must hold the lock for the active profile
   399  // (profMemActiveLock) and for the profiling cycle at index
   400  // (profMemFutureLock[index]).
   401  func mProf_FlushLocked(index uint32) {
   402  	assertLockHeld(&profMemActiveLock)
   403  	assertLockHeld(&profMemFutureLock[index])
   404  	head := (*bucket)(mbuckets.Load())
   405  	for b := head; b != nil; b = b.allnext {
   406  		mp := b.mp()
   407  
   408  		// Flush cycle C into the published profile and clear
   409  		// it for reuse.
   410  		mpc := &mp.future[index]
   411  		mp.active.add(mpc)
   412  		*mpc = memRecordCycle{}
   413  	}
   414  }
   415  
   416  // mProf_PostSweep records that all sweep frees for this GC cycle have
   417  // completed. This has the effect of publishing the heap profile
   418  // snapshot as of the last mark termination without advancing the heap
   419  // profile cycle.
   420  func mProf_PostSweep() {
   421  	// Flush cycle C+1 to the active profile so everything as of
   422  	// the last mark termination becomes visible. *Don't* advance
   423  	// the cycle, since we're still accumulating allocs in cycle
   424  	// C+2, which have to become C+1 in the next mark termination
   425  	// and so on.
   426  	cycle := mProfCycle.read() + 1
   427  
   428  	index := cycle % uint32(len(memRecord{}.future))
   429  	lock(&profMemActiveLock)
   430  	lock(&profMemFutureLock[index])
   431  	mProf_FlushLocked(index)
   432  	unlock(&profMemFutureLock[index])
   433  	unlock(&profMemActiveLock)
   434  }
   435  
   436  // Called by malloc to record a profiled block.
   437  func mProf_Malloc(mp *m, p unsafe.Pointer, size uintptr) {
   438  	if mp.profStack == nil {
   439  		// mp.profStack is nil if we happen to sample an allocation during the
   440  		// initialization of mp. This case is rare, so we just ignore such
   441  		// allocations. Change MemProfileRate to 1 if you need to reproduce such
   442  		// cases for testing purposes.
   443  		return
   444  	}
   445  	// Only use the part of mp.profStack we need and ignore the extra space
   446  	// reserved for delayed inline expansion with frame pointer unwinding.
   447  	nstk := callers(3, mp.profStack[:debug.profstackdepth+2])
   448  	index := (mProfCycle.read() + 2) % uint32(len(memRecord{}.future))
   449  
   450  	b := stkbucket(memProfile, size, mp.profStack[:nstk], true)
   451  	mr := b.mp()
   452  	mpc := &mr.future[index]
   453  
   454  	lock(&profMemFutureLock[index])
   455  	mpc.allocs++
   456  	mpc.alloc_bytes += size
   457  	unlock(&profMemFutureLock[index])
   458  
   459  	// Setprofilebucket locks a bunch of other mutexes, so we call it outside of
   460  	// the profiler locks. This reduces potential contention and chances of
   461  	// deadlocks. Since the object must be alive during the call to
   462  	// mProf_Malloc, it's fine to do this non-atomically.
   463  	systemstack(func() {
   464  		setprofilebucket(p, b)
   465  	})
   466  }
   467  
   468  // Called when freeing a profiled block.
   469  func mProf_Free(b *bucket, size uintptr) {
   470  	index := (mProfCycle.read() + 1) % uint32(len(memRecord{}.future))
   471  
   472  	mp := b.mp()
   473  	mpc := &mp.future[index]
   474  
   475  	lock(&profMemFutureLock[index])
   476  	mpc.frees++
   477  	mpc.free_bytes += size
   478  	unlock(&profMemFutureLock[index])
   479  }
   480  
   481  var blockprofilerate uint64 // in CPU ticks
   482  
   483  // SetBlockProfileRate controls the fraction of goroutine blocking events
   484  // that are reported in the blocking profile. The profiler aims to sample
   485  // an average of one blocking event per rate nanoseconds spent blocked.
   486  //
   487  // To include every blocking event in the profile, pass rate = 1.
   488  // To turn off profiling entirely, pass rate <= 0.
   489  func SetBlockProfileRate(rate int) {
   490  	var r int64
   491  	if rate <= 0 {
   492  		r = 0 // disable profiling
   493  	} else if rate == 1 {
   494  		r = 1 // profile everything
   495  	} else {
   496  		// convert ns to cycles, use float64 to prevent overflow during multiplication
   497  		r = int64(float64(rate) * float64(ticksPerSecond()) / (1000 * 1000 * 1000))
   498  		if r == 0 {
   499  			r = 1
   500  		}
   501  	}
   502  
   503  	atomic.Store64(&blockprofilerate, uint64(r))
   504  }
   505  
   506  func blockevent(cycles int64, skip int) {
   507  	if cycles <= 0 {
   508  		cycles = 1
   509  	}
   510  
   511  	rate := int64(atomic.Load64(&blockprofilerate))
   512  	if blocksampled(cycles, rate) {
   513  		saveblockevent(cycles, rate, skip+1, blockProfile)
   514  	}
   515  }
   516  
   517  // blocksampled returns true for all events where cycles >= rate. Shorter
   518  // events have a cycles/rate random chance of returning true.
   519  func blocksampled(cycles, rate int64) bool {
   520  	if rate <= 0 || (rate > cycles && cheaprand64()%rate > cycles) {
   521  		return false
   522  	}
   523  	return true
   524  }
   525  
   526  // saveblockevent records a profile event of the type specified by which.
   527  // cycles is the quantity associated with this event and rate is the sampling rate,
   528  // used to adjust the cycles value in the manner determined by the profile type.
   529  // skip is the number of frames to omit from the traceback associated with the event.
   530  // The traceback will be recorded from the stack of the goroutine associated with the current m.
   531  // skip should be positive if this event is recorded from the current stack
   532  // (e.g. when this is not called from a system stack)
   533  func saveblockevent(cycles, rate int64, skip int, which bucketType) {
   534  	if debug.profstackdepth == 0 {
   535  		// profstackdepth is set to 0 by the user, so mp.profStack is nil and we
   536  		// can't record a stack trace.
   537  		return
   538  	}
   539  	if skip > maxSkip {
   540  		print("requested skip=", skip)
   541  		throw("invalid skip value")
   542  	}
   543  	gp := getg()
   544  	mp := acquirem() // we must not be preempted while accessing profstack
   545  
   546  	var nstk int
   547  	if tracefpunwindoff() || gp.m.hasCgoOnStack() {
   548  		if gp.m.curg == nil || gp.m.curg == gp {
   549  			nstk = callers(skip, mp.profStack)
   550  		} else {
   551  			nstk = gcallers(gp.m.curg, skip, mp.profStack)
   552  		}
   553  	} else {
   554  		if gp.m.curg == nil || gp.m.curg == gp {
   555  			if skip > 0 {
   556  				// We skip one fewer frame than the provided value for frame
   557  				// pointer unwinding because the skip value includes the current
   558  				// frame, whereas the saved frame pointer will give us the
   559  				// caller's return address first (so, not including
   560  				// saveblockevent)
   561  				skip -= 1
   562  			}
   563  			nstk = fpTracebackPartialExpand(skip, unsafe.Pointer(getfp()), mp.profStack)
   564  		} else {
   565  			mp.profStack[0] = gp.m.curg.sched.pc
   566  			nstk = 1 + fpTracebackPartialExpand(skip, unsafe.Pointer(gp.m.curg.sched.bp), mp.profStack[1:])
   567  		}
   568  	}
   569  
   570  	saveBlockEventStack(cycles, rate, mp.profStack[:nstk], which)
   571  	releasem(mp)
   572  }
   573  
   574  // fpTracebackPartialExpand records a call stack obtained starting from fp.
   575  // This function will skip the given number of frames, properly accounting for
   576  // inlining, and save remaining frames as "physical" return addresses. The
   577  // consumer should later use CallersFrames or similar to expand inline frames.
   578  func fpTracebackPartialExpand(skip int, fp unsafe.Pointer, pcBuf []uintptr) int {
   579  	var n int
   580  	lastFuncID := abi.FuncIDNormal
   581  	skipOrAdd := func(retPC uintptr) bool {
   582  		if skip > 0 {
   583  			skip--
   584  		} else if n < len(pcBuf) {
   585  			pcBuf[n] = retPC
   586  			n++
   587  		}
   588  		return n < len(pcBuf)
   589  	}
   590  	for n < len(pcBuf) && fp != nil {
   591  		// return addr sits one word above the frame pointer
   592  		pc := *(*uintptr)(unsafe.Pointer(uintptr(fp) + goarch.PtrSize))
   593  
   594  		if skip > 0 {
   595  			callPC := pc - 1
   596  			fi := findfunc(callPC)
   597  			u, uf := newInlineUnwinder(fi, callPC)
   598  			for ; uf.valid(); uf = u.next(uf) {
   599  				sf := u.srcFunc(uf)
   600  				if sf.funcID == abi.FuncIDWrapper && elideWrapperCalling(lastFuncID) {
   601  					// ignore wrappers
   602  				} else if more := skipOrAdd(uf.pc + 1); !more {
   603  					return n
   604  				}
   605  				lastFuncID = sf.funcID
   606  			}
   607  		} else {
   608  			// We've skipped the desired number of frames, so no need
   609  			// to perform further inline expansion now.
   610  			pcBuf[n] = pc
   611  			n++
   612  		}
   613  
   614  		// follow the frame pointer to the next one
   615  		fp = unsafe.Pointer(*(*uintptr)(fp))
   616  	}
   617  	return n
   618  }
   619  
   620  // mLockProfile holds information about the runtime-internal lock contention
   621  // experienced and caused by this M, to report in metrics and profiles.
   622  //
   623  // These measurements are subject to some notable constraints: First, the fast
   624  // path for lock and unlock must remain very fast, with a minimal critical
   625  // section. Second, the critical section during contention has to remain small
   626  // too, so low levels of contention are less likely to snowball into large ones.
   627  // The reporting code cannot acquire new locks until the M has released all
   628  // other locks, which means no memory allocations and encourages use of
   629  // (temporary) M-local storage.
   630  //
   631  // The M has space for storing one call stack that caused contention, and the
   632  // magnitude of that contention. It also has space to store the magnitude of
   633  // additional contention the M caused, since it might encounter several
   634  // contention events before it releases all of its locks and is thus able to
   635  // transfer the locally buffered call stack and magnitude into the profile.
   636  //
   637  // The M collects the call stack when it unlocks the contended lock. The
   638  // traceback takes place outside of the lock's critical section.
   639  //
   640  // The profile for contention on sync.Mutex blames the caller of Unlock for the
   641  // amount of contention experienced by the callers of Lock which had to wait.
   642  // When there are several critical sections, this allows identifying which of
   643  // them is responsible. We must match that reporting behavior for contention on
   644  // runtime-internal locks.
   645  //
   646  // When the M unlocks its last mutex, it transfers the locally buffered call
   647  // stack and magnitude into the profile. As part of that step, it also transfers
   648  // any "additional contention" time to the profile. Any lock contention that it
   649  // experiences while adding samples to the profile will be recorded later as
   650  // "additional contention" and not include a call stack, to avoid an echo.
   651  type mLockProfile struct {
   652  	waitTime   atomic.Int64 // (nanotime) total time this M has spent waiting in runtime.lockWithRank. Read by runtime/metrics.
   653  	stack      []uintptr    // call stack at the point of this M's unlock call, when other Ms had to wait
   654  	cycles     int64        // (cputicks) cycles attributable to "stack"
   655  	cyclesLost int64        // (cputicks) contention for which we weren't able to record a call stack
   656  	haveStack  bool         // stack and cycles are to be added to the mutex profile (even if cycles is 0)
   657  	disabled   bool         // attribute all time to "lost"
   658  }
   659  
   660  func (prof *mLockProfile) start() int64 {
   661  	if cheaprandn(gTrackingPeriod) == 0 {
   662  		return nanotime()
   663  	}
   664  	return 0
   665  }
   666  
   667  func (prof *mLockProfile) end(start int64) {
   668  	if start != 0 {
   669  		prof.waitTime.Add((nanotime() - start) * gTrackingPeriod)
   670  	}
   671  }
   672  
   673  // recordUnlock prepares data for later addition to the mutex contention
   674  // profile. The M may hold arbitrary locks during this call.
   675  //
   676  // From unlock2, we might not be holding a p in this code.
   677  //
   678  //go:nowritebarrierrec
   679  func (prof *mLockProfile) recordUnlock(cycles int64) {
   680  	if cycles < 0 {
   681  		cycles = 0
   682  	}
   683  
   684  	if prof.disabled {
   685  		// We're experiencing contention while attempting to report contention.
   686  		// Make a note of its magnitude, but don't allow it to be the sole cause
   687  		// of another contention report.
   688  		prof.cyclesLost += cycles
   689  		return
   690  	}
   691  
   692  	if prev := prof.cycles; prev > 0 {
   693  		// We can only store one call stack for runtime-internal lock contention
   694  		// on this M, and we've already got one. Decide which should stay, and
   695  		// add the other to the report for runtime._LostContendedRuntimeLock.
   696  		if cycles == 0 {
   697  			return
   698  		}
   699  		prevScore := cheaprandu64() % uint64(prev)
   700  		thisScore := cheaprandu64() % uint64(cycles)
   701  		if prevScore > thisScore {
   702  			prof.cyclesLost += cycles
   703  			return
   704  		} else {
   705  			prof.cyclesLost += prev
   706  		}
   707  	}
   708  	prof.captureStack()
   709  	prof.cycles = cycles
   710  }
   711  
   712  func (prof *mLockProfile) captureStack() {
   713  	if debug.profstackdepth == 0 {
   714  		// profstackdepth is set to 0 by the user, so mp.profStack is nil and we
   715  		// can't record a stack trace.
   716  		return
   717  	}
   718  
   719  	skip := 4 // runtime.(*mLockProfile).recordUnlock runtime.unlock2Wake runtime.unlock2 runtime.unlockWithRank
   720  	if staticLockRanking {
   721  		// When static lock ranking is enabled, we'll always be on the system
   722  		// stack at this point. There will be a runtime.unlockWithRank.func1
   723  		// frame, and if the call to runtime.unlock took place on a user stack
   724  		// then there'll also be a runtime.systemstack frame. To keep stack
   725  		// traces somewhat consistent whether or not static lock ranking is
   726  		// enabled, we'd like to skip those. But it's hard to tell how long
   727  		// we've been on the system stack so accept an extra frame in that case,
   728  		// with a leaf of "runtime.unlockWithRank runtime.unlock" instead of
   729  		// "runtime.unlock".
   730  		skip += 1 // runtime.unlockWithRank.func1
   731  	}
   732  	prof.haveStack = true
   733  
   734  	var nstk int
   735  	gp := getg()
   736  	sp := sys.GetCallerSP()
   737  	pc := sys.GetCallerPC()
   738  	systemstack(func() {
   739  		var u unwinder
   740  		u.initAt(pc, sp, 0, gp, unwindSilentErrors|unwindJumpStack)
   741  		nstk = tracebackPCs(&u, skip, prof.stack)
   742  	})
   743  	if nstk < len(prof.stack) {
   744  		prof.stack[nstk] = 0
   745  	}
   746  }
   747  
   748  // store adds the M's local record to the mutex contention profile.
   749  //
   750  // From unlock2, we might not be holding a p in this code.
   751  //
   752  //go:nowritebarrierrec
   753  func (prof *mLockProfile) store() {
   754  	if gp := getg(); gp.m.locks == 1 && gp.m.mLockProfile.haveStack {
   755  		prof.storeSlow()
   756  	}
   757  }
   758  
   759  func (prof *mLockProfile) storeSlow() {
   760  	// Report any contention we experience within this function as "lost"; it's
   761  	// important that the act of reporting a contention event not lead to a
   762  	// reportable contention event. This also means we can use prof.stack
   763  	// without copying, since it won't change during this function.
   764  	mp := acquirem()
   765  	prof.disabled = true
   766  
   767  	nstk := int(debug.profstackdepth)
   768  	for i := 0; i < nstk; i++ {
   769  		if pc := prof.stack[i]; pc == 0 {
   770  			nstk = i
   771  			break
   772  		}
   773  	}
   774  
   775  	cycles, lost := prof.cycles, prof.cyclesLost
   776  	prof.cycles, prof.cyclesLost = 0, 0
   777  	prof.haveStack = false
   778  
   779  	rate := int64(atomic.Load64(&mutexprofilerate))
   780  	saveBlockEventStack(cycles, rate, prof.stack[:nstk], mutexProfile)
   781  	if lost > 0 {
   782  		lostStk := [...]uintptr{
   783  			abi.FuncPCABIInternal(_LostContendedRuntimeLock) + sys.PCQuantum,
   784  		}
   785  		saveBlockEventStack(lost, rate, lostStk[:], mutexProfile)
   786  	}
   787  
   788  	prof.disabled = false
   789  	releasem(mp)
   790  }
   791  
   792  func saveBlockEventStack(cycles, rate int64, stk []uintptr, which bucketType) {
   793  	b := stkbucket(which, 0, stk, true)
   794  	bp := b.bp()
   795  
   796  	lock(&profBlockLock)
   797  	// We want to up-scale the count and cycles according to the
   798  	// probability that the event was sampled. For block profile events,
   799  	// the sample probability is 1 if cycles >= rate, and cycles / rate
   800  	// otherwise. For mutex profile events, the sample probability is 1 / rate.
   801  	// We scale the events by 1 / (probability the event was sampled).
   802  	if which == blockProfile && cycles < rate {
   803  		// Remove sampling bias, see discussion on http://golang.org/cl/299991.
   804  		bp.count += float64(rate) / float64(cycles)
   805  		bp.cycles += rate
   806  	} else if which == mutexProfile {
   807  		bp.count += float64(rate)
   808  		bp.cycles += rate * cycles
   809  	} else {
   810  		bp.count++
   811  		bp.cycles += cycles
   812  	}
   813  	unlock(&profBlockLock)
   814  }
   815  
   816  var mutexprofilerate uint64 // fraction sampled
   817  
   818  // SetMutexProfileFraction controls the fraction of mutex contention events
   819  // that are reported in the mutex profile. On average 1/rate events are
   820  // reported. The previous rate is returned.
   821  //
   822  // To turn off profiling entirely, pass rate 0.
   823  // To just read the current rate, pass rate < 0.
   824  // (For n>1 the details of sampling may change.)
   825  func SetMutexProfileFraction(rate int) int {
   826  	if rate < 0 {
   827  		return int(mutexprofilerate)
   828  	}
   829  	old := mutexprofilerate
   830  	atomic.Store64(&mutexprofilerate, uint64(rate))
   831  	return int(old)
   832  }
   833  
   834  func mutexevent(cycles int64, skip int) {
   835  	if cycles < 0 {
   836  		cycles = 0
   837  	}
   838  	rate := int64(atomic.Load64(&mutexprofilerate))
   839  	if rate > 0 && cheaprand64()%rate == 0 {
   840  		saveblockevent(cycles, rate, skip+1, mutexProfile)
   841  	}
   842  }
   843  
   844  // Go interface to profile data.
   845  
   846  // A StackRecord describes a single execution stack.
   847  type StackRecord struct {
   848  	Stack0 [32]uintptr // stack trace for this record; ends at first 0 entry
   849  }
   850  
   851  // Stack returns the stack trace associated with the record,
   852  // a prefix of r.Stack0.
   853  func (r *StackRecord) Stack() []uintptr {
   854  	for i, v := range r.Stack0 {
   855  		if v == 0 {
   856  			return r.Stack0[0:i]
   857  		}
   858  	}
   859  	return r.Stack0[0:]
   860  }
   861  
   862  // MemProfileRate controls the fraction of memory allocations
   863  // that are recorded and reported in the memory profile.
   864  // The profiler aims to sample an average of
   865  // one allocation per MemProfileRate bytes allocated.
   866  //
   867  // To include every allocated block in the profile, set MemProfileRate to 1.
   868  // To turn off profiling entirely, set MemProfileRate to 0.
   869  //
   870  // The tools that process the memory profiles assume that the
   871  // profile rate is constant across the lifetime of the program
   872  // and equal to the current value. Programs that change the
   873  // memory profiling rate should do so just once, as early as
   874  // possible in the execution of the program (for example,
   875  // at the beginning of main).
   876  var MemProfileRate int = 512 * 1024
   877  
   878  // disableMemoryProfiling is set by the linker if memory profiling
   879  // is not used and the link type guarantees nobody else could use it
   880  // elsewhere.
   881  // We check if the runtime.memProfileInternal symbol is present.
   882  var disableMemoryProfiling bool
   883  
   884  // A MemProfileRecord describes the live objects allocated
   885  // by a particular call sequence (stack trace).
   886  type MemProfileRecord struct {
   887  	AllocBytes, FreeBytes     int64       // number of bytes allocated, freed
   888  	AllocObjects, FreeObjects int64       // number of objects allocated, freed
   889  	Stack0                    [32]uintptr // stack trace for this record; ends at first 0 entry
   890  }
   891  
   892  // InUseBytes returns the number of bytes in use (AllocBytes - FreeBytes).
   893  func (r *MemProfileRecord) InUseBytes() int64 { return r.AllocBytes - r.FreeBytes }
   894  
   895  // InUseObjects returns the number of objects in use (AllocObjects - FreeObjects).
   896  func (r *MemProfileRecord) InUseObjects() int64 {
   897  	return r.AllocObjects - r.FreeObjects
   898  }
   899  
   900  // Stack returns the stack trace associated with the record,
   901  // a prefix of r.Stack0.
   902  func (r *MemProfileRecord) Stack() []uintptr {
   903  	for i, v := range r.Stack0 {
   904  		if v == 0 {
   905  			return r.Stack0[0:i]
   906  		}
   907  	}
   908  	return r.Stack0[0:]
   909  }
   910  
   911  // MemProfile returns a profile of memory allocated and freed per allocation
   912  // site.
   913  //
   914  // MemProfile returns n, the number of records in the current memory profile.
   915  // If len(p) >= n, MemProfile copies the profile into p and returns n, true.
   916  // If len(p) < n, MemProfile does not change p and returns n, false.
   917  //
   918  // If inuseZero is true, the profile includes allocation records
   919  // where r.AllocBytes > 0 but r.AllocBytes == r.FreeBytes.
   920  // These are sites where memory was allocated, but it has all
   921  // been released back to the runtime.
   922  //
   923  // The returned profile may be up to two garbage collection cycles old.
   924  // This is to avoid skewing the profile toward allocations; because
   925  // allocations happen in real time but frees are delayed until the garbage
   926  // collector performs sweeping, the profile only accounts for allocations
   927  // that have had a chance to be freed by the garbage collector.
   928  //
   929  // Most clients should use the runtime/pprof package or
   930  // the testing package's -test.memprofile flag instead
   931  // of calling MemProfile directly.
   932  func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool) {
   933  	return memProfileInternal(len(p), inuseZero, func(r profilerecord.MemProfileRecord) {
   934  		copyMemProfileRecord(&p[0], r)
   935  		p = p[1:]
   936  	})
   937  }
   938  
   939  // memProfileInternal returns the number of records n in the profile. If there
   940  // are less than size records, copyFn is invoked for each record, and ok returns
   941  // true.
   942  //
   943  // The linker set disableMemoryProfiling to true to disable memory profiling
   944  // if this function is not reachable. Mark it noinline to ensure the symbol exists.
   945  // (This function is big and normally not inlined anyway.)
   946  // See also disableMemoryProfiling above and cmd/link/internal/ld/lib.go:linksetup.
   947  //
   948  //go:noinline
   949  func memProfileInternal(size int, inuseZero bool, copyFn func(profilerecord.MemProfileRecord)) (n int, ok bool) {
   950  	cycle := mProfCycle.read()
   951  	// If we're between mProf_NextCycle and mProf_Flush, take care
   952  	// of flushing to the active profile so we only have to look
   953  	// at the active profile below.
   954  	index := cycle % uint32(len(memRecord{}.future))
   955  	lock(&profMemActiveLock)
   956  	lock(&profMemFutureLock[index])
   957  	mProf_FlushLocked(index)
   958  	unlock(&profMemFutureLock[index])
   959  	clear := true
   960  	head := (*bucket)(mbuckets.Load())
   961  	for b := head; b != nil; b = b.allnext {
   962  		mp := b.mp()
   963  		if inuseZero || mp.active.alloc_bytes != mp.active.free_bytes {
   964  			n++
   965  		}
   966  		if mp.active.allocs != 0 || mp.active.frees != 0 {
   967  			clear = false
   968  		}
   969  	}
   970  	if clear {
   971  		// Absolutely no data, suggesting that a garbage collection
   972  		// has not yet happened. In order to allow profiling when
   973  		// garbage collection is disabled from the beginning of execution,
   974  		// accumulate all of the cycles, and recount buckets.
   975  		n = 0
   976  		for b := head; b != nil; b = b.allnext {
   977  			mp := b.mp()
   978  			for c := range mp.future {
   979  				lock(&profMemFutureLock[c])
   980  				mp.active.add(&mp.future[c])
   981  				mp.future[c] = memRecordCycle{}
   982  				unlock(&profMemFutureLock[c])
   983  			}
   984  			if inuseZero || mp.active.alloc_bytes != mp.active.free_bytes {
   985  				n++
   986  			}
   987  		}
   988  	}
   989  	if n <= size {
   990  		ok = true
   991  		for b := head; b != nil; b = b.allnext {
   992  			mp := b.mp()
   993  			if inuseZero || mp.active.alloc_bytes != mp.active.free_bytes {
   994  				r := profilerecord.MemProfileRecord{
   995  					AllocBytes:   int64(mp.active.alloc_bytes),
   996  					FreeBytes:    int64(mp.active.free_bytes),
   997  					AllocObjects: int64(mp.active.allocs),
   998  					FreeObjects:  int64(mp.active.frees),
   999  					Stack:        b.stk(),
  1000  				}
  1001  				copyFn(r)
  1002  			}
  1003  		}
  1004  	}
  1005  	unlock(&profMemActiveLock)
  1006  	return
  1007  }
  1008  
  1009  func copyMemProfileRecord(dst *MemProfileRecord, src profilerecord.MemProfileRecord) {
  1010  	dst.AllocBytes = src.AllocBytes
  1011  	dst.FreeBytes = src.FreeBytes
  1012  	dst.AllocObjects = src.AllocObjects
  1013  	dst.FreeObjects = src.FreeObjects
  1014  	if raceenabled {
  1015  		racewriterangepc(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0), sys.GetCallerPC(), abi.FuncPCABIInternal(MemProfile))
  1016  	}
  1017  	if msanenabled {
  1018  		msanwrite(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0))
  1019  	}
  1020  	if asanenabled {
  1021  		asanwrite(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0))
  1022  	}
  1023  	i := copy(dst.Stack0[:], src.Stack)
  1024  	clear(dst.Stack0[i:])
  1025  }
  1026  
  1027  //go:linkname pprof_memProfileInternal
  1028  func pprof_memProfileInternal(p []profilerecord.MemProfileRecord, inuseZero bool) (n int, ok bool) {
  1029  	return memProfileInternal(len(p), inuseZero, func(r profilerecord.MemProfileRecord) {
  1030  		p[0] = r
  1031  		p = p[1:]
  1032  	})
  1033  }
  1034  
  1035  func iterate_memprof(fn func(*bucket, uintptr, *uintptr, uintptr, uintptr, uintptr)) {
  1036  	lock(&profMemActiveLock)
  1037  	head := (*bucket)(mbuckets.Load())
  1038  	for b := head; b != nil; b = b.allnext {
  1039  		mp := b.mp()
  1040  		fn(b, b.nstk, &b.stk()[0], b.size, mp.active.allocs, mp.active.frees)
  1041  	}
  1042  	unlock(&profMemActiveLock)
  1043  }
  1044  
  1045  // BlockProfileRecord describes blocking events originated
  1046  // at a particular call sequence (stack trace).
  1047  type BlockProfileRecord struct {
  1048  	Count  int64
  1049  	Cycles int64
  1050  	StackRecord
  1051  }
  1052  
  1053  // BlockProfile returns n, the number of records in the current blocking profile.
  1054  // If len(p) >= n, BlockProfile copies the profile into p and returns n, true.
  1055  // If len(p) < n, BlockProfile does not change p and returns n, false.
  1056  //
  1057  // Most clients should use the [runtime/pprof] package or
  1058  // the [testing] package's -test.blockprofile flag instead
  1059  // of calling BlockProfile directly.
  1060  func BlockProfile(p []BlockProfileRecord) (n int, ok bool) {
  1061  	var m int
  1062  	n, ok = blockProfileInternal(len(p), func(r profilerecord.BlockProfileRecord) {
  1063  		copyBlockProfileRecord(&p[m], r)
  1064  		m++
  1065  	})
  1066  	if ok {
  1067  		expandFrames(p[:n])
  1068  	}
  1069  	return
  1070  }
  1071  
  1072  func expandFrames(p []BlockProfileRecord) {
  1073  	expandedStack := makeProfStack()
  1074  	for i := range p {
  1075  		cf := CallersFrames(p[i].Stack())
  1076  		j := 0
  1077  		for j < len(expandedStack) {
  1078  			f, more := cf.Next()
  1079  			// f.PC is a "call PC", but later consumers will expect
  1080  			// "return PCs"
  1081  			expandedStack[j] = f.PC + 1
  1082  			j++
  1083  			if !more {
  1084  				break
  1085  			}
  1086  		}
  1087  		k := copy(p[i].Stack0[:], expandedStack[:j])
  1088  		clear(p[i].Stack0[k:])
  1089  	}
  1090  }
  1091  
  1092  // blockProfileInternal returns the number of records n in the profile. If there
  1093  // are less than size records, copyFn is invoked for each record, and ok returns
  1094  // true.
  1095  func blockProfileInternal(size int, copyFn func(profilerecord.BlockProfileRecord)) (n int, ok bool) {
  1096  	lock(&profBlockLock)
  1097  	head := (*bucket)(bbuckets.Load())
  1098  	for b := head; b != nil; b = b.allnext {
  1099  		n++
  1100  	}
  1101  	if n <= size {
  1102  		ok = true
  1103  		for b := head; b != nil; b = b.allnext {
  1104  			bp := b.bp()
  1105  			r := profilerecord.BlockProfileRecord{
  1106  				Count:  int64(bp.count),
  1107  				Cycles: bp.cycles,
  1108  				Stack:  b.stk(),
  1109  			}
  1110  			// Prevent callers from having to worry about division by zero errors.
  1111  			// See discussion on http://golang.org/cl/299991.
  1112  			if r.Count == 0 {
  1113  				r.Count = 1
  1114  			}
  1115  			copyFn(r)
  1116  		}
  1117  	}
  1118  	unlock(&profBlockLock)
  1119  	return
  1120  }
  1121  
  1122  // copyBlockProfileRecord copies the sample values and call stack from src to dst.
  1123  // The call stack is copied as-is. The caller is responsible for handling inline
  1124  // expansion, needed when the call stack was collected with frame pointer unwinding.
  1125  func copyBlockProfileRecord(dst *BlockProfileRecord, src profilerecord.BlockProfileRecord) {
  1126  	dst.Count = src.Count
  1127  	dst.Cycles = src.Cycles
  1128  	if raceenabled {
  1129  		racewriterangepc(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0), sys.GetCallerPC(), abi.FuncPCABIInternal(BlockProfile))
  1130  	}
  1131  	if msanenabled {
  1132  		msanwrite(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0))
  1133  	}
  1134  	if asanenabled {
  1135  		asanwrite(unsafe.Pointer(&dst.Stack0[0]), unsafe.Sizeof(dst.Stack0))
  1136  	}
  1137  	// We just copy the stack here without inline expansion
  1138  	// (needed if frame pointer unwinding is used)
  1139  	// since this function is called under the profile lock,
  1140  	// and doing something that might allocate can violate lock ordering.
  1141  	i := copy(dst.Stack0[:], src.Stack)
  1142  	clear(dst.Stack0[i:])
  1143  }
  1144  
  1145  //go:linkname pprof_blockProfileInternal
  1146  func pprof_blockProfileInternal(p []profilerecord.BlockProfileRecord) (n int, ok bool) {
  1147  	return blockProfileInternal(len(p), func(r profilerecord.BlockProfileRecord) {
  1148  		p[0] = r
  1149  		p = p[1:]
  1150  	})
  1151  }
  1152  
  1153  // MutexProfile returns n, the number of records in the current mutex profile.
  1154  // If len(p) >= n, MutexProfile copies the profile into p and returns n, true.
  1155  // Otherwise, MutexProfile does not change p, and returns n, false.
  1156  //
  1157  // Most clients should use the [runtime/pprof] package
  1158  // instead of calling MutexProfile directly.
  1159  func MutexProfile(p []BlockProfileRecord) (n int, ok bool) {
  1160  	var m int
  1161  	n, ok = mutexProfileInternal(len(p), func(r profilerecord.BlockProfileRecord) {
  1162  		copyBlockProfileRecord(&p[m], r)
  1163  		m++
  1164  	})
  1165  	if ok {
  1166  		expandFrames(p[:n])
  1167  	}
  1168  	return
  1169  }
  1170  
  1171  // mutexProfileInternal returns the number of records n in the profile. If there
  1172  // are less than size records, copyFn is invoked for each record, and ok returns
  1173  // true.
  1174  func mutexProfileInternal(size int, copyFn func(profilerecord.BlockProfileRecord)) (n int, ok bool) {
  1175  	lock(&profBlockLock)
  1176  	head := (*bucket)(xbuckets.Load())
  1177  	for b := head; b != nil; b = b.allnext {
  1178  		n++
  1179  	}
  1180  	if n <= size {
  1181  		ok = true
  1182  		for b := head; b != nil; b = b.allnext {
  1183  			bp := b.bp()
  1184  			r := profilerecord.BlockProfileRecord{
  1185  				Count:  int64(bp.count),
  1186  				Cycles: bp.cycles,
  1187  				Stack:  b.stk(),
  1188  			}
  1189  			copyFn(r)
  1190  		}
  1191  	}
  1192  	unlock(&profBlockLock)
  1193  	return
  1194  }
  1195  
  1196  //go:linkname pprof_mutexProfileInternal
  1197  func pprof_mutexProfileInternal(p []profilerecord.BlockProfileRecord) (n int, ok bool) {
  1198  	return mutexProfileInternal(len(p), func(r profilerecord.BlockProfileRecord) {
  1199  		p[0] = r
  1200  		p = p[1:]
  1201  	})
  1202  }
  1203  
  1204  // ThreadCreateProfile returns n, the number of records in the thread creation profile.
  1205  // If len(p) >= n, ThreadCreateProfile copies the profile into p and returns n, true.
  1206  // If len(p) < n, ThreadCreateProfile does not change p and returns n, false.
  1207  //
  1208  // Most clients should use the runtime/pprof package instead
  1209  // of calling ThreadCreateProfile directly.
  1210  func ThreadCreateProfile(p []StackRecord) (n int, ok bool) {
  1211  	return threadCreateProfileInternal(len(p), func(r profilerecord.StackRecord) {
  1212  		i := copy(p[0].Stack0[:], r.Stack)
  1213  		clear(p[0].Stack0[i:])
  1214  		p = p[1:]
  1215  	})
  1216  }
  1217  
  1218  // threadCreateProfileInternal returns the number of records n in the profile.
  1219  // If there are less than size records, copyFn is invoked for each record, and
  1220  // ok returns true.
  1221  func threadCreateProfileInternal(size int, copyFn func(profilerecord.StackRecord)) (n int, ok bool) {
  1222  	first := (*m)(atomic.Loadp(unsafe.Pointer(&allm)))
  1223  	for mp := first; mp != nil; mp = mp.alllink {
  1224  		n++
  1225  	}
  1226  	if n <= size {
  1227  		ok = true
  1228  		for mp := first; mp != nil; mp = mp.alllink {
  1229  			r := profilerecord.StackRecord{Stack: mp.createstack[:]}
  1230  			copyFn(r)
  1231  		}
  1232  	}
  1233  	return
  1234  }
  1235  
  1236  //go:linkname pprof_threadCreateInternal
  1237  func pprof_threadCreateInternal(p []profilerecord.StackRecord) (n int, ok bool) {
  1238  	return threadCreateProfileInternal(len(p), func(r profilerecord.StackRecord) {
  1239  		p[0] = r
  1240  		p = p[1:]
  1241  	})
  1242  }
  1243  
  1244  //go:linkname pprof_goroutineProfileWithLabels
  1245  func pprof_goroutineProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
  1246  	return goroutineProfileWithLabels(p, labels)
  1247  }
  1248  
  1249  // labels may be nil. If labels is non-nil, it must have the same length as p.
  1250  func goroutineProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
  1251  	if labels != nil && len(labels) != len(p) {
  1252  		labels = nil
  1253  	}
  1254  
  1255  	return goroutineProfileWithLabelsConcurrent(p, labels)
  1256  }
  1257  
  1258  //go:linkname pprof_goroutineLeakProfileWithLabels
  1259  func pprof_goroutineLeakProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
  1260  	return goroutineLeakProfileWithLabels(p, labels)
  1261  }
  1262  
  1263  // labels may be nil. If labels is non-nil, it must have the same length as p.
  1264  func goroutineLeakProfileWithLabels(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
  1265  	if labels != nil && len(labels) != len(p) {
  1266  		labels = nil
  1267  	}
  1268  
  1269  	return goroutineLeakProfileWithLabelsConcurrent(p, labels)
  1270  }
  1271  
  1272  var goroutineProfile = struct {
  1273  	sema    uint32
  1274  	active  bool
  1275  	offset  atomic.Int64
  1276  	records []profilerecord.StackRecord
  1277  	labels  []unsafe.Pointer
  1278  }{
  1279  	sema: 1,
  1280  }
  1281  
  1282  // goroutineProfileState indicates the status of a goroutine's stack for the
  1283  // current in-progress goroutine profile. Goroutines' stacks are initially
  1284  // "Absent" from the profile, and end up "Satisfied" by the time the profile is
  1285  // complete. While a goroutine's stack is being captured, its
  1286  // goroutineProfileState will be "InProgress" and it will not be able to run
  1287  // until the capture completes and the state moves to "Satisfied".
  1288  //
  1289  // Some goroutines (the finalizer goroutine, which at various times can be
  1290  // either a "system" or a "user" goroutine, and the goroutine that is
  1291  // coordinating the profile, any goroutines created during the profile) move
  1292  // directly to the "Satisfied" state.
  1293  type goroutineProfileState uint32
  1294  
  1295  const (
  1296  	goroutineProfileAbsent goroutineProfileState = iota
  1297  	goroutineProfileInProgress
  1298  	goroutineProfileSatisfied
  1299  )
  1300  
  1301  type goroutineProfileStateHolder atomic.Uint32
  1302  
  1303  func (p *goroutineProfileStateHolder) Load() goroutineProfileState {
  1304  	return goroutineProfileState((*atomic.Uint32)(p).Load())
  1305  }
  1306  
  1307  func (p *goroutineProfileStateHolder) Store(value goroutineProfileState) {
  1308  	(*atomic.Uint32)(p).Store(uint32(value))
  1309  }
  1310  
  1311  func (p *goroutineProfileStateHolder) CompareAndSwap(old, new goroutineProfileState) bool {
  1312  	return (*atomic.Uint32)(p).CompareAndSwap(uint32(old), uint32(new))
  1313  }
  1314  
  1315  func goroutineLeakProfileWithLabelsConcurrent(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
  1316  	if len(p) == 0 {
  1317  		// An empty slice is obviously too small. Return a rough
  1318  		// allocation estimate.
  1319  		return work.goroutineLeak.count, false
  1320  	}
  1321  
  1322  	pcbuf := makeProfStack() // see saveg() for explanation
  1323  
  1324  	// Prepare a profile large enough to store all leaked goroutines.
  1325  	n = work.goroutineLeak.count
  1326  
  1327  	if n > len(p) {
  1328  		// There's not enough space in p to store the whole profile, so
  1329  		// we're not allowed to write to p at all and must return n, false.
  1330  		return n, false
  1331  	}
  1332  
  1333  	// Visit each leaked goroutine and try to record its stack.
  1334  	var offset int
  1335  	forEachGRace(func(gp1 *g) {
  1336  		if readgstatus(gp1)&^_Gscan == _Gleaked {
  1337  			systemstack(func() { saveg(^uintptr(0), ^uintptr(0), gp1, &p[offset], pcbuf) })
  1338  			if labels != nil {
  1339  				labels[offset] = gp1.labels
  1340  			}
  1341  			offset++
  1342  		}
  1343  	})
  1344  
  1345  	if raceenabled {
  1346  		raceacquire(unsafe.Pointer(&labelSync))
  1347  	}
  1348  
  1349  	return n, true
  1350  }
  1351  
  1352  func goroutineProfileWithLabelsConcurrent(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
  1353  	if len(p) == 0 {
  1354  		// An empty slice is obviously too small. Return a rough
  1355  		// allocation estimate without bothering to STW. As long as
  1356  		// this is close, then we'll only need to STW once (on the next
  1357  		// call).
  1358  		return int(gcount(false)), false
  1359  	}
  1360  
  1361  	semacquire(&goroutineProfile.sema)
  1362  
  1363  	ourg := getg()
  1364  
  1365  	pcbuf := makeProfStack() // see saveg() for explanation
  1366  	stw := stopTheWorld(stwGoroutineProfile)
  1367  	// Using gcount while the world is stopped should give us a consistent view
  1368  	// of the number of live goroutines, minus the number of goroutines that are
  1369  	// alive and permanently marked as "system". But to make this count agree
  1370  	// with what we'd get from isSystemGoroutine, we need special handling for
  1371  	// goroutines that can vary between user and system to ensure that the count
  1372  	// doesn't change during the collection. So, check the finalizer goroutine
  1373  	// and cleanup goroutines in particular.
  1374  	n = int(gcount(false))
  1375  	if fingStatus.Load()&fingRunningFinalizer != 0 {
  1376  		n++
  1377  	}
  1378  	n += int(gcCleanups.running.Load())
  1379  
  1380  	if n > len(p) {
  1381  		// There's not enough space in p to store the whole profile, so (per the
  1382  		// contract of runtime.GoroutineProfile) we're not allowed to write to p
  1383  		// at all and must return n, false.
  1384  		startTheWorld(stw)
  1385  		semrelease(&goroutineProfile.sema)
  1386  		return n, false
  1387  	}
  1388  
  1389  	// Save current goroutine.
  1390  	sp := sys.GetCallerSP()
  1391  	pc := sys.GetCallerPC()
  1392  	systemstack(func() {
  1393  		saveg(pc, sp, ourg, &p[0], pcbuf)
  1394  	})
  1395  	if labels != nil {
  1396  		labels[0] = ourg.labels
  1397  	}
  1398  	ourg.goroutineProfiled.Store(goroutineProfileSatisfied)
  1399  	goroutineProfile.offset.Store(1)
  1400  
  1401  	// Prepare for all other goroutines to enter the profile. Aside from ourg,
  1402  	// every goroutine struct in the allgs list has its goroutineProfiled field
  1403  	// cleared. Any goroutine created from this point on (while
  1404  	// goroutineProfile.active is set) will start with its goroutineProfiled
  1405  	// field set to goroutineProfileSatisfied.
  1406  	goroutineProfile.active = true
  1407  	goroutineProfile.records = p
  1408  	goroutineProfile.labels = labels
  1409  	startTheWorld(stw)
  1410  
  1411  	// Visit each goroutine that existed as of the startTheWorld call above.
  1412  	//
  1413  	// New goroutines may not be in this list, but we didn't want to know about
  1414  	// them anyway. If they do appear in this list (via reusing a dead goroutine
  1415  	// struct, or racing to launch between the world restarting and us getting
  1416  	// the list), they will already have their goroutineProfiled field set to
  1417  	// goroutineProfileSatisfied before their state transitions out of _Gdead.
  1418  	//
  1419  	// Any goroutine that the scheduler tries to execute concurrently with this
  1420  	// call will start by adding itself to the profile (before the act of
  1421  	// executing can cause any changes in its stack).
  1422  	forEachGRace(func(gp1 *g) {
  1423  		tryRecordGoroutineProfile(gp1, pcbuf, Gosched)
  1424  	})
  1425  
  1426  	stw = stopTheWorld(stwGoroutineProfileCleanup)
  1427  	endOffset := goroutineProfile.offset.Swap(0)
  1428  	goroutineProfile.active = false
  1429  	goroutineProfile.records = nil
  1430  	goroutineProfile.labels = nil
  1431  	startTheWorld(stw)
  1432  
  1433  	// Restore the invariant that every goroutine struct in allgs has its
  1434  	// goroutineProfiled field cleared.
  1435  	forEachGRace(func(gp1 *g) {
  1436  		gp1.goroutineProfiled.Store(goroutineProfileAbsent)
  1437  	})
  1438  
  1439  	if raceenabled {
  1440  		raceacquire(unsafe.Pointer(&labelSync))
  1441  	}
  1442  
  1443  	if n != int(endOffset) {
  1444  		// It's a big surprise that the number of goroutines changed while we
  1445  		// were collecting the profile. But probably better to return a
  1446  		// truncated profile than to crash the whole process.
  1447  		//
  1448  		// For instance, needm moves a goroutine out of the _Gdeadextra state and so
  1449  		// might be able to change the goroutine count without interacting with
  1450  		// the scheduler. For code like that, the race windows are small and the
  1451  		// combination of features is uncommon, so it's hard to be (and remain)
  1452  		// sure we've caught them all.
  1453  	}
  1454  
  1455  	semrelease(&goroutineProfile.sema)
  1456  	return n, true
  1457  }
  1458  
  1459  // tryRecordGoroutineProfileWB asserts that write barriers are allowed and calls
  1460  // tryRecordGoroutineProfile.
  1461  //
  1462  //go:yeswritebarrierrec
  1463  func tryRecordGoroutineProfileWB(gp1 *g) {
  1464  	if getg().m.p.ptr() == nil {
  1465  		throw("no P available, write barriers are forbidden")
  1466  	}
  1467  	tryRecordGoroutineProfile(gp1, nil, osyield)
  1468  }
  1469  
  1470  // tryRecordGoroutineProfile ensures that gp1 has the appropriate representation
  1471  // in the current goroutine profile: either that it should not be profiled, or
  1472  // that a snapshot of its call stack and labels are now in the profile.
  1473  func tryRecordGoroutineProfile(gp1 *g, pcbuf []uintptr, yield func()) {
  1474  	if status := readgstatus(gp1); status == _Gdead || status == _Gdeadextra {
  1475  		// Dead goroutines should not appear in the profile. Goroutines that
  1476  		// start while profile collection is active will get goroutineProfiled
  1477  		// set to goroutineProfileSatisfied before transitioning out of _Gdead,
  1478  		// so here we check _Gdead first.
  1479  		return
  1480  	}
  1481  
  1482  	for {
  1483  		prev := gp1.goroutineProfiled.Load()
  1484  		if prev == goroutineProfileSatisfied {
  1485  			// This goroutine is already in the profile (or is new since the
  1486  			// start of collection, so shouldn't appear in the profile).
  1487  			break
  1488  		}
  1489  		if prev == goroutineProfileInProgress {
  1490  			// Something else is adding gp1 to the goroutine profile right now.
  1491  			// Give that a moment to finish.
  1492  			yield()
  1493  			continue
  1494  		}
  1495  
  1496  		// While we have gp1.goroutineProfiled set to
  1497  		// goroutineProfileInProgress, gp1 may appear _Grunnable but will not
  1498  		// actually be able to run. Disable preemption for ourselves, to make
  1499  		// sure we finish profiling gp1 right away instead of leaving it stuck
  1500  		// in this limbo.
  1501  		mp := acquirem()
  1502  		if gp1.goroutineProfiled.CompareAndSwap(goroutineProfileAbsent, goroutineProfileInProgress) {
  1503  			doRecordGoroutineProfile(gp1, pcbuf)
  1504  			gp1.goroutineProfiled.Store(goroutineProfileSatisfied)
  1505  		}
  1506  		releasem(mp)
  1507  	}
  1508  }
  1509  
  1510  // doRecordGoroutineProfile writes gp1's call stack and labels to an in-progress
  1511  // goroutine profile. Preemption is disabled.
  1512  //
  1513  // This may be called via tryRecordGoroutineProfile in two ways: by the
  1514  // goroutine that is coordinating the goroutine profile (running on its own
  1515  // stack), or from the scheduler in preparation to execute gp1 (running on the
  1516  // system stack).
  1517  func doRecordGoroutineProfile(gp1 *g, pcbuf []uintptr) {
  1518  	if isSystemGoroutine(gp1, false) {
  1519  		// System goroutines should not appear in the profile.
  1520  		// Check this here and not in tryRecordGoroutineProfile because isSystemGoroutine
  1521  		// may change on a goroutine while it is executing, so while the scheduler might
  1522  		// see a system goroutine, goroutineProfileWithLabelsConcurrent might not, and
  1523  		// this inconsistency could cause invariants to be violated, such as trying to
  1524  		// record the stack of a running goroutine below. In short, we still want system
  1525  		// goroutines to participate in the same state machine on gp1.goroutineProfiled as
  1526  		// everything else, we just don't record the stack in the profile.
  1527  		return
  1528  	}
  1529  	// Double-check that we didn't make a grave mistake. If the G is running then in
  1530  	// general, we cannot safely read its stack.
  1531  	//
  1532  	// However, there is one case where it's OK. There's a small window of time in
  1533  	// exitsyscall where a goroutine could be in _Grunning as it's exiting a syscall.
  1534  	// This is OK because goroutine will not exit the syscall until it passes through
  1535  	// a call to tryRecordGoroutineProfile. (An explicit one on the fast path, an
  1536  	// implicit one via the scheduler on the slow path.)
  1537  	//
  1538  	// This is also why it's safe to check syscallsp here. The syscall path mutates
  1539  	// syscallsp only after passing through tryRecordGoroutineProfile.
  1540  	if readgstatus(gp1) == _Grunning && gp1.syscallsp == 0 {
  1541  		print("doRecordGoroutineProfile gp1=", gp1.goid, "\n")
  1542  		throw("cannot read stack of running goroutine")
  1543  	}
  1544  
  1545  	offset := int(goroutineProfile.offset.Add(1)) - 1
  1546  
  1547  	if offset >= len(goroutineProfile.records) {
  1548  		// Should be impossible, but better to return a truncated profile than
  1549  		// to crash the entire process at this point. Instead, deal with it in
  1550  		// goroutineProfileWithLabelsConcurrent where we have more context.
  1551  		return
  1552  	}
  1553  
  1554  	// saveg calls gentraceback, which may call cgo traceback functions. When
  1555  	// called from the scheduler, this is on the system stack already so
  1556  	// traceback.go:cgoContextPCs will avoid calling back into the scheduler.
  1557  	//
  1558  	// When called from the goroutine coordinating the profile, we still have
  1559  	// set gp1.goroutineProfiled to goroutineProfileInProgress and so are still
  1560  	// preventing it from being truly _Grunnable. So we'll use the system stack
  1561  	// to avoid schedule delays.
  1562  	systemstack(func() { saveg(^uintptr(0), ^uintptr(0), gp1, &goroutineProfile.records[offset], pcbuf) })
  1563  
  1564  	if goroutineProfile.labels != nil {
  1565  		goroutineProfile.labels[offset] = gp1.labels
  1566  	}
  1567  }
  1568  
  1569  func goroutineProfileWithLabelsSync(p []profilerecord.StackRecord, labels []unsafe.Pointer) (n int, ok bool) {
  1570  	gp := getg()
  1571  
  1572  	isOK := func(gp1 *g) bool {
  1573  		// Checking isSystemGoroutine here makes GoroutineProfile
  1574  		// consistent with both NumGoroutine and Stack.
  1575  		if gp1 == gp {
  1576  			return false
  1577  		}
  1578  		if status := readgstatus(gp1); status == _Gdead || status == _Gdeadextra {
  1579  			return false
  1580  		}
  1581  		if isSystemGoroutine(gp1, false) {
  1582  			return false
  1583  		}
  1584  		return true
  1585  	}
  1586  
  1587  	pcbuf := makeProfStack() // see saveg() for explanation
  1588  	stw := stopTheWorld(stwGoroutineProfile)
  1589  
  1590  	// World is stopped, no locking required.
  1591  	n = 1
  1592  	forEachGRace(func(gp1 *g) {
  1593  		if isOK(gp1) {
  1594  			n++
  1595  		}
  1596  	})
  1597  
  1598  	if n <= len(p) {
  1599  		ok = true
  1600  		r, lbl := p, labels
  1601  
  1602  		// Save current goroutine.
  1603  		sp := sys.GetCallerSP()
  1604  		pc := sys.GetCallerPC()
  1605  		systemstack(func() {
  1606  			saveg(pc, sp, gp, &r[0], pcbuf)
  1607  		})
  1608  		r = r[1:]
  1609  
  1610  		// If we have a place to put our goroutine labelmap, insert it there.
  1611  		if labels != nil {
  1612  			lbl[0] = gp.labels
  1613  			lbl = lbl[1:]
  1614  		}
  1615  
  1616  		// Save other goroutines.
  1617  		forEachGRace(func(gp1 *g) {
  1618  			if !isOK(gp1) {
  1619  				return
  1620  			}
  1621  
  1622  			if len(r) == 0 {
  1623  				// Should be impossible, but better to return a
  1624  				// truncated profile than to crash the entire process.
  1625  				return
  1626  			}
  1627  			// saveg calls gentraceback, which may call cgo traceback functions.
  1628  			// The world is stopped, so it cannot use cgocall (which will be
  1629  			// blocked at exitsyscall). Do it on the system stack so it won't
  1630  			// call into the schedular (see traceback.go:cgoContextPCs).
  1631  			systemstack(func() { saveg(^uintptr(0), ^uintptr(0), gp1, &r[0], pcbuf) })
  1632  			if labels != nil {
  1633  				lbl[0] = gp1.labels
  1634  				lbl = lbl[1:]
  1635  			}
  1636  			r = r[1:]
  1637  		})
  1638  	}
  1639  
  1640  	if raceenabled {
  1641  		raceacquire(unsafe.Pointer(&labelSync))
  1642  	}
  1643  
  1644  	startTheWorld(stw)
  1645  	return n, ok
  1646  }
  1647  
  1648  // GoroutineProfile returns n, the number of records in the active goroutine stack profile.
  1649  // If len(p) >= n, GoroutineProfile copies the profile into p and returns n, true.
  1650  // If len(p) < n, GoroutineProfile does not change p and returns n, false.
  1651  //
  1652  // Most clients should use the [runtime/pprof] package instead
  1653  // of calling GoroutineProfile directly.
  1654  func GoroutineProfile(p []StackRecord) (n int, ok bool) {
  1655  	records := make([]profilerecord.StackRecord, len(p))
  1656  	n, ok = goroutineProfileInternal(records)
  1657  	if !ok {
  1658  		return
  1659  	}
  1660  	for i, mr := range records[0:n] {
  1661  		l := copy(p[i].Stack0[:], mr.Stack)
  1662  		clear(p[i].Stack0[l:])
  1663  	}
  1664  	return
  1665  }
  1666  
  1667  func goroutineProfileInternal(p []profilerecord.StackRecord) (n int, ok bool) {
  1668  	return goroutineProfileWithLabels(p, nil)
  1669  }
  1670  
  1671  func saveg(pc, sp uintptr, gp *g, r *profilerecord.StackRecord, pcbuf []uintptr) {
  1672  	// To reduce memory usage, we want to allocate a r.Stack that is just big
  1673  	// enough to hold gp's stack trace. Naively we might achieve this by
  1674  	// recording our stack trace into mp.profStack, and then allocating a
  1675  	// r.Stack of the right size. However, mp.profStack is also used for
  1676  	// allocation profiling, so it could get overwritten if the slice allocation
  1677  	// gets profiled. So instead we record the stack trace into a temporary
  1678  	// pcbuf which is usually given to us by our caller. When it's not, we have
  1679  	// to allocate one here. This will only happen for goroutines that were in a
  1680  	// syscall when the goroutine profile started or for goroutines that manage
  1681  	// to execute before we finish iterating over all the goroutines.
  1682  	if pcbuf == nil {
  1683  		pcbuf = makeProfStack()
  1684  	}
  1685  
  1686  	var u unwinder
  1687  	u.initAt(pc, sp, 0, gp, unwindSilentErrors)
  1688  	n := tracebackPCs(&u, 0, pcbuf)
  1689  	r.Stack = make([]uintptr, n)
  1690  	copy(r.Stack, pcbuf)
  1691  }
  1692  
  1693  // Stack formats a stack trace of the calling goroutine into buf
  1694  // and returns the number of bytes written to buf.
  1695  // If all is true, Stack formats stack traces of all other goroutines
  1696  // into buf after the trace for the current goroutine.
  1697  func Stack(buf []byte, all bool) int {
  1698  	var stw worldStop
  1699  	if all {
  1700  		stw = stopTheWorld(stwAllGoroutinesStack)
  1701  	}
  1702  
  1703  	n := 0
  1704  	if len(buf) > 0 {
  1705  		gp := getg()
  1706  		sp := sys.GetCallerSP()
  1707  		pc := sys.GetCallerPC()
  1708  		systemstack(func() {
  1709  			g0 := getg()
  1710  			// Force traceback=1 to override GOTRACEBACK setting,
  1711  			// so that Stack's results are consistent.
  1712  			// GOTRACEBACK is only about crash dumps.
  1713  			g0.m.traceback = 1
  1714  			g0.writebuf = buf[0:0:len(buf)]
  1715  			goroutineheader(gp)
  1716  			traceback(pc, sp, 0, gp)
  1717  			if all {
  1718  				tracebackothers(gp)
  1719  			}
  1720  			g0.m.traceback = 0
  1721  			n = len(g0.writebuf)
  1722  			g0.writebuf = nil
  1723  		})
  1724  	}
  1725  
  1726  	if all {
  1727  		startTheWorld(stw)
  1728  	}
  1729  	return n
  1730  }
  1731  

View as plain text