...
Run Format

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		"runtime/internal/atomic"
    12		"unsafe"
    13	)
    14	
    15	// NOTE(rsc): Everything here could use cas if contention became an issue.
    16	var proflock mutex
    17	
    18	// All memory allocations are local and do not escape outside of the profiler.
    19	// The profiler is forbidden from referring to garbage-collected memory.
    20	
    21	const (
    22		// profile types
    23		memProfile bucketType = 1 + iota
    24		blockProfile
    25		mutexProfile
    26	
    27		// size of bucket hash table
    28		buckHashSize = 179999
    29	
    30		// max depth of stack to record in bucket
    31		maxStack = 32
    32	)
    33	
    34	type bucketType int
    35	
    36	// A bucket holds per-call-stack profiling information.
    37	// The representation is a bit sleazy, inherited from C.
    38	// This struct defines the bucket header. It is followed in
    39	// memory by the stack words and then the actual record
    40	// data, either a memRecord or a blockRecord.
    41	//
    42	// Per-call-stack profiling information.
    43	// Lookup by hashing call stack into a linked-list hash table.
    44	//
    45	// No heap pointers.
    46	//
    47	//go:notinheap
    48	type bucket struct {
    49		next    *bucket
    50		allnext *bucket
    51		typ     bucketType // memBucket or blockBucket (includes mutexProfile)
    52		hash    uintptr
    53		size    uintptr
    54		nstk    uintptr
    55	}
    56	
    57	// A memRecord is the bucket data for a bucket of type memProfile,
    58	// part of the memory profile.
    59	type memRecord struct {
    60		// The following complex 3-stage scheme of stats accumulation
    61		// is required to obtain a consistent picture of mallocs and frees
    62		// for some point in time.
    63		// The problem is that mallocs come in real time, while frees
    64		// come only after a GC during concurrent sweeping. So if we would
    65		// naively count them, we would get a skew toward mallocs.
    66		//
    67		// Mallocs are accounted in recent stats.
    68		// Explicit frees are accounted in recent stats.
    69		// GC frees are accounted in prev stats.
    70		// After GC prev stats are added to final stats and
    71		// recent stats are moved into prev stats.
    72		allocs      uintptr
    73		frees       uintptr
    74		alloc_bytes uintptr
    75		free_bytes  uintptr
    76	
    77		// changes between next-to-last GC and last GC
    78		prev_allocs      uintptr
    79		prev_frees       uintptr
    80		prev_alloc_bytes uintptr
    81		prev_free_bytes  uintptr
    82	
    83		// changes since last GC
    84		recent_allocs      uintptr
    85		recent_frees       uintptr
    86		recent_alloc_bytes uintptr
    87		recent_free_bytes  uintptr
    88	}
    89	
    90	// A blockRecord is the bucket data for a bucket of type blockProfile,
    91	// which is used in blocking and mutex profiles.
    92	type blockRecord struct {
    93		count  int64
    94		cycles int64
    95	}
    96	
    97	var (
    98		mbuckets  *bucket // memory profile buckets
    99		bbuckets  *bucket // blocking profile buckets
   100		xbuckets  *bucket // mutex profile buckets
   101		buckhash  *[179999]*bucket
   102		bucketmem uintptr
   103	)
   104	
   105	// newBucket allocates a bucket with the given type and number of stack entries.
   106	func newBucket(typ bucketType, nstk int) *bucket {
   107		size := unsafe.Sizeof(bucket{}) + uintptr(nstk)*unsafe.Sizeof(uintptr(0))
   108		switch typ {
   109		default:
   110			throw("invalid profile bucket type")
   111		case memProfile:
   112			size += unsafe.Sizeof(memRecord{})
   113		case blockProfile, mutexProfile:
   114			size += unsafe.Sizeof(blockRecord{})
   115		}
   116	
   117		b := (*bucket)(persistentalloc(size, 0, &memstats.buckhash_sys))
   118		bucketmem += size
   119		b.typ = typ
   120		b.nstk = uintptr(nstk)
   121		return b
   122	}
   123	
   124	// stk returns the slice in b holding the stack.
   125	func (b *bucket) stk() []uintptr {
   126		stk := (*[maxStack]uintptr)(add(unsafe.Pointer(b), unsafe.Sizeof(*b)))
   127		return stk[:b.nstk:b.nstk]
   128	}
   129	
   130	// mp returns the memRecord associated with the memProfile bucket b.
   131	func (b *bucket) mp() *memRecord {
   132		if b.typ != memProfile {
   133			throw("bad use of bucket.mp")
   134		}
   135		data := add(unsafe.Pointer(b), unsafe.Sizeof(*b)+b.nstk*unsafe.Sizeof(uintptr(0)))
   136		return (*memRecord)(data)
   137	}
   138	
   139	// bp returns the blockRecord associated with the blockProfile bucket b.
   140	func (b *bucket) bp() *blockRecord {
   141		if b.typ != blockProfile && b.typ != mutexProfile {
   142			throw("bad use of bucket.bp")
   143		}
   144		data := add(unsafe.Pointer(b), unsafe.Sizeof(*b)+b.nstk*unsafe.Sizeof(uintptr(0)))
   145		return (*blockRecord)(data)
   146	}
   147	
   148	// Return the bucket for stk[0:nstk], allocating new bucket if needed.
   149	func stkbucket(typ bucketType, size uintptr, stk []uintptr, alloc bool) *bucket {
   150		if buckhash == nil {
   151			buckhash = (*[buckHashSize]*bucket)(sysAlloc(unsafe.Sizeof(*buckhash), &memstats.buckhash_sys))
   152			if buckhash == nil {
   153				throw("runtime: cannot allocate memory")
   154			}
   155		}
   156	
   157		// Hash stack.
   158		var h uintptr
   159		for _, pc := range stk {
   160			h += pc
   161			h += h << 10
   162			h ^= h >> 6
   163		}
   164		// hash in size
   165		h += size
   166		h += h << 10
   167		h ^= h >> 6
   168		// finalize
   169		h += h << 3
   170		h ^= h >> 11
   171	
   172		i := int(h % buckHashSize)
   173		for b := buckhash[i]; b != nil; b = b.next {
   174			if b.typ == typ && b.hash == h && b.size == size && eqslice(b.stk(), stk) {
   175				return b
   176			}
   177		}
   178	
   179		if !alloc {
   180			return nil
   181		}
   182	
   183		// Create new bucket.
   184		b := newBucket(typ, len(stk))
   185		copy(b.stk(), stk)
   186		b.hash = h
   187		b.size = size
   188		b.next = buckhash[i]
   189		buckhash[i] = b
   190		if typ == memProfile {
   191			b.allnext = mbuckets
   192			mbuckets = b
   193		} else if typ == mutexProfile {
   194			b.allnext = xbuckets
   195			xbuckets = b
   196		} else {
   197			b.allnext = bbuckets
   198			bbuckets = b
   199		}
   200		return b
   201	}
   202	
   203	func eqslice(x, y []uintptr) bool {
   204		if len(x) != len(y) {
   205			return false
   206		}
   207		for i, xi := range x {
   208			if xi != y[i] {
   209				return false
   210			}
   211		}
   212		return true
   213	}
   214	
   215	func mprof_GC() {
   216		for b := mbuckets; b != nil; b = b.allnext {
   217			mp := b.mp()
   218			mp.allocs += mp.prev_allocs
   219			mp.frees += mp.prev_frees
   220			mp.alloc_bytes += mp.prev_alloc_bytes
   221			mp.free_bytes += mp.prev_free_bytes
   222	
   223			mp.prev_allocs = mp.recent_allocs
   224			mp.prev_frees = mp.recent_frees
   225			mp.prev_alloc_bytes = mp.recent_alloc_bytes
   226			mp.prev_free_bytes = mp.recent_free_bytes
   227	
   228			mp.recent_allocs = 0
   229			mp.recent_frees = 0
   230			mp.recent_alloc_bytes = 0
   231			mp.recent_free_bytes = 0
   232		}
   233	}
   234	
   235	// Record that a gc just happened: all the 'recent' statistics are now real.
   236	func mProf_GC() {
   237		lock(&proflock)
   238		mprof_GC()
   239		unlock(&proflock)
   240	}
   241	
   242	// Called by malloc to record a profiled block.
   243	func mProf_Malloc(p unsafe.Pointer, size uintptr) {
   244		var stk [maxStack]uintptr
   245		nstk := callers(4, stk[:])
   246		lock(&proflock)
   247		b := stkbucket(memProfile, size, stk[:nstk], true)
   248		mp := b.mp()
   249		mp.recent_allocs++
   250		mp.recent_alloc_bytes += size
   251		unlock(&proflock)
   252	
   253		// Setprofilebucket locks a bunch of other mutexes, so we call it outside of proflock.
   254		// This reduces potential contention and chances of deadlocks.
   255		// Since the object must be alive during call to mProf_Malloc,
   256		// it's fine to do this non-atomically.
   257		systemstack(func() {
   258			setprofilebucket(p, b)
   259		})
   260	}
   261	
   262	// Called when freeing a profiled block.
   263	func mProf_Free(b *bucket, size uintptr) {
   264		lock(&proflock)
   265		mp := b.mp()
   266		mp.prev_frees++
   267		mp.prev_free_bytes += size
   268		unlock(&proflock)
   269	}
   270	
   271	var blockprofilerate uint64 // in CPU ticks
   272	
   273	// SetBlockProfileRate controls the fraction of goroutine blocking events
   274	// that are reported in the blocking profile. The profiler aims to sample
   275	// an average of one blocking event per rate nanoseconds spent blocked.
   276	//
   277	// To include every blocking event in the profile, pass rate = 1.
   278	// To turn off profiling entirely, pass rate <= 0.
   279	func SetBlockProfileRate(rate int) {
   280		var r int64
   281		if rate <= 0 {
   282			r = 0 // disable profiling
   283		} else if rate == 1 {
   284			r = 1 // profile everything
   285		} else {
   286			// convert ns to cycles, use float64 to prevent overflow during multiplication
   287			r = int64(float64(rate) * float64(tickspersecond()) / (1000 * 1000 * 1000))
   288			if r == 0 {
   289				r = 1
   290			}
   291		}
   292	
   293		atomic.Store64(&blockprofilerate, uint64(r))
   294	}
   295	
   296	func blockevent(cycles int64, skip int) {
   297		if cycles <= 0 {
   298			cycles = 1
   299		}
   300		if blocksampled(cycles) {
   301			saveblockevent(cycles, skip+1, blockProfile, &blockprofilerate)
   302		}
   303	}
   304	
   305	func blocksampled(cycles int64) bool {
   306		rate := int64(atomic.Load64(&blockprofilerate))
   307		if rate <= 0 || (rate > cycles && int64(fastrand())%rate > cycles) {
   308			return false
   309		}
   310		return true
   311	}
   312	
   313	func saveblockevent(cycles int64, skip int, which bucketType, ratep *uint64) {
   314		gp := getg()
   315		var nstk int
   316		var stk [maxStack]uintptr
   317		if gp.m.curg == nil || gp.m.curg == gp {
   318			nstk = callers(skip, stk[:])
   319		} else {
   320			nstk = gcallers(gp.m.curg, skip, stk[:])
   321		}
   322		lock(&proflock)
   323		b := stkbucket(which, 0, stk[:nstk], true)
   324		b.bp().count++
   325		b.bp().cycles += cycles
   326		unlock(&proflock)
   327	}
   328	
   329	var mutexprofilerate uint64 // fraction sampled
   330	
   331	// SetMutexProfileFraction controls the fraction of mutex contention events
   332	// that are reported in the mutex profile. On average 1/rate events are
   333	// reported. The previous rate is returned.
   334	//
   335	// To turn off profiling entirely, pass rate 0.
   336	// To just read the current rate, pass rate -1.
   337	// (For n>1 the details of sampling may change.)
   338	func SetMutexProfileFraction(rate int) int {
   339		if rate < 0 {
   340			return int(mutexprofilerate)
   341		}
   342		old := mutexprofilerate
   343		atomic.Store64(&mutexprofilerate, uint64(rate))
   344		return int(old)
   345	}
   346	
   347	//go:linkname mutexevent sync.event
   348	func mutexevent(cycles int64, skip int) {
   349		if cycles < 0 {
   350			cycles = 0
   351		}
   352		rate := int64(atomic.Load64(&mutexprofilerate))
   353		// TODO(pjw): measure impact of always calling fastrand vs using something
   354		// like malloc.go:nextSample()
   355		if rate > 0 && int64(fastrand())%rate == 0 {
   356			saveblockevent(cycles, skip+1, mutexProfile, &mutexprofilerate)
   357		}
   358	}
   359	
   360	// Go interface to profile data.
   361	
   362	// A StackRecord describes a single execution stack.
   363	type StackRecord struct {
   364		Stack0 [32]uintptr // stack trace for this record; ends at first 0 entry
   365	}
   366	
   367	// Stack returns the stack trace associated with the record,
   368	// a prefix of r.Stack0.
   369	func (r *StackRecord) Stack() []uintptr {
   370		for i, v := range r.Stack0 {
   371			if v == 0 {
   372				return r.Stack0[0:i]
   373			}
   374		}
   375		return r.Stack0[0:]
   376	}
   377	
   378	// MemProfileRate controls the fraction of memory allocations
   379	// that are recorded and reported in the memory profile.
   380	// The profiler aims to sample an average of
   381	// one allocation per MemProfileRate bytes allocated.
   382	//
   383	// To include every allocated block in the profile, set MemProfileRate to 1.
   384	// To turn off profiling entirely, set MemProfileRate to 0.
   385	//
   386	// The tools that process the memory profiles assume that the
   387	// profile rate is constant across the lifetime of the program
   388	// and equal to the current value. Programs that change the
   389	// memory profiling rate should do so just once, as early as
   390	// possible in the execution of the program (for example,
   391	// at the beginning of main).
   392	var MemProfileRate int = 512 * 1024
   393	
   394	// A MemProfileRecord describes the live objects allocated
   395	// by a particular call sequence (stack trace).
   396	type MemProfileRecord struct {
   397		AllocBytes, FreeBytes     int64       // number of bytes allocated, freed
   398		AllocObjects, FreeObjects int64       // number of objects allocated, freed
   399		Stack0                    [32]uintptr // stack trace for this record; ends at first 0 entry
   400	}
   401	
   402	// InUseBytes returns the number of bytes in use (AllocBytes - FreeBytes).
   403	func (r *MemProfileRecord) InUseBytes() int64 { return r.AllocBytes - r.FreeBytes }
   404	
   405	// InUseObjects returns the number of objects in use (AllocObjects - FreeObjects).
   406	func (r *MemProfileRecord) InUseObjects() int64 {
   407		return r.AllocObjects - r.FreeObjects
   408	}
   409	
   410	// Stack returns the stack trace associated with the record,
   411	// a prefix of r.Stack0.
   412	func (r *MemProfileRecord) Stack() []uintptr {
   413		for i, v := range r.Stack0 {
   414			if v == 0 {
   415				return r.Stack0[0:i]
   416			}
   417		}
   418		return r.Stack0[0:]
   419	}
   420	
   421	// MemProfile returns a profile of memory allocated and freed per allocation
   422	// site.
   423	//
   424	// MemProfile returns n, the number of records in the current memory profile.
   425	// If len(p) >= n, MemProfile copies the profile into p and returns n, true.
   426	// If len(p) < n, MemProfile does not change p and returns n, false.
   427	//
   428	// If inuseZero is true, the profile includes allocation records
   429	// where r.AllocBytes > 0 but r.AllocBytes == r.FreeBytes.
   430	// These are sites where memory was allocated, but it has all
   431	// been released back to the runtime.
   432	//
   433	// The returned profile may be up to two garbage collection cycles old.
   434	// This is to avoid skewing the profile toward allocations; because
   435	// allocations happen in real time but frees are delayed until the garbage
   436	// collector performs sweeping, the profile only accounts for allocations
   437	// that have had a chance to be freed by the garbage collector.
   438	//
   439	// Most clients should use the runtime/pprof package or
   440	// the testing package's -test.memprofile flag instead
   441	// of calling MemProfile directly.
   442	func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool) {
   443		lock(&proflock)
   444		clear := true
   445		for b := mbuckets; b != nil; b = b.allnext {
   446			mp := b.mp()
   447			if inuseZero || mp.alloc_bytes != mp.free_bytes {
   448				n++
   449			}
   450			if mp.allocs != 0 || mp.frees != 0 {
   451				clear = false
   452			}
   453		}
   454		if clear {
   455			// Absolutely no data, suggesting that a garbage collection
   456			// has not yet happened. In order to allow profiling when
   457			// garbage collection is disabled from the beginning of execution,
   458			// accumulate stats as if a GC just happened, and recount buckets.
   459			mprof_GC()
   460			mprof_GC()
   461			n = 0
   462			for b := mbuckets; b != nil; b = b.allnext {
   463				mp := b.mp()
   464				if inuseZero || mp.alloc_bytes != mp.free_bytes {
   465					n++
   466				}
   467			}
   468		}
   469		if n <= len(p) {
   470			ok = true
   471			idx := 0
   472			for b := mbuckets; b != nil; b = b.allnext {
   473				mp := b.mp()
   474				if inuseZero || mp.alloc_bytes != mp.free_bytes {
   475					record(&p[idx], b)
   476					idx++
   477				}
   478			}
   479		}
   480		unlock(&proflock)
   481		return
   482	}
   483	
   484	// Write b's data to r.
   485	func record(r *MemProfileRecord, b *bucket) {
   486		mp := b.mp()
   487		r.AllocBytes = int64(mp.alloc_bytes)
   488		r.FreeBytes = int64(mp.free_bytes)
   489		r.AllocObjects = int64(mp.allocs)
   490		r.FreeObjects = int64(mp.frees)
   491		if raceenabled {
   492			racewriterangepc(unsafe.Pointer(&r.Stack0[0]), unsafe.Sizeof(r.Stack0), getcallerpc(unsafe.Pointer(&r)), funcPC(MemProfile))
   493		}
   494		if msanenabled {
   495			msanwrite(unsafe.Pointer(&r.Stack0[0]), unsafe.Sizeof(r.Stack0))
   496		}
   497		copy(r.Stack0[:], b.stk())
   498		for i := int(b.nstk); i < len(r.Stack0); i++ {
   499			r.Stack0[i] = 0
   500		}
   501	}
   502	
   503	func iterate_memprof(fn func(*bucket, uintptr, *uintptr, uintptr, uintptr, uintptr)) {
   504		lock(&proflock)
   505		for b := mbuckets; b != nil; b = b.allnext {
   506			mp := b.mp()
   507			fn(b, b.nstk, &b.stk()[0], b.size, mp.allocs, mp.frees)
   508		}
   509		unlock(&proflock)
   510	}
   511	
   512	// BlockProfileRecord describes blocking events originated
   513	// at a particular call sequence (stack trace).
   514	type BlockProfileRecord struct {
   515		Count  int64
   516		Cycles int64
   517		StackRecord
   518	}
   519	
   520	// BlockProfile returns n, the number of records in the current blocking profile.
   521	// If len(p) >= n, BlockProfile copies the profile into p and returns n, true.
   522	// If len(p) < n, BlockProfile does not change p and returns n, false.
   523	//
   524	// Most clients should use the runtime/pprof package or
   525	// the testing package's -test.blockprofile flag instead
   526	// of calling BlockProfile directly.
   527	func BlockProfile(p []BlockProfileRecord) (n int, ok bool) {
   528		lock(&proflock)
   529		for b := bbuckets; b != nil; b = b.allnext {
   530			n++
   531		}
   532		if n <= len(p) {
   533			ok = true
   534			for b := bbuckets; b != nil; b = b.allnext {
   535				bp := b.bp()
   536				r := &p[0]
   537				r.Count = bp.count
   538				r.Cycles = bp.cycles
   539				if raceenabled {
   540					racewriterangepc(unsafe.Pointer(&r.Stack0[0]), unsafe.Sizeof(r.Stack0), getcallerpc(unsafe.Pointer(&p)), funcPC(BlockProfile))
   541				}
   542				if msanenabled {
   543					msanwrite(unsafe.Pointer(&r.Stack0[0]), unsafe.Sizeof(r.Stack0))
   544				}
   545				i := copy(r.Stack0[:], b.stk())
   546				for ; i < len(r.Stack0); i++ {
   547					r.Stack0[i] = 0
   548				}
   549				p = p[1:]
   550			}
   551		}
   552		unlock(&proflock)
   553		return
   554	}
   555	
   556	// MutexProfile returns n, the number of records in the current mutex profile.
   557	// If len(p) >= n, MutexProfile copies the profile into p and returns n, true.
   558	// Otherwise, MutexProfile does not change p, and returns n, false.
   559	//
   560	// Most clients should use the runtime/pprof package
   561	// instead of calling MutexProfile directly.
   562	func MutexProfile(p []BlockProfileRecord) (n int, ok bool) {
   563		lock(&proflock)
   564		for b := xbuckets; b != nil; b = b.allnext {
   565			n++
   566		}
   567		if n <= len(p) {
   568			ok = true
   569			for b := xbuckets; b != nil; b = b.allnext {
   570				bp := b.bp()
   571				r := &p[0]
   572				r.Count = int64(bp.count)
   573				r.Cycles = bp.cycles
   574				i := copy(r.Stack0[:], b.stk())
   575				for ; i < len(r.Stack0); i++ {
   576					r.Stack0[i] = 0
   577				}
   578				p = p[1:]
   579			}
   580		}
   581		unlock(&proflock)
   582		return
   583	}
   584	
   585	// ThreadCreateProfile returns n, the number of records in the thread creation profile.
   586	// If len(p) >= n, ThreadCreateProfile copies the profile into p and returns n, true.
   587	// If len(p) < n, ThreadCreateProfile does not change p and returns n, false.
   588	//
   589	// Most clients should use the runtime/pprof package instead
   590	// of calling ThreadCreateProfile directly.
   591	func ThreadCreateProfile(p []StackRecord) (n int, ok bool) {
   592		first := (*m)(atomic.Loadp(unsafe.Pointer(&allm)))
   593		for mp := first; mp != nil; mp = mp.alllink {
   594			n++
   595		}
   596		if n <= len(p) {
   597			ok = true
   598			i := 0
   599			for mp := first; mp != nil; mp = mp.alllink {
   600				p[i].Stack0 = mp.createstack
   601				i++
   602			}
   603		}
   604		return
   605	}
   606	
   607	// GoroutineProfile returns n, the number of records in the active goroutine stack profile.
   608	// If len(p) >= n, GoroutineProfile copies the profile into p and returns n, true.
   609	// If len(p) < n, GoroutineProfile does not change p and returns n, false.
   610	//
   611	// Most clients should use the runtime/pprof package instead
   612	// of calling GoroutineProfile directly.
   613	func GoroutineProfile(p []StackRecord) (n int, ok bool) {
   614		gp := getg()
   615	
   616		isOK := func(gp1 *g) bool {
   617			// Checking isSystemGoroutine here makes GoroutineProfile
   618			// consistent with both NumGoroutine and Stack.
   619			return gp1 != gp && readgstatus(gp1) != _Gdead && !isSystemGoroutine(gp1)
   620		}
   621	
   622		stopTheWorld("profile")
   623	
   624		n = 1
   625		for _, gp1 := range allgs {
   626			if isOK(gp1) {
   627				n++
   628			}
   629		}
   630	
   631		if n <= len(p) {
   632			ok = true
   633			r := p
   634	
   635			// Save current goroutine.
   636			sp := getcallersp(unsafe.Pointer(&p))
   637			pc := getcallerpc(unsafe.Pointer(&p))
   638			systemstack(func() {
   639				saveg(pc, sp, gp, &r[0])
   640			})
   641			r = r[1:]
   642	
   643			// Save other goroutines.
   644			for _, gp1 := range allgs {
   645				if isOK(gp1) {
   646					if len(r) == 0 {
   647						// Should be impossible, but better to return a
   648						// truncated profile than to crash the entire process.
   649						break
   650					}
   651					saveg(^uintptr(0), ^uintptr(0), gp1, &r[0])
   652					r = r[1:]
   653				}
   654			}
   655		}
   656	
   657		startTheWorld()
   658	
   659		return n, ok
   660	}
   661	
   662	func saveg(pc, sp uintptr, gp *g, r *StackRecord) {
   663		n := gentraceback(pc, sp, 0, gp, 0, &r.Stack0[0], len(r.Stack0), nil, nil, 0)
   664		if n < len(r.Stack0) {
   665			r.Stack0[n] = 0
   666		}
   667	}
   668	
   669	// Stack formats a stack trace of the calling goroutine into buf
   670	// and returns the number of bytes written to buf.
   671	// If all is true, Stack formats stack traces of all other goroutines
   672	// into buf after the trace for the current goroutine.
   673	func Stack(buf []byte, all bool) int {
   674		if all {
   675			stopTheWorld("stack trace")
   676		}
   677	
   678		n := 0
   679		if len(buf) > 0 {
   680			gp := getg()
   681			sp := getcallersp(unsafe.Pointer(&buf))
   682			pc := getcallerpc(unsafe.Pointer(&buf))
   683			systemstack(func() {
   684				g0 := getg()
   685				// Force traceback=1 to override GOTRACEBACK setting,
   686				// so that Stack's results are consistent.
   687				// GOTRACEBACK is only about crash dumps.
   688				g0.m.traceback = 1
   689				g0.writebuf = buf[0:0:len(buf)]
   690				goroutineheader(gp)
   691				traceback(pc, sp, 0, gp)
   692				if all {
   693					tracebackothers(gp)
   694				}
   695				g0.m.traceback = 0
   696				n = len(g0.writebuf)
   697				g0.writebuf = nil
   698			})
   699		}
   700	
   701		if all {
   702			startTheWorld()
   703		}
   704		return n
   705	}
   706	
   707	// Tracing of alloc/free/gc.
   708	
   709	var tracelock mutex
   710	
   711	func tracealloc(p unsafe.Pointer, size uintptr, typ *_type) {
   712		lock(&tracelock)
   713		gp := getg()
   714		gp.m.traceback = 2
   715		if typ == nil {
   716			print("tracealloc(", p, ", ", hex(size), ")\n")
   717		} else {
   718			print("tracealloc(", p, ", ", hex(size), ", ", typ.string(), ")\n")
   719		}
   720		if gp.m.curg == nil || gp == gp.m.curg {
   721			goroutineheader(gp)
   722			pc := getcallerpc(unsafe.Pointer(&p))
   723			sp := getcallersp(unsafe.Pointer(&p))
   724			systemstack(func() {
   725				traceback(pc, sp, 0, gp)
   726			})
   727		} else {
   728			goroutineheader(gp.m.curg)
   729			traceback(^uintptr(0), ^uintptr(0), 0, gp.m.curg)
   730		}
   731		print("\n")
   732		gp.m.traceback = 0
   733		unlock(&tracelock)
   734	}
   735	
   736	func tracefree(p unsafe.Pointer, size uintptr) {
   737		lock(&tracelock)
   738		gp := getg()
   739		gp.m.traceback = 2
   740		print("tracefree(", p, ", ", hex(size), ")\n")
   741		goroutineheader(gp)
   742		pc := getcallerpc(unsafe.Pointer(&p))
   743		sp := getcallersp(unsafe.Pointer(&p))
   744		systemstack(func() {
   745			traceback(pc, sp, 0, gp)
   746		})
   747		print("\n")
   748		gp.m.traceback = 0
   749		unlock(&tracelock)
   750	}
   751	
   752	func tracegc() {
   753		lock(&tracelock)
   754		gp := getg()
   755		gp.m.traceback = 2
   756		print("tracegc()\n")
   757		// running on m->g0 stack; show all non-g0 goroutines
   758		tracebackothers(gp)
   759		print("end tracegc\n")
   760		print("\n")
   761		gp.m.traceback = 0
   762		unlock(&tracelock)
   763	}
   764	

View as plain text