詳解go中panic源碼解讀

package main

import "fmt"

func main() {
	fmt.Println(1)
	func() {
		fmt.Println(2)
		panic("3")
	}()
	fmt.Println(4)
}

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println(1)

	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()

	go func() {
		fmt.Println(2)
		panic("3")
	}()
	time.Sleep(time.Second)
	fmt.Println(4)
}

func main() {
	defer fmt.Println("in main")
	defer func() {
		defer func() {
			panic("3 panic again and again")
		}()
		panic("2 panic again")
	}()

	panic("1 panic once")
}

// _panic 保存了一個活躍的 panic
//
// 這個標(biāo)記了 go:notinheap 因為 _panic 的值必須位于棧上
//
// argp 和 link 字段為棧指針，但在棧增長時不需要特殊處理：因為他們是指針類型且
// _panic 值只位于棧上，正常的棧指針調(diào)整會處理他們。
//
//go:notinheap
type _panic struct {
	argp      unsafe.Pointer // panic 期間 defer 調(diào)用參數(shù)的指針; 無法移動 - liblink 已知
	arg       interface{}    // panic的參數(shù)
	link      *_panic        // link 鏈接到更早的 panic
	recovered bool           // panic是否結(jié)束
	aborted   bool           // panic是否被忽略
}

// 預(yù)先聲明的函數(shù) panic 的實現(xiàn)
func gopanic(e interface{}) {
	gp := getg()
	// 判斷在系統(tǒng)棧上還是在用戶棧上
	// 如果執(zhí)行在系統(tǒng)或信號棧時，getg() 會返回當(dāng)前 m 的 g0 或 gsignal
	// 因此可以通過 gp.m.curg == gp 來判斷所在棧
	// 系統(tǒng)棧上的 panic 無法恢復(fù)
	if gp.m.curg != gp {
		print("panic: ")
		printany(e)
		print("\n")
		throw("panic on system stack")
	}
	// 如果正在進(jìn)行 malloc 時發(fā)生 panic 也無法恢復(fù)
	if gp.m.mallocing != 0 {
		print("panic: ")
		printany(e)
		print("\n")
		throw("panic during malloc")
	}
	// 在禁止搶占時發(fā)生 panic 也無法恢復(fù)
	if gp.m.preemptoff != "" {
		print("panic: ")
		printany(e)
		print("\n")
		print("preempt off reason: ")
		print(gp.m.preemptoff)
		print("\n")
		throw("panic during preemptoff")
	}
	// 在 g 鎖在 m 上時發(fā)生 panic 也無法恢復(fù)
	if gp.m.locks != 0 {
		print("panic: ")
		printany(e)
		print("\n")
		throw("panic holding locks")
	}

	// 下面是可以恢復(fù)的
	var p _panic
	p.arg = e
	// panic 保存了對應(yīng)的消息，并指向了保存在 goroutine 鏈表中先前的 panic 鏈表
	p.link = gp._panic
	gp._panic = (*_panic)(noescape(unsafe.Pointer(p)))

	atomic.Xadd(runningPanicDefers, 1)

	for {
		// 開始逐個取當(dāng)前 goroutine 的 defer 調(diào)用
		d := gp._defer
		// 沒有defer，退出循環(huán)
		if d == nil {
			break
		}

		// 如果 defer 是由早期的 panic 或 Goexit 開始的（并且，因為我們回到這里，這引發(fā)了新的 panic），
		// 則將 defer 帶離鏈表。更早的 panic 或 Goexit 將無法繼續(xù)運(yùn)行。
		if d.started {
			if d._panic != nil {
				d._panic.aborted = true
			}
			d._panic = nil
			d.fn = nil
			gp._defer = d.link
			freedefer(d)
			continue
		}

		// 將deferred標(biāo)記為started
		// 如果棧增長或者垃圾回收在 reflectcall 開始執(zhí)行 d.fn 前發(fā)生
		// 標(biāo)記 defer 已經(jīng)開始執(zhí)行，但仍將其保存在列表中，從而 traceback 可以找到并更新這個 defer 的參數(shù)幀

		// 標(biāo)記defer是否已經(jīng)執(zhí)行
		d.started = true

		// 記錄正在運(yùn)行的延遲的panic。
		// 如果在延遲調(diào)用期間有新的panic，那么這個panic
		// 將在列表中找到d，并將標(biāo)記d._panic(此panic)中止。
		d._panic = (*_panic)(noescape(unsafe.Pointer(p)))

		p.argp = unsafe.Pointer(getargp(0))

		reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz))
		p.argp = nil

		// reflectcall沒有panic。刪除d
		if gp._defer != d {
			throw("bad defer entry in panic")
		}
		d._panic = nil
		d.fn = nil
		gp._defer = d.link

		// trigger shrinkage to test stack copy. See stack_test.go:TestStackPanic
		//GC()

		pc := d.pc
		sp := unsafe.Pointer(d.sp) // must be pointer so it gets adjusted during stack copy
		freedefer(d)
		if p.recovered {
			atomic.Xadd(runningPanicDefers, -1)

			gp._panic = p.link
			// 忽略的 panic 會被標(biāo)記，但仍然保留在 g.panic 列表中
			// 這里將它們移出列表
			for gp._panic != nil  gp._panic.aborted {
				gp._panic = gp._panic.link
			}
			if gp._panic == nil { // 必須由 signal 完成
				gp.sig = 0
			}
			// 傳遞關(guān)于恢復(fù)幀的信息
			gp.sigcode0 = uintptr(sp)
			gp.sigcode1 = pc
			// 調(diào)用 recover，并重新進(jìn)入調(diào)度循環(huán)，不再返回
			mcall(recovery)
			// 如果無法重新進(jìn)入調(diào)度循環(huán)，則無法恢復(fù)錯誤
			throw("recovery failed") // mcall should not return
		}
	}

	// 消耗完所有的 defer 調(diào)用，保守地進(jìn)行 panic
	// 因為在凍結(jié)之后調(diào)用任意用戶代碼是不安全的，所以我們調(diào)用 preprintpanics 來調(diào)用
	// 所有必要的 Error 和 String 方法來在 startpanic 之前準(zhǔn)備 panic 字符串。
	preprintpanics(gp._panic)

	fatalpanic(gp._panic) // 不應(yīng)該返回
	*(*int)(nil) = 0      // 無法觸及
}

