深入剖析 Golang 程序启动原理 - 从 ELF 入口点到GMP初始化到执行 main！

package main
import "fmt"
func main() {
 fmt.Println("Hello World!")
}

# go build main.go
# ./main
Hello World!

$ readelf --file-header main
ELF Header:
 ......
 Entry point address:               0x45c220

nm -n main | grep 45c220
000000000045c220 T _rt0_amd64_linux

// file:asm_amd64.s
// _rt0_amd64 is common startup code for most amd64 systems when using
// internal linking.
TEXT _rt0_amd64(SB),NOSPLIT,$-8
	MOVQ	0(SP), DI	// argc
	LEAQ	8(SP), SI	// argv
	JMP	runtime·rt0_go(SB)

// file:runtime/asm_amd64.s
TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
	......

	// 2.1 Golang 核心初始化过程
	CALL	runtime·osinit(SB)
	CALL	runtime·schedinit(SB)


	//2.2 调用 runtime·newproc 创建一个协程
	//    并将 runtime.main 函数作为入口
	MOVQ	$runtime·mainPC(SB), AX		// entry
	PUSHQ	AX
	CALL	runtime·newproc(SB)
	POPQ	AX

	//2.3 启动线程，启动调度系统
	CALL	runtime·mstart(SB)

// file:os_linux.go
func osinit() {
 ncpu = getproccount()
 physHugePageSize = getHugePageSize()
 osArchInit()
}

// file:runtime/proc.go
// The bootstrap sequence is:
//
// call osinit
// call schedinit
// make & queue new G
// call runtime·mstart
//
// The new G calls runtime·main.
func schedinit() {
 ......

 // 默认情况下 procs 等于 cpu 个数
 // 如果设置了 GOMAXPROCS 则以这个为准
 procs := ncpu
 if n, ok := atoi32(gogetenv("GOMAXPROCS")); ok && n > 0 {
  procs = n
 }

 // 分配 procs 个 P
 if procresize(procs) != nil {
  throw("unknown runnable goroutine during bootstrap")
 }

 ......
} 

// file:runtime/proc.go
// Change number of processors
// Returns list of Ps with local work, they need to be scheduled by the caller
func procresize(nprocs int32) *p {

 // 申请存储 P 的数组
 if nprocs > int32(len(allp)) {
  allp = ...
 }

 // 对新 P 进行内存分配和初始化，并保存到 allp 数组中
 for i := old; i < nprocs; i++ {
  pp := allp[i]
  if pp == nil {
   pp = new(p)
  }
  pp.init(i)
  atomicstorep(unsafe.Pointer(&allp[i]), unsafe.Pointer(pp))
 }
 ...
}

//file:runtime/proc.go
func newproc(fn *funcval) {
  ...
  systemstack(func() {
  newg := newproc1(fn, gp, pc)

  _p_ := getg().m.p.ptr()
  runqput(_p_, newg, true)

  if mainStarted {
   wakep()
  }
 })
}

// file:runtime/proc.go
func newproc1(fn *funcval, callergp *g, callerpc uintptr) *g {
 ...
 //从缓存中获取或者创建 G 对象
 newg := gfget(_p_)
 if newg == nil {
  newg = malg(_StackMin)
  ...
 }

 newg.sched.sp = sp
 newg.stktopsp = sp
 ...
 newg.startpc = fn.fn
 ...
 return newg
}

// file:runtime/proc.go
func malg(stacksize int32) *g {
 newg := new(g)
 if stacksize >= 0 {
  //这里会在 stacksize 的基础上为每个栈预留系统调用所需的内存大小 \_StackSystem
  //在 Linux/Darwin 上（ \_StackSystem == 0 ）本行不改变 stacksize 的大小
  stacksize = round2(_StackSystem + stacksize)
 }
 // 切换到 G0 为 newg 初始化栈内存
 systemstack(func() {
   newg.stack = stackalloc(uint32(stacksize))
  })

 // 设置 stackguard0 ，用来判断是否要进行栈扩容 
 newg.stackguard0 = newg.stack.lo + _StackGuard
 newg.stackguard1 = ^uintptr(0)
} 

//file:runtime/stack.go
func stackalloc(n uint32) stack {
 thisg := getg()
 ...
 //对齐到整数页
 n = uint32(alignUp(uintptr(n), physPageSize))
 v := sysAlloc(uintptr(n), &memstats.stacks_sys)
 return stack{uintptr(v), uintptr(v) + uintptr(n)}
}

