func main() {
   ...

   if GOARCH != "wasm" { // no threads on wasm yet, so no sysmon
       systemstack(func() {
           newm(sysmon, nil) // 모니터링 기능
       })
   }

   // Lock the main goroutine onto this, the main OS thread,
   // during initialization. Most programs won't care, but a few
   // do require certain calls to be made by the main thread.
   // Those can arrange for main.main to run in the main thread
   // by calling runtime.LockOSThread during initialization
   // to preserve the lock.
   lockOSThread()
   ...
}

func sysmon() {
   ...
   for {
      if netpollinited() && lastpoll != 0 && lastpoll+10*1000*1000 < now {
           atomic.Cas64(&sched.lastpoll, uint64(lastpoll), uint64(now))
           gp := netpoll(false) // non-blocking - returns list of goroutines
           if gp != nil {
               // Need to decrement number of idle locked M's
               // (pretending that one more is running) before injectglist.
               // Otherwise it can lead to the following situation:
               // injectglist grabs all P's but before it starts M's to run the P's,
               // another M returns from syscall, finishes running its G,
               // observes that there is no work to do and no other running M's
               // and reports deadlock.
               incidlelocked(-1)
               injectglist(gp)
               incidlelocked(1)
           }
       }
       ...
   }
}

func netpoll(block bool) *g {
   ...
retry:
   n := epollwait(epfd, &events[0], int32(len(events)), waitms)
   ...
}

func main() {
 conn, _ := net.Dial("tcp", "127.0.0.1:8081")
 for {
   reader := bufio.NewReader(os.Stdin)
   fmt.Print("Text to send: ")
   text, _ := reader.ReadString('\n')
   fmt.Fprintf(conn, text + "\n")
   message, _ := bufio.NewReader(conn).ReadString('\n')
   fmt.Print("Message from server: "+message)
 }
}

net/dial.go:341

func (d *Dialer) DialContext(ctx context.Context, network, address string) (Conn, error) {
   ...
   var c Conn
   if len(fallbacks) > 0 {
       c, err = dialParallel(ctx, dp, primaries, fallbacks)
   } else {
       c, err = dialSerial(ctx, dp, primaries)
   }
   ...
}

net/dial.go:489

func dialSerial(ctx context.Context, dp *dialParam, ras addrList) (Conn, error) {
   ...
   c, err := dialSingle(dialCtx, dp, ra)
   ...
}

net/dial.go:532

func dialSingle(ctx context.Context, dp *dialParam, ra Addr) (c Conn, err error) {
   ...
   case *TCPAddr:
       la, _ := la.(*TCPAddr)
       c, err = dialTCP(ctx, dp.network, la, ra)
   ...
}

net/tcpsock_posix.go:61

func doDialTCP(ctx context.Context, net string, laddr, raddr *TCPAddr) (*TCPConn, error) {
   fd, err := internetSocket(ctx, net, laddr, raddr, syscall.SOCK_STREAM, 0, "dial")
   ...
}

net/ipsock_posix.go:136

func internetSocket(ctx context.Context, net string, laddr, raddr sockaddr, sotype, proto int, mode string) (fd *netFD, err error) {
   ...
   return socket(ctx, net, family, sotype, proto, ipv6only, laddr, raddr)
}

net/sock_posix.go:18

func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr) (fd *netFD, err error) {
   ...
   if fd, err = newFD(s, family, sotype, net); err != nil {
       poll.CloseFunc(s)
       return nil, err
   }
   
   if err := fd.dial(ctx, laddr, raddr); err != nil {
       fd.Close()
       return nil, err
   }
   ...
}

func (pd *pollDesc) init(fd *FD) error {
   serverInit.Do(runtime_pollServerInit)
   ctx, errno := runtime_pollOpen(uintptr(fd.Sysfd))
   if errno != 0 {
       if ctx != 0 {
           runtime_pollUnblock(ctx)
           runtime_pollClose(ctx)
       }
       return syscall.Errno(errno)
   }
   pd.runtimeCtx = ctx
   return nil
}

//go:linkname poll_runtime_pollServerInit internal/poll.runtime_pollServerInit
func poll_runtime_pollServerInit() {
   netpollinit()
   atomic.Store(&netpollInited, 1)
}

//go:linkname poll_runtime_pollOpen internal/poll.runtime_pollOpen
func poll_runtime_pollOpen(fd uintptr) (*pollDesc, int) {
   pd := pollcache.alloc()
   lock(&pd.lock)
   if pd.wg != 0 && pd.wg != pdReady {
       throw("runtime: blocked write on free polldesc")
   }
   if pd.rg != 0 && pd.rg != pdReady {
       throw("runtime: blocked read on free polldesc")
   }
   pd.fd = fd
   pd.closing = false
   pd.seq++
   pd.rg = 0
   pd.rd = 0
   pd.wg = 0
   pd.wd = 0
   unlock(&pd.lock)

   var errno int32
   errno = netpollopen(fd, pd)
   return pd, int(errno)
}

func netpollinit() {
   epfd = epollcreate1(_EPOLL_CLOEXEC)
   if epfd >= 0 {
       return
   }
   epfd = epollcreate(1024)
   if epfd >= 0 {
       closeonexec(epfd)
       return
   }
   println("runtime: epollcreate failed with", -epfd)
   throw("runtime: netpollinit failed")
}

func netpollopen(fd uintptr, pd *pollDesc) int32 {
   var ev epollevent
   ev.events = _EPOLLIN | _EPOLLOUT | _EPOLLRDHUP | _EPOLLET
   *(**pollDesc)(unsafe.Pointer(&ev.data)) = pd
   return -epollctl(epfd, _EPOLL_CTL_ADD, int32(fd), &ev)
}