// reflectcall 使用 arg 指向的 n 個參數(shù)字節(jié)的副本調(diào)用 fn。
// fn 返回后，reflectcall 在返回之前將 n-retoffset 結(jié)果字節(jié)復(fù)制回 arg+retoffset。
// 如果重新復(fù)制結(jié)果字節(jié)，則調(diào)用者應(yīng)將參數(shù)幀類型作為 argtype 傳遞，以便該調(diào)用可以在復(fù)制期間執(zhí)行適當(dāng)?shù)膶懻系K。
// reflect 包傳遞幀類型。在 runtime 包中，只有一個調(diào)用將結(jié)果復(fù)制回來，即 cgocallbackg1，
// 并且它不傳遞幀類型，這意味著沒有調(diào)用寫障礙。參見該調(diào)用的頁面了解相關(guān)理由。
//
// 包 reflect 通過 linkname 訪問此符號
func reflectcall(argtype *_type, fn, arg unsafe.Pointer, argsize uint32, retoffset uint32)

// 在發(fā)生 panic 后 defer 函數(shù)調(diào)用 recover 后展開棧。然后安排繼續(xù)運(yùn)行，
// 就像 defer 函數(shù)的調(diào)用方正常返回一樣。
func recovery(gp *g) {
	// Info about defer passed in G struct.
	sp := gp.sigcode0
	pc := gp.sigcode1

	// d's arguments need to be in the stack.
	if sp != 0  (sp  gp.stack.lo || gp.stack.hi  sp) {
		print("recover: ", hex(sp), " not in [", hex(gp.stack.lo), ", ", hex(gp.stack.hi), "]\n")
		throw("bad recovery")
	}

	// 使 deferproc 為此 d 返回
	// 這時候返回 1。調(diào)用函數(shù)將跳轉(zhuǎn)到標(biāo)準(zhǔn)的返回尾聲
	gp.sched.sp = sp
	gp.sched.pc = pc
	gp.sched.lr = 0
	gp.sched.ret = 1
	gogo(gp.sched)
}