//file:runtime/runtime2.go
type stack struct {
 lo uintptr
 hi uintptr
}

// file:runtime/mem_darwin.go
func sysAlloc(n uintptr, sysStat *sysMemStat) unsafe.Pointer {
 v, err := mmap(nil, n, _PROT_READ|_PROT_WRITE, _MAP_ANON|_MAP_PRIVATE, -1, 0)
 if err != 0 {
  return nil
 }
 sysStat.add(int64(n))
 return v
}

// file:runtime/proc.go
// runqput tries to put g on the local runnable queue.
// If next is false, runqput adds g to the tail of the runnable queue.
// If next is true, runqput puts g in the _p_.runnext slot.
// If the run queue is full, runnext puts g on the global queue.
// Executed only by the owner P.
func runqput(_p_ *p, gp *g, next bool) {
 ...

 //将新 goroutine 添加到 P 的 runnext 中
 if next {
 retryNext:
  oldnext := _p_.runnext
  if !_p_.runnext.cas(oldnext, guintptr(unsafe.Pointer(gp))) {
   goto retryNext
  }
  if oldnext == 0 {
   return
  }
  // 将原来的 runnext 添加到运行队列中
  gp = oldnext.ptr()
 }

 //将新协程或者被从 runnext 上踢下来的协程添加到运行队列中
retry:
 h := atomic.LoadAcq(&_p_.runqhead) // load-acquire, synchronize with consumers
 t := _p_.runqtail

 //如果 P 的运行队列没满，那就添加到尾部
 if t-h < uint32(len(_p_.runq)) {
  _p_.runq[t%uint32(len(_p_.runq))].set(gp)
  atomic.StoreRel(&_p_.runqtail, t+1) // store-release, makes the item available for consumption
  return
 }

 //如果满了，就添加到全局运行队列中
 if runqputslow(_p_, gp, h, t) {
  return
 }
}

// file:runtime/proc.go
func wakep() {
 ...
 startm(nil, true)
}

// file:runtime/proc.go
// Schedules some M to run the p (creates an M if necessary).
func startm(_p_ *p, spinning bool) {
 mp := acquirem()

 //如果没有传入 p，就获取一个 idel p
 if _p_ == nil {
  _p_ = pidleget()
 }

 //再获取一个空闲的 m
 nmp := mget()
 if nmp == nil {
  //如果获取不到，就创建一个出来
  newm(fn, _p_, id)
  ...
  return
 }

 ...
}

// file:runtime/proc.go
func mstart0() {
 ...
 mstart1()
}

// file:runtime/proc.go
func mstart1() {
 ...
 // 进入调度循环
 schedule()
}

// file:runtime/proc.go
func schedule() {
 _g_ := getg()
 ...
top:
 pp := _g_.m.p.ptr()

 //每 61 次从全局运行队列中获取可运行的协程
 if gp == nil {
  if _g_.m.p.ptr().schedtick%61 == 0 && sched.runqsize > 0 {
   lock(&sched.lock)
   gp = globrunqget(_g_.m.p.ptr(), 1)
   unlock(&sched.lock)
  }
 }

 if gp == nil {
  //从当前 P 的运行队列中获取可运行
  gp, inheritTime = runqget(_g_.m.p.ptr())
 }

 if gp == nil {
  //当前P或者全局队列中获取可运行协程
  //尝试从其它P中steal任务来处理
  //如果获取不到，就阻塞
  gp, inheritTime = findrunnable() // blocks until work is available
 }

//执行协程
 execute(gp, inheritTime) 
}

// file:runtime/proc.go
// The main goroutine.
func main() {
 g := getg()

 // 在系统栈上运行 sysmon
 systemstack(func() {
  newm(sysmon, nil, -1)
 })

 // runtime 内部 init 函数的执行，编译器动态生成的。
 doInit(&runtime_inittask) // Must be before defer.

 // gc 启动一个goroutine进行gc清扫
 gcenable()

 // 执行main init
 doInit(&main_inittask)

 // 执行用户main
 fn := main_main // make an indirect call, as the linker doesn't know the address of the main package when laying down the runtime
 fn()

 // 退出程序
 exit(0)
}