恐慌与恢复 - panic/recover #

func main() {
    recover()
    panic("it is panic") // not recover
}

func main() {
    defer func() {
        recover()
    }()

    panic("it is panic") // recover
}

func main() {
	defer recover()
	panic("it is panic") // not recover
}

func main() {
    defer func() {
        defer recover()
    }()

    panic("it is panic") // recover
}

func main() {
	defer func() {
		defer func() {
			recover()
		}()
	}()

	panic("it is panic") // not recover
}

func main() {
	defer doRecover()
	panic("it is panic") // recover
}

func doRecover() {
	recover()
	fmt.Println("hello")
}

func main() {
	defer doRecover()
	panic("it is panic") // recover
}

func doRecover() {
	defer recover()
}

func gopanic(e interface{}) {
	gp := getg()
	
	... // 一些判断当前g是否允许在用户栈，是否正在内存分配的代码，略
	
	var p _panic // panic底层数据结构是_panic
	p.arg = e // e是panic函数的参数，对应case2中的: it is panic
	p.link = gp._panic
	gp._panic = (*_panic)(noescape(unsafe.Pointer(&p))) // 将当前panic挂到g上面

	atomic.Xadd(&runningPanicDefers, 1) // 记录正在执行panic的goroutine数量，防止main groutine返回时候，
	// 其他goroutine的panic栈信息未打印出来。@see https://github.com/golang/go/blob/go1.14.13/src/runtime/proc.go#L208-L220

	
	// 对于open-coded defer实现的延迟函数，需要扫描FUNCDATA_OpenCodedDeferInfo信息，
	// 获取延迟函数的sp/pc信息，并创建_defer结构，将其插入gp._defer链表中
	// 这是也是在defer函数章节中，提到的为啥open-coded defer提升了延迟函数的性能，而panic性能却降低的原因
	addOneOpenDeferFrame(gp, getcallerpc(), unsafe.Pointer(getcallersp()))

	for { // 开始遍历defer链表
		d := gp._defer
		if d == nil {
			break
		}

	
		// 当延迟函数里面再次抛出panic或者调用runtime.Goexit时候，
		// 会再次进入同一个延迟函数，此时d.started已经设置为true状态
		if d.started {
			if d._panic != nil { // 标记上一个_panic状态为aborted
				d._panic.aborted = true
			}
			d._panic = nil
			if !d.openDefer {
				// 对于非open-coded defer函数，我们需要将_defer从gp._defer链表中溢出去，防止继续重复执行
				d.fn = nil
				gp._defer = d.link
				freedefer(d)
				continue
			}
		}

	
		// 标记当前defer开始执行，这样当g栈增长时候或者垃圾回收时候，可以更新defer的参数栈帧
		d.started = true

		// 记录当前的_panic信息到_defer结构中，这样当该defer函数再次发生panic时候，可以标记d._panic为aborted状态
		d._panic = (*_panic)(noescape(unsafe.Pointer(&p)))

		done := true
		if d.openDefer { // 如果该延迟函数是open-coded defer函数
			done = runOpenDeferFrame(gp, d) // 运行open-coded defer函数，如果当前栈下面没有其他延迟函数，则返回true
			if done && !d._panic.recovered { // 如果当前栈下面没有其他open-coded defer函数了，且panic也未recover，
			// 那么继续当前的open-coded defer函数的sp作为基址，继续扫描funcdata，获取open-coded defer函数。
			// 之所以这么做是因为open-coded defer里面也存在defer函数的情况，例如case4
				addOneOpenDeferFrame(gp, 0, nil)
			}
		} else {// 非open-coded defer实现的defer函数

			// getargp返回其caller的保存callee参数的地址。
			// 之前介绍过了Go语言中函数调用约定，callee的参数存储，是由caller的栈空间提供。
			p.argp = unsafe.Pointer(getargp(0)) // 这里面p.argp保存的gopanic函数作为caller时候，保存callee参数的地址。
			// 之所以要_panic.argp保存gopanic的callee参数地址，
			// 这是因为调用gorecover会通过此检查其caller的caller是不是gopanic。
			// 这也是case5等不能捕获panic异常的原因。

			// 调用defer函数
			reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz))
		}
		p.argp = nil

		// reflectcall did not panic. Remove d.
		if gp._defer != d {
			throw("bad defer entry in panic")
		}
		d._panic = nil

		pc := d.pc
		sp := unsafe.Pointer(d.sp)
		if done { // 从gp._defer链表清除掉当前defer函数
			d.fn = nil
			gp._defer = d.link
			freedefer(d)
		}
		if p.recovered {
			gp._panic = p.link
			if gp._panic != nil && gp._panic.goexit && gp._panic.aborted {
				// A normal recover would bypass/abort the Goexit.  Instead,
				// we return to the processing loop of the Goexit.
				gp.sigcode0 = uintptr(gp._panic.sp)
				gp.sigcode1 = uintptr(gp._panic.pc)
				mcall(recovery)
				throw("bypassed recovery failed") // mcall should not return
			}
			atomic.Xadd(&runningPanicDefers, -1)

			if done { // panic已经被recover处理掉了，那么移除掉上面通过addOneOpenDeferFrame添加到gp._defer中的open-coded defer函数。
			// 因为这些open-coded defer是通过inline方式执行的，从gp._defer链表中移除掉，不影响它们继续的执行
				d := gp._defer
				var prev *_defer
				for d != nil {
					if d.openDefer {
						if d.started {
							break
						}
						if prev == nil {
							gp._defer = d.link
						} else {
							prev.link = d.link
						}
						newd := d.link
						freedefer(d)
						d = newd
					} else {
						prev = d
						d = d.link
					}
				}
			}

			gp._panic = p.link // 无用代码，上面已经操作过了
			// Aborted panics are marked but remain on the g.panic list.
			// Remove them from the list.
			for gp._panic != nil && gp._panic.aborted {
				gp._panic = gp._panic.link
			}
			if gp._panic == nil { // must be done with signal
				gp.sig = 0
			}
			// Pass information about recovering frame to recovery.
			gp.sigcode0 = uintptr(sp)
			gp.sigcode1 = pc
			mcall(recovery)
			throw("recovery failed") // mcall should not return
		}
	}

	preprintpanics(gp._panic)

	fatalpanic(gp._panic) // should not return
	*(*int)(nil) = 0      // not reached
}

func gorecover(argp uintptr) interface{} {
	gp := getg()
	p := gp._panic
	if p != nil && !p.goexit && !p.recovered && argp == uintptr(p.argp) {
		p.recovered = true
		return p.arg
	}
	return nil
}