zsh: segmentation fault ./virtualization about vz HOT 12 CLOSED

func NewProxyVSOCK(p *Publish, vso *vz.VirtioSocketDevice, port uint32) func(conn net.Conn) {
	return func(conn net.Conn) {
		klog.Infof("[MAC_OS]prepare to connect to vm port: %d", port)
		onConnect := func(vzconn *vz.VirtioSocketConnection, err error) {
			defer Close(conn, "MAC_OS: unix  --> vsock")
			klog.Infof("[MAC_OS][%s]remote connection to vm established: %s",p,vzconn)
			//defer Close(vzconn, "MAC_OS: vsock --> unix")
		        	
			//stop := make(chan struct{}, 1)
			grp := &sync.WaitGroup{}
			grp.Add(2)
			//go copyStream(grp,vzconn, conn, "MAC_OS: unix  --> vsock",false)

			go func() {
				msg := "MAC_OS: unix  --> vsock"
				defer Close(conn, msg)
				n, err := io.Copy(vzconn, conn)
				if err != nil {
					klog.Errorf("[%s]copy to vm: %d bytes copied, %s",msg, n, err.Error())
				}
				klog.Infof("local conn done")
				grp.Done()
				Close(vzconn,"")
			}()
			//go copyStream(nil,conn, vzconn, "MAC_OS: vsock  --> unix",false)
			go func() {
				msg := "MAC_OS: vsock  --> unix"
				n, err := io.Copy(conn, vzconn)
				if err != nil {
					klog.Errorf("[%s]copy to vm: %d bytes copied, %s",msg, n, err.Error())
				}
				klog.Infof("vzconn: done")
				grp.Done()
			}()
			klog.Infof("[MAC_OS][%s]unix --> vsock started, wait done: ", p)
			grp.Wait()
			klog.Infof("[MAC_OS][%s]receive goroutine sig 1",p)
			//<-closer
		}
		if vso == nil {
			klog.Errorf("[MAC_OS]Attention, nil vso:  [%v]", vso)
		}
		klog.Infof("[MAC_OS] do connect to port")
		vso.ConnectToPort(port, onConnect)

		klog.Infof("[MAC_OS][%s]connection complete: %s",p, conn.RemoteAddr())
	}
}

       vzconn := Connect2Port()
        grp := sync.WaitGroup{}
	grp.Add(1)
	go func() {
		bb := make([]byte,1024)
		n, err := vzconn.Read(bb)
		if err != nil {
			t.Logf("read error: %s", err.Error())
		}
		t.Logf("read %d byte: xxx", n)
		grp.Done()
	}()
	t.Logf("sleep 5s")
	time.Sleep(5*time.Second)

	vzconn.Close()

	t.Logf("sleep 3")
	time.Sleep(3*time.Second)
	t.Logf("wait")
	grp.Wait()
	t.Logf("finishe")

func newVirtioSocketConnection(ptr unsafe.Pointer) *VirtioSocketConnection {
	id := xid.New().String()
	vzVirtioSocketConnection := C.convertVZVirtioSocketConnection2Flat(ptr)
	err := unix.SetNonblock(int(vzVirtioSocketConnection.fileDescriptor), true)
	if err != nil {
		panic(fmt.Sprintf("set nonblock: %s", err.Error()))
	}
	conn := &VirtioSocketConnection{
		id:              id,
		sourcePort:      (uint32)(vzVirtioSocketConnection.sourcePort),
		destinationPort: (uint32)(vzVirtioSocketConnection.destinationPort),
		fileDescriptor:  (uintptr)(vzVirtioSocketConnection.fileDescriptor),
		file:            os.NewFile((uintptr)(vzVirtioSocketConnection.fileDescriptor), id),
		laddr: &Addr{
			CID:  unix.VMADDR_CID_HOST,
			Port: (uint32)(vzVirtioSocketConnection.destinationPort),
		},
		raddr: &Addr{
			CID:  unix.VMADDR_CID_HYPERVISOR,
			Port: (uint32)(vzVirtioSocketConnection.sourcePort),
		},
	}
	return conn
}