// Accept4 wraps syscall.Accept4. func (sw *Switch) Accept4(s, flags int) (ns int, sa syscall.Sockaddr, err error) { so := sw.sockso(s) if so == nil { return syscall.Accept4(s, flags) } sw.fmu.RLock() f, _ := sw.fltab[FilterAccept] sw.fmu.RUnlock() af, err := f.apply(so) if err != nil { return -1, nil, err } ns, sa, so.Err = syscall.Accept4(s, flags) if err = af.apply(so); err != nil { if so.Err == nil { syscall.Close(ns) } return -1, nil, err } sw.smu.Lock() defer sw.smu.Unlock() if so.Err != nil { sw.stats.getLocked(so.Cookie).AcceptFailed++ return -1, nil, so.Err } nso := sw.addLocked(ns, so.Cookie.Family(), so.Cookie.Type(), so.Cookie.Protocol()) sw.stats.getLocked(nso.Cookie).Accepted++ return ns, sa, nil }
// Wrapper around the accept system call that marks the returned file // descriptor as nonblocking and close-on-exec. func accept(fd int) (int, syscall.Sockaddr, error) { nfd, sa, err := syscall.Accept4(fd, syscall.SOCK_NONBLOCK|syscall.SOCK_CLOEXEC) // The accept4 system call was introduced in Linux 2.6.28. If // we get an ENOSYS error, fall back to using accept. if err == nil || err != syscall.ENOSYS { return nfd, sa, err } // See ../syscall/exec_unix.go for description of ForkLock. // It is probably okay to hold the lock across syscall.Accept // because we have put fd.sysfd into non-blocking mode. // However, a call to the File method will put it back into // blocking mode. We can't take that risk, so no use of ForkLock here. nfd, sa, err = syscall.Accept(fd) if err == nil { syscall.CloseOnExec(nfd) } if err != nil { return -1, nil, err } if err = syscall.SetNonblock(nfd, true); err != nil { syscall.Close(nfd) return -1, nil, err } return nfd, sa, nil }
// Wrapper around the accept system call that marks the returned file // descriptor as nonblocking and close-on-exec. func accept(s int) (int, syscall.Sockaddr, error) { ns, sa, err := syscall.Accept4(s, syscall.SOCK_NONBLOCK|syscall.SOCK_CLOEXEC) // On Linux the accept4 system call was introduced in 2.6.28 // kernel and on FreeBSD it was introduced in 10 kernel. If we // get an ENOSYS error on both Linux and FreeBSD, or EINVAL // error on Linux, fall back to using accept. if err == nil || (err != syscall.ENOSYS && err != syscall.EINVAL) { return ns, sa, err } // See ../syscall/exec_unix.go for description of ForkLock. // It is probably okay to hold the lock across syscall.Accept // because we have put fd.sysfd into non-blocking mode. // However, a call to the File method will put it back into // blocking mode. We can't take that risk, so no use of ForkLock here. ns, sa, err = syscall.Accept(s) if err == nil { syscall.CloseOnExec(ns) } if err != nil { return -1, nil, err } if err = syscall.SetNonblock(ns, true); err != nil { syscall.Close(ns) return -1, nil, err } return ns, sa, nil }
// Wrapper around the accept system call that marks the returned file // descriptor as nonblocking and close-on-exec. func accept(fd int) (int, syscall.Sockaddr, error) { nfd, sa, err := syscall.Accept4(fd, syscall.SOCK_NONBLOCK|syscall.SOCK_CLOEXEC) // The accept4 system call was introduced in Linux 2.6.28. If // we get an ENOSYS error, fall back to using accept. if err == nil || err != syscall.ENOSYS { return nfd, sa, err } // See ../syscall/exec_unix.go for description of ForkLock. // It is okay to hold the lock across syscall.Accept // because we have put fd.sysfd into non-blocking mode. syscall.ForkLock.RLock() nfd, sa, err = syscall.Accept(fd) if err == nil { syscall.CloseOnExec(nfd) } syscall.ForkLock.RUnlock() if err != nil { return -1, nil, err } if err = syscall.SetNonblock(nfd, true); err != nil { syscall.Close(nfd) return -1, nil, err } return nfd, sa, nil }