func deferproc(siz int32, fn *funcval) { // arguments of fn follow fn
	...

	// deferproc returns 0 normally.
	// a deferred func that stops a panic
	// makes the deferproc return 1.
	// the code the compiler generates always
	// checks the return value and jumps to the
	// end of the function if deferproc returns != 0.
	return0()
	// No code can go here - the C return register has
	// been set and must not be clobbered.
}

// go/src/runtime/panic.go
// 執(zhí)行預(yù)先聲明的函數(shù) recover。
// 不允許分段棧，因為它需要可靠地找到其調(diào)用者的棧段。
//
// TODO(rsc): Once we commit to CopyStackAlways,
// this doesn't need to be nosplit.
//go:nosplit
func gorecover(argp uintptr) interface{} {
	// 必須在 panic 期間作為 defer 調(diào)用的一部分在函數(shù)中運(yùn)行。
	// 必須從調(diào)用的最頂層函數(shù)（ defer 語句中使用的函數(shù)）調(diào)用。
	// p.argp 是最頂層 defer 函數(shù)調(diào)用的參數(shù)指針。
	// 比較調(diào)用方報告的 argp，如果匹配，則調(diào)用者可以恢復(fù)。
	gp := getg()
	p := gp._panic
	if p != nil  !p.recovered  argp == uintptr(p.argp) {
		// 標(biāo)記recovered
		p.recovered = true
		return p.arg
	}
	return nil
}

// go/src/runtime/panic.go
// fatalpanic 實現(xiàn)了不可恢復(fù)的 panic。類似于 fatalthrow，
// 如果 msgs != nil，則 fatalpanic 仍然能夠打印 panic 的消息
// 并在 main 在退出時候減少 runningPanicDeferss
//
//go:nosplit
func fatalpanic(msgs *_panic) {
	// 返回程序計數(shù)寄存器指針
	pc := getcallerpc()
	// 返回堆棧指針
	sp := getcallersp()
	// 返回當(dāng)前G
	gp := getg()
	var docrash bool
	// 切換到系統(tǒng)棧來避免棧增長，如果運(yùn)行時狀態(tài)較差則可能導(dǎo)致更糟糕的事情
	systemstack(func() {
		if startpanic_m()  msgs != nil {
			// 有 panic 消息和 startpanic_m 則可以嘗試打印它們

			// startpanic_m 設(shè)置 panic 會從阻止 main 的退出，
			// 因此現(xiàn)在可以開始減少 runningPanicDefers 了
			atomic.Xadd(runningPanicDefers, -1)

			printpanics(msgs)
		}

		docrash = dopanic_m(gp, pc, sp)
	})

	if docrash {
		// 通過在上述 systemstack 調(diào)用之外崩潰，調(diào)試器在生成回溯時不會混淆。
		// 函數(shù)崩潰標(biāo)記為 nosplit 以避免堆棧增長。
		crash()
	}
	// 從系統(tǒng)推出
	systemstack(func() {
		exit(2)
	})

	*(*int)(nil) = 0 // not reached
}

// 打印出當(dāng)前活動的panic
func printpanics(p *_panic) {
	if p.link != nil {
		printpanics(p.link)
		print("\t")
	}
	print("panic: ")
	printany(p.arg)
	if p.recovered {
		print(" [recovered]")
	}
	print("\n")
}