Source file src/runtime/heapdump.go

Documentation: runtime

		 1  // Copyright 2014 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  // Implementation of runtime/debug.WriteHeapDump. Writes all
		 6  // objects in the heap plus additional info (roots, threads,
		 7  // finalizers, etc.) to a file.
		 8  
		 9  // The format of the dumped file is described at
		10  // https://golang.org/s/go15heapdump.
		11  
		12  package runtime
		13  
		14  import (
		15  	"runtime/internal/sys"
		16  	"unsafe"
		17  )
		18  
		19  //go:linkname runtime_debug_WriteHeapDump runtime/debug.WriteHeapDump
		20  func runtime_debug_WriteHeapDump(fd uintptr) {
		21  	stopTheWorld("write heap dump")
		22  
		23  	// Keep m on this G's stack instead of the system stack.
		24  	// Both readmemstats_m and writeheapdump_m have pretty large
		25  	// peak stack depths and we risk blowing the system stack.
		26  	// This is safe because the world is stopped, so we don't
		27  	// need to worry about anyone shrinking and therefore moving
		28  	// our stack.
		29  	var m MemStats
		30  	systemstack(func() {
		31  		// Call readmemstats_m here instead of deeper in
		32  		// writeheapdump_m because we might blow the system stack
		33  		// otherwise.
		34  		readmemstats_m(&m)
		35  		writeheapdump_m(fd, &m)
		36  	})
		37  
		38  	startTheWorld()
		39  }
		40  
		41  const (
		42  	fieldKindEol			 = 0
		43  	fieldKindPtr			 = 1
		44  	fieldKindIface		 = 2
		45  	fieldKindEface		 = 3
		46  	tagEOF						 = 0
		47  	tagObject					= 1
		48  	tagOtherRoot			 = 2
		49  	tagType						= 3
		50  	tagGoroutine			 = 4
		51  	tagStackFrame			= 5
		52  	tagParams					= 6
		53  	tagFinalizer			 = 7
		54  	tagItab						= 8
		55  	tagOSThread				= 9
		56  	tagMemStats				= 10
		57  	tagQueuedFinalizer = 11
		58  	tagData						= 12
		59  	tagBSS						 = 13
		60  	tagDefer					 = 14
		61  	tagPanic					 = 15
		62  	tagMemProf				 = 16
		63  	tagAllocSample		 = 17
		64  )
		65  
		66  var dumpfd uintptr // fd to write the dump to.
		67  var tmpbuf []byte
		68  
		69  // buffer of pending write data
		70  const (
		71  	bufSize = 4096
		72  )
		73  
		74  var buf [bufSize]byte
		75  var nbuf uintptr
		76  
		77  func dwrite(data unsafe.Pointer, len uintptr) {
		78  	if len == 0 {
		79  		return
		80  	}
		81  	if nbuf+len <= bufSize {
		82  		copy(buf[nbuf:], (*[bufSize]byte)(data)[:len])
		83  		nbuf += len
		84  		return
		85  	}
		86  
		87  	write(dumpfd, unsafe.Pointer(&buf), int32(nbuf))
		88  	if len >= bufSize {
		89  		write(dumpfd, data, int32(len))
		90  		nbuf = 0
		91  	} else {
		92  		copy(buf[:], (*[bufSize]byte)(data)[:len])
		93  		nbuf = len
		94  	}
		95  }
		96  
		97  func dwritebyte(b byte) {
		98  	dwrite(unsafe.Pointer(&b), 1)
		99  }
	 100  
	 101  func flush() {
	 102  	write(dumpfd, unsafe.Pointer(&buf), int32(nbuf))
	 103  	nbuf = 0
	 104  }
	 105  
	 106  // Cache of types that have been serialized already.
	 107  // We use a type's hash field to pick a bucket.
	 108  // Inside a bucket, we keep a list of types that
	 109  // have been serialized so far, most recently used first.
	 110  // Note: when a bucket overflows we may end up
	 111  // serializing a type more than once. That's ok.
	 112  const (
	 113  	typeCacheBuckets = 256
	 114  	typeCacheAssoc	 = 4
	 115  )
	 116  
	 117  type typeCacheBucket struct {
	 118  	t [typeCacheAssoc]*_type
	 119  }
	 120  
	 121  var typecache [typeCacheBuckets]typeCacheBucket
	 122  
	 123  // dump a uint64 in a varint format parseable by encoding/binary
	 124  func dumpint(v uint64) {
	 125  	var buf [10]byte
	 126  	var n int
	 127  	for v >= 0x80 {
	 128  		buf[n] = byte(v | 0x80)
	 129  		n++
	 130  		v >>= 7
	 131  	}
	 132  	buf[n] = byte(v)
	 133  	n++
	 134  	dwrite(unsafe.Pointer(&buf), uintptr(n))
	 135  }
	 136  
	 137  func dumpbool(b bool) {
	 138  	if b {
	 139  		dumpint(1)
	 140  	} else {
	 141  		dumpint(0)
	 142  	}
	 143  }
	 144  
	 145  // dump varint uint64 length followed by memory contents
	 146  func dumpmemrange(data unsafe.Pointer, len uintptr) {
	 147  	dumpint(uint64(len))
	 148  	dwrite(data, len)
	 149  }
	 150  
	 151  func dumpslice(b []byte) {
	 152  	dumpint(uint64(len(b)))
	 153  	if len(b) > 0 {
	 154  		dwrite(unsafe.Pointer(&b[0]), uintptr(len(b)))
	 155  	}
	 156  }
	 157  
	 158  func dumpstr(s string) {
	 159  	sp := stringStructOf(&s)
	 160  	dumpmemrange(sp.str, uintptr(sp.len))
	 161  }
	 162  
	 163  // dump information for a type
	 164  func dumptype(t *_type) {
	 165  	if t == nil {
	 166  		return
	 167  	}
	 168  
	 169  	// If we've definitely serialized the type before,
	 170  	// no need to do it again.
	 171  	b := &typecache[t.hash&(typeCacheBuckets-1)]
	 172  	if t == b.t[0] {
	 173  		return
	 174  	}
	 175  	for i := 1; i < typeCacheAssoc; i++ {
	 176  		if t == b.t[i] {
	 177  			// Move-to-front
	 178  			for j := i; j > 0; j-- {
	 179  				b.t[j] = b.t[j-1]
	 180  			}
	 181  			b.t[0] = t
	 182  			return
	 183  		}
	 184  	}
	 185  
	 186  	// Might not have been dumped yet. Dump it and
	 187  	// remember we did so.
	 188  	for j := typeCacheAssoc - 1; j > 0; j-- {
	 189  		b.t[j] = b.t[j-1]
	 190  	}
	 191  	b.t[0] = t
	 192  
	 193  	// dump the type
	 194  	dumpint(tagType)
	 195  	dumpint(uint64(uintptr(unsafe.Pointer(t))))
	 196  	dumpint(uint64(t.size))
	 197  	if x := t.uncommon(); x == nil || t.nameOff(x.pkgpath).name() == "" {
	 198  		dumpstr(t.string())
	 199  	} else {
	 200  		pkgpathstr := t.nameOff(x.pkgpath).name()
	 201  		pkgpath := stringStructOf(&pkgpathstr)
	 202  		namestr := t.name()
	 203  		name := stringStructOf(&namestr)
	 204  		dumpint(uint64(uintptr(pkgpath.len) + 1 + uintptr(name.len)))
	 205  		dwrite(pkgpath.str, uintptr(pkgpath.len))
	 206  		dwritebyte('.')
	 207  		dwrite(name.str, uintptr(name.len))
	 208  	}
	 209  	dumpbool(t.kind&kindDirectIface == 0 || t.ptrdata != 0)
	 210  }
	 211  
	 212  // dump an object
	 213  func dumpobj(obj unsafe.Pointer, size uintptr, bv bitvector) {
	 214  	dumpint(tagObject)
	 215  	dumpint(uint64(uintptr(obj)))
	 216  	dumpmemrange(obj, size)
	 217  	dumpfields(bv)
	 218  }
	 219  
	 220  func dumpotherroot(description string, to unsafe.Pointer) {
	 221  	dumpint(tagOtherRoot)
	 222  	dumpstr(description)
	 223  	dumpint(uint64(uintptr(to)))
	 224  }
	 225  
	 226  func dumpfinalizer(obj unsafe.Pointer, fn *funcval, fint *_type, ot *ptrtype) {
	 227  	dumpint(tagFinalizer)
	 228  	dumpint(uint64(uintptr(obj)))
	 229  	dumpint(uint64(uintptr(unsafe.Pointer(fn))))
	 230  	dumpint(uint64(uintptr(unsafe.Pointer(fn.fn))))
	 231  	dumpint(uint64(uintptr(unsafe.Pointer(fint))))
	 232  	dumpint(uint64(uintptr(unsafe.Pointer(ot))))
	 233  }
	 234  
	 235  type childInfo struct {
	 236  	// Information passed up from the callee frame about
	 237  	// the layout of the outargs region.
	 238  	argoff uintptr	 // where the arguments start in the frame
	 239  	arglen uintptr	 // size of args region
	 240  	args	 bitvector // if args.n >= 0, pointer map of args region
	 241  	sp		 *uint8		// callee sp
	 242  	depth	uintptr	 // depth in call stack (0 == most recent)
	 243  }
	 244  
	 245  // dump kinds & offsets of interesting fields in bv
	 246  func dumpbv(cbv *bitvector, offset uintptr) {
	 247  	for i := uintptr(0); i < uintptr(cbv.n); i++ {
	 248  		if cbv.ptrbit(i) == 1 {
	 249  			dumpint(fieldKindPtr)
	 250  			dumpint(uint64(offset + i*sys.PtrSize))
	 251  		}
	 252  	}
	 253  }
	 254  
	 255  func dumpframe(s *stkframe, arg unsafe.Pointer) bool {
	 256  	child := (*childInfo)(arg)
	 257  	f := s.fn
	 258  
	 259  	// Figure out what we can about our stack map
	 260  	pc := s.pc
	 261  	pcdata := int32(-1) // Use the entry map at function entry
	 262  	if pc != f.entry {
	 263  		pc--
	 264  		pcdata = pcdatavalue(f, _PCDATA_StackMapIndex, pc, nil)
	 265  	}
	 266  	if pcdata == -1 {
	 267  		// We do not have a valid pcdata value but there might be a
	 268  		// stackmap for this function. It is likely that we are looking
	 269  		// at the function prologue, assume so and hope for the best.
	 270  		pcdata = 0
	 271  	}
	 272  	stkmap := (*stackmap)(funcdata(f, _FUNCDATA_LocalsPointerMaps))
	 273  
	 274  	var bv bitvector
	 275  	if stkmap != nil && stkmap.n > 0 {
	 276  		bv = stackmapdata(stkmap, pcdata)
	 277  	} else {
	 278  		bv.n = -1
	 279  	}
	 280  
	 281  	// Dump main body of stack frame.
	 282  	dumpint(tagStackFrame)
	 283  	dumpint(uint64(s.sp))															// lowest address in frame
	 284  	dumpint(uint64(child.depth))											 // # of frames deep on the stack
	 285  	dumpint(uint64(uintptr(unsafe.Pointer(child.sp)))) // sp of child, or 0 if bottom of stack
	 286  	dumpmemrange(unsafe.Pointer(s.sp), s.fp-s.sp)			// frame contents
	 287  	dumpint(uint64(f.entry))
	 288  	dumpint(uint64(s.pc))
	 289  	dumpint(uint64(s.continpc))
	 290  	name := funcname(f)
	 291  	if name == "" {
	 292  		name = "unknown function"
	 293  	}
	 294  	dumpstr(name)
	 295  
	 296  	// Dump fields in the outargs section
	 297  	if child.args.n >= 0 {
	 298  		dumpbv(&child.args, child.argoff)
	 299  	} else {
	 300  		// conservative - everything might be a pointer
	 301  		for off := child.argoff; off < child.argoff+child.arglen; off += sys.PtrSize {
	 302  			dumpint(fieldKindPtr)
	 303  			dumpint(uint64(off))
	 304  		}
	 305  	}
	 306  
	 307  	// Dump fields in the local vars section
	 308  	if stkmap == nil {
	 309  		// No locals information, dump everything.
	 310  		for off := child.arglen; off < s.varp-s.sp; off += sys.PtrSize {
	 311  			dumpint(fieldKindPtr)
	 312  			dumpint(uint64(off))
	 313  		}
	 314  	} else if stkmap.n < 0 {
	 315  		// Locals size information, dump just the locals.
	 316  		size := uintptr(-stkmap.n)
	 317  		for off := s.varp - size - s.sp; off < s.varp-s.sp; off += sys.PtrSize {
	 318  			dumpint(fieldKindPtr)
	 319  			dumpint(uint64(off))
	 320  		}
	 321  	} else if stkmap.n > 0 {
	 322  		// Locals bitmap information, scan just the pointers in
	 323  		// locals.
	 324  		dumpbv(&bv, s.varp-uintptr(bv.n)*sys.PtrSize-s.sp)
	 325  	}
	 326  	dumpint(fieldKindEol)
	 327  
	 328  	// Record arg info for parent.
	 329  	child.argoff = s.argp - s.fp
	 330  	child.arglen = s.arglen
	 331  	child.sp = (*uint8)(unsafe.Pointer(s.sp))
	 332  	child.depth++
	 333  	stkmap = (*stackmap)(funcdata(f, _FUNCDATA_ArgsPointerMaps))
	 334  	if stkmap != nil {
	 335  		child.args = stackmapdata(stkmap, pcdata)
	 336  	} else {
	 337  		child.args.n = -1
	 338  	}
	 339  	return true
	 340  }
	 341  
	 342  func dumpgoroutine(gp *g) {
	 343  	var sp, pc, lr uintptr
	 344  	if gp.syscallsp != 0 {
	 345  		sp = gp.syscallsp
	 346  		pc = gp.syscallpc
	 347  		lr = 0
	 348  	} else {
	 349  		sp = gp.sched.sp
	 350  		pc = gp.sched.pc
	 351  		lr = gp.sched.lr
	 352  	}
	 353  
	 354  	dumpint(tagGoroutine)
	 355  	dumpint(uint64(uintptr(unsafe.Pointer(gp))))
	 356  	dumpint(uint64(sp))
	 357  	dumpint(uint64(gp.goid))
	 358  	dumpint(uint64(gp.gopc))
	 359  	dumpint(uint64(readgstatus(gp)))
	 360  	dumpbool(isSystemGoroutine(gp, false))
	 361  	dumpbool(false) // isbackground
	 362  	dumpint(uint64(gp.waitsince))
	 363  	dumpstr(gp.waitreason.String())
	 364  	dumpint(uint64(uintptr(gp.sched.ctxt)))
	 365  	dumpint(uint64(uintptr(unsafe.Pointer(gp.m))))
	 366  	dumpint(uint64(uintptr(unsafe.Pointer(gp._defer))))
	 367  	dumpint(uint64(uintptr(unsafe.Pointer(gp._panic))))
	 368  
	 369  	// dump stack
	 370  	var child childInfo
	 371  	child.args.n = -1
	 372  	child.arglen = 0
	 373  	child.sp = nil
	 374  	child.depth = 0
	 375  	gentraceback(pc, sp, lr, gp, 0, nil, 0x7fffffff, dumpframe, noescape(unsafe.Pointer(&child)), 0)
	 376  
	 377  	// dump defer & panic records
	 378  	for d := gp._defer; d != nil; d = d.link {
	 379  		dumpint(tagDefer)
	 380  		dumpint(uint64(uintptr(unsafe.Pointer(d))))
	 381  		dumpint(uint64(uintptr(unsafe.Pointer(gp))))
	 382  		dumpint(uint64(d.sp))
	 383  		dumpint(uint64(d.pc))
	 384  		dumpint(uint64(uintptr(unsafe.Pointer(d.fn))))
	 385  		if d.fn == nil {
	 386  			// d.fn can be nil for open-coded defers
	 387  			dumpint(uint64(0))
	 388  		} else {
	 389  			dumpint(uint64(uintptr(unsafe.Pointer(d.fn.fn))))
	 390  		}
	 391  		dumpint(uint64(uintptr(unsafe.Pointer(d.link))))
	 392  	}
	 393  	for p := gp._panic; p != nil; p = p.link {
	 394  		dumpint(tagPanic)
	 395  		dumpint(uint64(uintptr(unsafe.Pointer(p))))
	 396  		dumpint(uint64(uintptr(unsafe.Pointer(gp))))
	 397  		eface := efaceOf(&p.arg)
	 398  		dumpint(uint64(uintptr(unsafe.Pointer(eface._type))))
	 399  		dumpint(uint64(uintptr(unsafe.Pointer(eface.data))))
	 400  		dumpint(0) // was p->defer, no longer recorded
	 401  		dumpint(uint64(uintptr(unsafe.Pointer(p.link))))
	 402  	}
	 403  }
	 404  
	 405  func dumpgs() {
	 406  	assertWorldStopped()
	 407  
	 408  	// goroutines & stacks
	 409  	forEachG(func(gp *g) {
	 410  		status := readgstatus(gp) // The world is stopped so gp will not be in a scan state.
	 411  		switch status {
	 412  		default:
	 413  			print("runtime: unexpected G.status ", hex(status), "\n")
	 414  			throw("dumpgs in STW - bad status")
	 415  		case _Gdead:
	 416  			// ok
	 417  		case _Grunnable,
	 418  			_Gsyscall,
	 419  			_Gwaiting:
	 420  			dumpgoroutine(gp)
	 421  		}
	 422  	})
	 423  }
	 424  
	 425  func finq_callback(fn *funcval, obj unsafe.Pointer, nret uintptr, fint *_type, ot *ptrtype) {
	 426  	dumpint(tagQueuedFinalizer)
	 427  	dumpint(uint64(uintptr(obj)))
	 428  	dumpint(uint64(uintptr(unsafe.Pointer(fn))))
	 429  	dumpint(uint64(uintptr(unsafe.Pointer(fn.fn))))
	 430  	dumpint(uint64(uintptr(unsafe.Pointer(fint))))
	 431  	dumpint(uint64(uintptr(unsafe.Pointer(ot))))
	 432  }
	 433  
	 434  func dumproots() {
	 435  	// To protect mheap_.allspans.
	 436  	assertWorldStopped()
	 437  
	 438  	// TODO(mwhudson): dump datamask etc from all objects
	 439  	// data segment
	 440  	dumpint(tagData)
	 441  	dumpint(uint64(firstmoduledata.data))
	 442  	dumpmemrange(unsafe.Pointer(firstmoduledata.data), firstmoduledata.edata-firstmoduledata.data)
	 443  	dumpfields(firstmoduledata.gcdatamask)
	 444  
	 445  	// bss segment
	 446  	dumpint(tagBSS)
	 447  	dumpint(uint64(firstmoduledata.bss))
	 448  	dumpmemrange(unsafe.Pointer(firstmoduledata.bss), firstmoduledata.ebss-firstmoduledata.bss)
	 449  	dumpfields(firstmoduledata.gcbssmask)
	 450  
	 451  	// mspan.types
	 452  	for _, s := range mheap_.allspans {
	 453  		if s.state.get() == mSpanInUse {
	 454  			// Finalizers
	 455  			for sp := s.specials; sp != nil; sp = sp.next {
	 456  				if sp.kind != _KindSpecialFinalizer {
	 457  					continue
	 458  				}
	 459  				spf := (*specialfinalizer)(unsafe.Pointer(sp))
	 460  				p := unsafe.Pointer(s.base() + uintptr(spf.special.offset))
	 461  				dumpfinalizer(p, spf.fn, spf.fint, spf.ot)
	 462  			}
	 463  		}
	 464  	}
	 465  
	 466  	// Finalizer queue
	 467  	iterate_finq(finq_callback)
	 468  }
	 469  
	 470  // Bit vector of free marks.
	 471  // Needs to be as big as the largest number of objects per span.
	 472  var freemark [_PageSize / 8]bool
	 473  
	 474  func dumpobjs() {
	 475  	// To protect mheap_.allspans.
	 476  	assertWorldStopped()
	 477  
	 478  	for _, s := range mheap_.allspans {
	 479  		if s.state.get() != mSpanInUse {
	 480  			continue
	 481  		}
	 482  		p := s.base()
	 483  		size := s.elemsize
	 484  		n := (s.npages << _PageShift) / size
	 485  		if n > uintptr(len(freemark)) {
	 486  			throw("freemark array doesn't have enough entries")
	 487  		}
	 488  
	 489  		for freeIndex := uintptr(0); freeIndex < s.nelems; freeIndex++ {
	 490  			if s.isFree(freeIndex) {
	 491  				freemark[freeIndex] = true
	 492  			}
	 493  		}
	 494  
	 495  		for j := uintptr(0); j < n; j, p = j+1, p+size {
	 496  			if freemark[j] {
	 497  				freemark[j] = false
	 498  				continue
	 499  			}
	 500  			dumpobj(unsafe.Pointer(p), size, makeheapobjbv(p, size))
	 501  		}
	 502  	}
	 503  }
	 504  
	 505  func dumpparams() {
	 506  	dumpint(tagParams)
	 507  	x := uintptr(1)
	 508  	if *(*byte)(unsafe.Pointer(&x)) == 1 {
	 509  		dumpbool(false) // little-endian ptrs
	 510  	} else {
	 511  		dumpbool(true) // big-endian ptrs
	 512  	}
	 513  	dumpint(sys.PtrSize)
	 514  	var arenaStart, arenaEnd uintptr
	 515  	for i1 := range mheap_.arenas {
	 516  		if mheap_.arenas[i1] == nil {
	 517  			continue
	 518  		}
	 519  		for i, ha := range mheap_.arenas[i1] {
	 520  			if ha == nil {
	 521  				continue
	 522  			}
	 523  			base := arenaBase(arenaIdx(i1)<<arenaL1Shift | arenaIdx(i))
	 524  			if arenaStart == 0 || base < arenaStart {
	 525  				arenaStart = base
	 526  			}
	 527  			if base+heapArenaBytes > arenaEnd {
	 528  				arenaEnd = base + heapArenaBytes
	 529  			}
	 530  		}
	 531  	}
	 532  	dumpint(uint64(arenaStart))
	 533  	dumpint(uint64(arenaEnd))
	 534  	dumpstr(sys.GOARCH)
	 535  	dumpstr(buildVersion)
	 536  	dumpint(uint64(ncpu))
	 537  }
	 538  
	 539  func itab_callback(tab *itab) {
	 540  	t := tab._type
	 541  	dumptype(t)
	 542  	dumpint(tagItab)
	 543  	dumpint(uint64(uintptr(unsafe.Pointer(tab))))
	 544  	dumpint(uint64(uintptr(unsafe.Pointer(t))))
	 545  }
	 546  
	 547  func dumpitabs() {
	 548  	iterate_itabs(itab_callback)
	 549  }
	 550  
	 551  func dumpms() {
	 552  	for mp := allm; mp != nil; mp = mp.alllink {
	 553  		dumpint(tagOSThread)
	 554  		dumpint(uint64(uintptr(unsafe.Pointer(mp))))
	 555  		dumpint(uint64(mp.id))
	 556  		dumpint(mp.procid)
	 557  	}
	 558  }
	 559  
	 560  //go:systemstack
	 561  func dumpmemstats(m *MemStats) {
	 562  	assertWorldStopped()
	 563  
	 564  	// These ints should be identical to the exported
	 565  	// MemStats structure and should be ordered the same
	 566  	// way too.
	 567  	dumpint(tagMemStats)
	 568  	dumpint(m.Alloc)
	 569  	dumpint(m.TotalAlloc)
	 570  	dumpint(m.Sys)
	 571  	dumpint(m.Lookups)
	 572  	dumpint(m.Mallocs)
	 573  	dumpint(m.Frees)
	 574  	dumpint(m.HeapAlloc)
	 575  	dumpint(m.HeapSys)
	 576  	dumpint(m.HeapIdle)
	 577  	dumpint(m.HeapInuse)
	 578  	dumpint(m.HeapReleased)
	 579  	dumpint(m.HeapObjects)
	 580  	dumpint(m.StackInuse)
	 581  	dumpint(m.StackSys)
	 582  	dumpint(m.MSpanInuse)
	 583  	dumpint(m.MSpanSys)
	 584  	dumpint(m.MCacheInuse)
	 585  	dumpint(m.MCacheSys)
	 586  	dumpint(m.BuckHashSys)
	 587  	dumpint(m.GCSys)
	 588  	dumpint(m.OtherSys)
	 589  	dumpint(m.NextGC)
	 590  	dumpint(m.LastGC)
	 591  	dumpint(m.PauseTotalNs)
	 592  	for i := 0; i < 256; i++ {
	 593  		dumpint(m.PauseNs[i])
	 594  	}
	 595  	dumpint(uint64(m.NumGC))
	 596  }
	 597  
	 598  func dumpmemprof_callback(b *bucket, nstk uintptr, pstk *uintptr, size, allocs, frees uintptr) {
	 599  	stk := (*[100000]uintptr)(unsafe.Pointer(pstk))
	 600  	dumpint(tagMemProf)
	 601  	dumpint(uint64(uintptr(unsafe.Pointer(b))))
	 602  	dumpint(uint64(size))
	 603  	dumpint(uint64(nstk))
	 604  	for i := uintptr(0); i < nstk; i++ {
	 605  		pc := stk[i]
	 606  		f := findfunc(pc)
	 607  		if !f.valid() {
	 608  			var buf [64]byte
	 609  			n := len(buf)
	 610  			n--
	 611  			buf[n] = ')'
	 612  			if pc == 0 {
	 613  				n--
	 614  				buf[n] = '0'
	 615  			} else {
	 616  				for pc > 0 {
	 617  					n--
	 618  					buf[n] = "0123456789abcdef"[pc&15]
	 619  					pc >>= 4
	 620  				}
	 621  			}
	 622  			n--
	 623  			buf[n] = 'x'
	 624  			n--
	 625  			buf[n] = '0'
	 626  			n--
	 627  			buf[n] = '('
	 628  			dumpslice(buf[n:])
	 629  			dumpstr("?")
	 630  			dumpint(0)
	 631  		} else {
	 632  			dumpstr(funcname(f))
	 633  			if i > 0 && pc > f.entry {
	 634  				pc--
	 635  			}
	 636  			file, line := funcline(f, pc)
	 637  			dumpstr(file)
	 638  			dumpint(uint64(line))
	 639  		}
	 640  	}
	 641  	dumpint(uint64(allocs))
	 642  	dumpint(uint64(frees))
	 643  }
	 644  
	 645  func dumpmemprof() {
	 646  	// To protect mheap_.allspans.
	 647  	assertWorldStopped()
	 648  
	 649  	iterate_memprof(dumpmemprof_callback)
	 650  	for _, s := range mheap_.allspans {
	 651  		if s.state.get() != mSpanInUse {
	 652  			continue
	 653  		}
	 654  		for sp := s.specials; sp != nil; sp = sp.next {
	 655  			if sp.kind != _KindSpecialProfile {
	 656  				continue
	 657  			}
	 658  			spp := (*specialprofile)(unsafe.Pointer(sp))
	 659  			p := s.base() + uintptr(spp.special.offset)
	 660  			dumpint(tagAllocSample)
	 661  			dumpint(uint64(p))
	 662  			dumpint(uint64(uintptr(unsafe.Pointer(spp.b))))
	 663  		}
	 664  	}
	 665  }
	 666  
	 667  var dumphdr = []byte("go1.7 heap dump\n")
	 668  
	 669  func mdump(m *MemStats) {
	 670  	assertWorldStopped()
	 671  
	 672  	// make sure we're done sweeping
	 673  	for _, s := range mheap_.allspans {
	 674  		if s.state.get() == mSpanInUse {
	 675  			s.ensureSwept()
	 676  		}
	 677  	}
	 678  	memclrNoHeapPointers(unsafe.Pointer(&typecache), unsafe.Sizeof(typecache))
	 679  	dwrite(unsafe.Pointer(&dumphdr[0]), uintptr(len(dumphdr)))
	 680  	dumpparams()
	 681  	dumpitabs()
	 682  	dumpobjs()
	 683  	dumpgs()
	 684  	dumpms()
	 685  	dumproots()
	 686  	dumpmemstats(m)
	 687  	dumpmemprof()
	 688  	dumpint(tagEOF)
	 689  	flush()
	 690  }
	 691  
	 692  func writeheapdump_m(fd uintptr, m *MemStats) {
	 693  	assertWorldStopped()
	 694  
	 695  	_g_ := getg()
	 696  	casgstatus(_g_.m.curg, _Grunning, _Gwaiting)
	 697  	_g_.waitreason = waitReasonDumpingHeap
	 698  
	 699  	// Update stats so we can dump them.
	 700  	// As a side effect, flushes all the mcaches so the mspan.freelist
	 701  	// lists contain all the free objects.
	 702  	updatememstats()
	 703  
	 704  	// Set dump file.
	 705  	dumpfd = fd
	 706  
	 707  	// Call dump routine.
	 708  	mdump(m)
	 709  
	 710  	// Reset dump file.
	 711  	dumpfd = 0
	 712  	if tmpbuf != nil {
	 713  		sysFree(unsafe.Pointer(&tmpbuf[0]), uintptr(len(tmpbuf)), &memstats.other_sys)
	 714  		tmpbuf = nil
	 715  	}
	 716  
	 717  	casgstatus(_g_.m.curg, _Gwaiting, _Grunning)
	 718  }
	 719  
	 720  // dumpint() the kind & offset of each field in an object.
	 721  func dumpfields(bv bitvector) {
	 722  	dumpbv(&bv, 0)
	 723  	dumpint(fieldKindEol)
	 724  }
	 725  
	 726  func makeheapobjbv(p uintptr, size uintptr) bitvector {
	 727  	// Extend the temp buffer if necessary.
	 728  	nptr := size / sys.PtrSize
	 729  	if uintptr(len(tmpbuf)) < nptr/8+1 {
	 730  		if tmpbuf != nil {
	 731  			sysFree(unsafe.Pointer(&tmpbuf[0]), uintptr(len(tmpbuf)), &memstats.other_sys)
	 732  		}
	 733  		n := nptr/8 + 1
	 734  		p := sysAlloc(n, &memstats.other_sys)
	 735  		if p == nil {
	 736  			throw("heapdump: out of memory")
	 737  		}
	 738  		tmpbuf = (*[1 << 30]byte)(p)[:n]
	 739  	}
	 740  	// Convert heap bitmap to pointer bitmap.
	 741  	for i := uintptr(0); i < nptr/8+1; i++ {
	 742  		tmpbuf[i] = 0
	 743  	}
	 744  	i := uintptr(0)
	 745  	hbits := heapBitsForAddr(p)
	 746  	for ; i < nptr; i++ {
	 747  		if !hbits.morePointers() {
	 748  			break // end of object
	 749  		}
	 750  		if hbits.isPointer() {
	 751  			tmpbuf[i/8] |= 1 << (i % 8)
	 752  		}
	 753  		hbits = hbits.next()
	 754  	}
	 755  	return bitvector{int32(i), &tmpbuf[0]}
	 756  }
	 757  

View as plain text