From 4d886c102874b3678df370d74d99d84b8ce9ba9b Mon Sep 17 00:00:00 2001 From: Veniamin Albaev Date: Thu, 9 Mar 2017 11:04:34 +0300 Subject: [PATCH] Unix: move from syscall to golang.org/x/sys/unix Prepare to using `unix.TCFLSH`/`unix.TIOCFLUSH` which is missing in `syscall` package --- serial_darwin.go | 6 +- serial_darwin_386.go | 50 +++++++------- serial_darwin_amd64.go | 50 +++++++------- serial_freebsd.go | 58 ++++++++-------- serial_linux.go | 80 +++++++++++----------- serial_unix.go | 149 +++++++++++++++++++++-------------------- zsyscall_darwin.go | 4 +- zsyscall_freebsd.go | 4 +- zsyscall_linux.go | 4 +- 9 files changed, 203 insertions(+), 202 deletions(-) diff --git a/serial_darwin.go b/serial_darwin.go index 13cf862..845b51f 100644 --- a/serial_darwin.go +++ b/serial_darwin.go @@ -6,10 +6,10 @@ package serial // import "go.bug.st/serial.v1" -import "syscall" +import "golang.org/x/sys/unix" const devFolder = "/dev" const regexFilter = "^(cu|tty)\\..*" -const ioctlTcgetattr = syscall.TIOCGETA -const ioctlTcsetattr = syscall.TIOCSETA +const ioctlTcgetattr = unix.TIOCGETA +const ioctlTcsetattr = unix.TIOCSETA diff --git a/serial_darwin_386.go b/serial_darwin_386.go index 4f96df7..4200f26 100644 --- a/serial_darwin_386.go +++ b/serial_darwin_386.go @@ -6,38 +6,38 @@ package serial // import "go.bug.st/serial.v1" -import "syscall" +import "golang.org/x/sys/unix" // termios manipulation functions var baudrateMap = map[int]uint32{ - 0: syscall.B9600, // Default to 9600 - 50: syscall.B50, - 75: syscall.B75, - 110: syscall.B110, - 134: syscall.B134, - 150: syscall.B150, - 200: syscall.B200, - 300: syscall.B300, - 600: syscall.B600, - 1200: syscall.B1200, - 1800: syscall.B1800, - 2400: syscall.B2400, - 4800: syscall.B4800, - 9600: syscall.B9600, - 19200: syscall.B19200, - 38400: syscall.B38400, - 57600: syscall.B57600, - 115200: syscall.B115200, - 230400: syscall.B230400, + 0: unix.B9600, // Default to 9600 + 50: unix.B50, + 75: unix.B75, + 110: unix.B110, + 134: unix.B134, + 150: unix.B150, + 200: unix.B200, + 300: unix.B300, + 600: unix.B600, + 1200: unix.B1200, + 1800: unix.B1800, + 2400: unix.B2400, + 4800: unix.B4800, + 9600: unix.B9600, + 19200: unix.B19200, + 38400: unix.B38400, + 57600: unix.B57600, + 115200: unix.B115200, + 230400: unix.B230400, } var databitsMap = map[int]uint32{ - 0: syscall.CS8, // Default to 8 bits - 5: syscall.CS5, - 6: syscall.CS6, - 7: syscall.CS7, - 8: syscall.CS8, + 0: unix.CS8, // Default to 8 bits + 5: unix.CS5, + 6: unix.CS6, + 7: unix.CS7, + 8: unix.CS8, } const tcCMSPAR uint32 = 0 // may be CMSPAR or PAREXT diff --git a/serial_darwin_amd64.go b/serial_darwin_amd64.go index 6ea59d5..d7109c0 100644 --- a/serial_darwin_amd64.go +++ b/serial_darwin_amd64.go @@ -6,38 +6,38 @@ package serial // import "go.bug.st/serial.v1" -import "syscall" +import "golang.org/x/sys/unix" // termios manipulation functions var baudrateMap = map[int]uint64{ - 0: syscall.B9600, // Default to 9600 - 50: syscall.B50, - 75: syscall.B75, - 110: syscall.B110, - 134: syscall.B134, - 150: syscall.B150, - 200: syscall.B200, - 300: syscall.B300, - 600: syscall.B600, - 1200: syscall.B1200, - 1800: syscall.B1800, - 2400: syscall.B2400, - 4800: syscall.B4800, - 9600: syscall.B9600, - 19200: syscall.B19200, - 38400: syscall.B38400, - 57600: syscall.B57600, - 115200: syscall.B115200, - 230400: syscall.B230400, + 0: unix.B9600, // Default to 9600 + 50: unix.B50, + 75: unix.B75, + 110: unix.B110, + 134: unix.B134, + 150: unix.B150, + 200: unix.B200, + 300: unix.B300, + 600: unix.B600, + 1200: unix.B1200, + 1800: unix.B1800, + 2400: unix.B2400, + 4800: unix.B4800, + 9600: unix.B9600, + 19200: unix.B19200, + 38400: unix.B38400, + 57600: unix.B57600, + 115200: unix.B115200, + 230400: unix.B230400, } var databitsMap = map[int]uint64{ - 0: syscall.CS8, // Default to 8 bits - 5: syscall.CS5, - 6: syscall.CS6, - 7: syscall.CS7, - 8: syscall.CS8, + 0: unix.CS8, // Default to 8 bits + 5: unix.CS5, + 6: unix.CS6, + 7: unix.CS7, + 8: unix.CS8, } const tcCMSPAR uint64 = 0 // may be CMSPAR or PAREXT diff --git a/serial_freebsd.go b/serial_freebsd.go index ae5ff09..0e54166 100644 --- a/serial_freebsd.go +++ b/serial_freebsd.go @@ -6,7 +6,7 @@ package serial // import "go.bug.st/serial.v1" -import "syscall" +import "golang.org/x/sys/unix" const devFolder = "/dev" const regexFilter = "^(cu|tty)\\..*" @@ -14,35 +14,35 @@ const regexFilter = "^(cu|tty)\\..*" // termios manipulation functions var baudrateMap = map[int]uint32{ - 0: syscall.B9600, // Default to 9600 - 50: syscall.B50, - 75: syscall.B75, - 110: syscall.B110, - 134: syscall.B134, - 150: syscall.B150, - 200: syscall.B200, - 300: syscall.B300, - 600: syscall.B600, - 1200: syscall.B1200, - 1800: syscall.B1800, - 2400: syscall.B2400, - 4800: syscall.B4800, - 9600: syscall.B9600, - 19200: syscall.B19200, - 38400: syscall.B38400, - 57600: syscall.B57600, - 115200: syscall.B115200, - 230400: syscall.B230400, - 460800: syscall.B460800, - 921600: syscall.B921600, + 0: unix.B9600, // Default to 9600 + 50: unix.B50, + 75: unix.B75, + 110: unix.B110, + 134: unix.B134, + 150: unix.B150, + 200: unix.B200, + 300: unix.B300, + 600: unix.B600, + 1200: unix.B1200, + 1800: unix.B1800, + 2400: unix.B2400, + 4800: unix.B4800, + 9600: unix.B9600, + 19200: unix.B19200, + 38400: unix.B38400, + 57600: unix.B57600, + 115200: unix.B115200, + 230400: unix.B230400, + 460800: unix.B460800, + 921600: unix.B921600, } var databitsMap = map[int]uint32{ - 0: syscall.CS8, // Default to 8 bits - 5: syscall.CS5, - 6: syscall.CS6, - 7: syscall.CS7, - 8: syscall.CS8, + 0: unix.CS8, // Default to 8 bits + 5: unix.CS5, + 6: unix.CS6, + 7: unix.CS7, + 8: unix.CS8, } const tcCMSPAR uint32 = 0 // may be CMSPAR or PAREXT @@ -53,5 +53,5 @@ const tcCRTS_IFLOW uint32 = 0x00020000 const tcCRTSCTS uint32 = tcCCTS_OFLOW -const ioctlTcgetattr = syscall.TIOCGETA -const ioctlTcsetattr = syscall.TIOCSETA +const ioctlTcgetattr = unix.TIOCGETA +const ioctlTcsetattr = unix.TIOCSETA diff --git a/serial_linux.go b/serial_linux.go index 0ef03b8..b41f25b 100644 --- a/serial_linux.go +++ b/serial_linux.go @@ -6,7 +6,7 @@ package serial // import "go.bug.st/serial.v1" -import "syscall" +import "golang.org/x/sys/unix" const devFolder = "/dev" const regexFilter = "(ttyS|ttyUSB|ttyACM|ttyAMA|rfcomm|ttyO)[0-9]{1,3}" @@ -14,51 +14,51 @@ const regexFilter = "(ttyS|ttyUSB|ttyACM|ttyAMA|rfcomm|ttyO)[0-9]{1,3}" // termios manipulation functions var baudrateMap = map[int]uint32{ - 0: syscall.B9600, // Default to 9600 - 50: syscall.B50, - 75: syscall.B75, - 110: syscall.B110, - 134: syscall.B134, - 150: syscall.B150, - 200: syscall.B200, - 300: syscall.B300, - 600: syscall.B600, - 1200: syscall.B1200, - 1800: syscall.B1800, - 2400: syscall.B2400, - 4800: syscall.B4800, - 9600: syscall.B9600, - 19200: syscall.B19200, - 38400: syscall.B38400, - 57600: syscall.B57600, - 115200: syscall.B115200, - 230400: syscall.B230400, - 460800: syscall.B460800, - 500000: syscall.B500000, - 576000: syscall.B576000, - 921600: syscall.B921600, - 1000000: syscall.B1000000, - 1152000: syscall.B1152000, - 1500000: syscall.B1500000, - 2000000: syscall.B2000000, - 2500000: syscall.B2500000, - 3000000: syscall.B3000000, - 3500000: syscall.B3500000, - 4000000: syscall.B4000000, + 0: unix.B9600, // Default to 9600 + 50: unix.B50, + 75: unix.B75, + 110: unix.B110, + 134: unix.B134, + 150: unix.B150, + 200: unix.B200, + 300: unix.B300, + 600: unix.B600, + 1200: unix.B1200, + 1800: unix.B1800, + 2400: unix.B2400, + 4800: unix.B4800, + 9600: unix.B9600, + 19200: unix.B19200, + 38400: unix.B38400, + 57600: unix.B57600, + 115200: unix.B115200, + 230400: unix.B230400, + 460800: unix.B460800, + 500000: unix.B500000, + 576000: unix.B576000, + 921600: unix.B921600, + 1000000: unix.B1000000, + 1152000: unix.B1152000, + 1500000: unix.B1500000, + 2000000: unix.B2000000, + 2500000: unix.B2500000, + 3000000: unix.B3000000, + 3500000: unix.B3500000, + 4000000: unix.B4000000, } var databitsMap = map[int]uint32{ - 0: syscall.CS8, // Default to 8 bits - 5: syscall.CS5, - 6: syscall.CS6, - 7: syscall.CS7, - 8: syscall.CS8, + 0: unix.CS8, // Default to 8 bits + 5: unix.CS5, + 6: unix.CS6, + 7: unix.CS7, + 8: unix.CS8, } const tcCMSPAR uint32 = 0 // may be CMSPAR or PAREXT -const tcIUCLC = syscall.IUCLC +const tcIUCLC = unix.IUCLC const tcCRTSCTS uint32 = 0x80000000 -const ioctlTcgetattr = syscall.TCGETS -const ioctlTcsetattr = syscall.TCSETS +const ioctlTcgetattr = unix.TCGETS +const ioctlTcsetattr = unix.TCSETS diff --git a/serial_unix.go b/serial_unix.go index 8dc2c74..58ee9c0 100644 --- a/serial_unix.go +++ b/serial_unix.go @@ -13,9 +13,10 @@ import ( "regexp" "strings" "sync" - "syscall" "unsafe" + "golang.org/x/sys/unix" + "go.bug.st/serial.v1/unixutils" ) @@ -30,7 +31,7 @@ type unixPort struct { func (port *unixPort) Close() error { // Close port port.releaseExclusiveAccess() - if err := syscall.Close(port.handle); err != nil { + if err := unix.Close(port.handle); err != nil { return err } port.opened = false @@ -66,11 +67,11 @@ func (port *unixPort) Read(p []byte) (n int, err error) { if res.IsReadable(port.closeSignal.ReadFD()) { return 0, &PortError{code: PortClosed} } - return syscall.Read(port.handle, p) + return unix.Read(port.handle, p) } func (port *unixPort) Write(p []byte) (n int, err error) { - return syscall.Write(port.handle, p) + return unix.Write(port.handle, p) } func (port *unixPort) SetMode(mode *Mode) error { @@ -99,9 +100,9 @@ func (port *unixPort) SetDTR(dtr bool) error { return err } if dtr { - status |= syscall.TIOCM_DTR + status |= unix.TIOCM_DTR } else { - status &^= syscall.TIOCM_DTR + status &^= unix.TIOCM_DTR } return port.setModemBitsStatus(status) } @@ -112,9 +113,9 @@ func (port *unixPort) SetRTS(rts bool) error { return err } if rts { - status |= syscall.TIOCM_RTS + status |= unix.TIOCM_RTS } else { - status &^= syscall.TIOCM_RTS + status &^= unix.TIOCM_RTS } return port.setModemBitsStatus(status) } @@ -125,20 +126,20 @@ func (port *unixPort) GetModemStatusBits() (*ModemStatusBits, error) { return nil, err } return &ModemStatusBits{ - CTS: (status & syscall.TIOCM_CTS) != 0, - DCD: (status & syscall.TIOCM_CD) != 0, - DSR: (status & syscall.TIOCM_DSR) != 0, - RI: (status & syscall.TIOCM_RI) != 0, + CTS: (status & unix.TIOCM_CTS) != 0, + DCD: (status & unix.TIOCM_CD) != 0, + DSR: (status & unix.TIOCM_DSR) != 0, + RI: (status & unix.TIOCM_RI) != 0, }, nil } func nativeOpen(portName string, mode *Mode) (*unixPort, error) { - h, err := syscall.Open(portName, syscall.O_RDWR|syscall.O_NOCTTY|syscall.O_NDELAY, 0) + h, err := unix.Open(portName, unix.O_RDWR|unix.O_NOCTTY|unix.O_NDELAY, 0) if err != nil { switch err { - case syscall.EBUSY: + case unix.EBUSY: return nil, &PortError{code: PortBusy} - case syscall.EACCES: + case unix.EACCES: return nil, &PortError{code: PermissionDenied} } return nil, err @@ -171,7 +172,7 @@ func nativeOpen(portName string, mode *Mode) (*unixPort, error) { return nil, &PortError{code: InvalidSerialPort} } - syscall.SetNonblock(h, false) + unix.SetNonblock(h, false) port.acquireExclusiveAccess() @@ -232,7 +233,7 @@ func nativeGetPortsList() ([]string, error) { // termios manipulation functions -func setTermSettingsBaudrate(speed int, settings *syscall.Termios) error { +func setTermSettingsBaudrate(speed int, settings *unix.Termios) error { baudrate, ok := baudrateMap[speed] if !ok { return &PortError{code: InvalidSpeed} @@ -248,72 +249,72 @@ func setTermSettingsBaudrate(speed int, settings *syscall.Termios) error { return nil } -func setTermSettingsParity(parity Parity, settings *syscall.Termios) error { +func setTermSettingsParity(parity Parity, settings *unix.Termios) error { switch parity { case NoParity: - settings.Cflag &^= syscall.PARENB - settings.Cflag &^= syscall.PARODD + settings.Cflag &^= unix.PARENB + settings.Cflag &^= unix.PARODD settings.Cflag &^= tcCMSPAR - settings.Iflag &^= syscall.INPCK + settings.Iflag &^= unix.INPCK case OddParity: - settings.Cflag |= syscall.PARENB - settings.Cflag |= syscall.PARODD + settings.Cflag |= unix.PARENB + settings.Cflag |= unix.PARODD settings.Cflag &^= tcCMSPAR - settings.Iflag |= syscall.INPCK + settings.Iflag |= unix.INPCK case EvenParity: - settings.Cflag |= syscall.PARENB - settings.Cflag &^= syscall.PARODD + settings.Cflag |= unix.PARENB + settings.Cflag &^= unix.PARODD settings.Cflag &^= tcCMSPAR - settings.Iflag |= syscall.INPCK + settings.Iflag |= unix.INPCK case MarkParity: if tcCMSPAR == 0 { return &PortError{code: InvalidParity} } - settings.Cflag |= syscall.PARENB - settings.Cflag |= syscall.PARODD + settings.Cflag |= unix.PARENB + settings.Cflag |= unix.PARODD settings.Cflag |= tcCMSPAR - settings.Iflag |= syscall.INPCK + settings.Iflag |= unix.INPCK case SpaceParity: if tcCMSPAR == 0 { return &PortError{code: InvalidParity} } - settings.Cflag |= syscall.PARENB - settings.Cflag &^= syscall.PARODD + settings.Cflag |= unix.PARENB + settings.Cflag &^= unix.PARODD settings.Cflag |= tcCMSPAR - settings.Iflag |= syscall.INPCK + settings.Iflag |= unix.INPCK default: return &PortError{code: InvalidParity} } return nil } -func setTermSettingsDataBits(bits int, settings *syscall.Termios) error { +func setTermSettingsDataBits(bits int, settings *unix.Termios) error { databits, ok := databitsMap[bits] if !ok { return &PortError{code: InvalidDataBits} } // Remove previous databits setting - settings.Cflag &^= syscall.CSIZE + settings.Cflag &^= unix.CSIZE // Set requested databits settings.Cflag |= databits return nil } -func setTermSettingsStopBits(bits StopBits, settings *syscall.Termios) error { +func setTermSettingsStopBits(bits StopBits, settings *unix.Termios) error { switch bits { case OneStopBit: - settings.Cflag &^= syscall.CSTOPB + settings.Cflag &^= unix.CSTOPB case OnePointFiveStopBits: return &PortError{code: InvalidStopBits} case TwoStopBits: - settings.Cflag |= syscall.CSTOPB + settings.Cflag |= unix.CSTOPB default: return &PortError{code: InvalidStopBits} } return nil } -func setTermSettingsCtsRts(enable bool, settings *syscall.Termios) { +func setTermSettingsCtsRts(enable bool, settings *unix.Termios) { if enable { settings.Cflag |= tcCRTSCTS } else { @@ -321,70 +322,70 @@ func setTermSettingsCtsRts(enable bool, settings *syscall.Termios) { } } -func setRawMode(settings *syscall.Termios) { +func setRawMode(settings *unix.Termios) { // Set local mode - settings.Cflag |= syscall.CREAD - settings.Cflag |= syscall.CLOCAL + settings.Cflag |= unix.CREAD + settings.Cflag |= unix.CLOCAL // Set raw mode - settings.Lflag &^= syscall.ICANON - settings.Lflag &^= syscall.ECHO - settings.Lflag &^= syscall.ECHOE - settings.Lflag &^= syscall.ECHOK - settings.Lflag &^= syscall.ECHONL - settings.Lflag &^= syscall.ECHOCTL - settings.Lflag &^= syscall.ECHOPRT - settings.Lflag &^= syscall.ECHOKE - settings.Lflag &^= syscall.ISIG - settings.Lflag &^= syscall.IEXTEN + settings.Lflag &^= unix.ICANON + settings.Lflag &^= unix.ECHO + settings.Lflag &^= unix.ECHOE + settings.Lflag &^= unix.ECHOK + settings.Lflag &^= unix.ECHONL + settings.Lflag &^= unix.ECHOCTL + settings.Lflag &^= unix.ECHOPRT + settings.Lflag &^= unix.ECHOKE + settings.Lflag &^= unix.ISIG + settings.Lflag &^= unix.IEXTEN - settings.Iflag &^= syscall.IXON - settings.Iflag &^= syscall.IXOFF - settings.Iflag &^= syscall.IXANY - settings.Iflag &^= syscall.INPCK - settings.Iflag &^= syscall.IGNPAR - settings.Iflag &^= syscall.PARMRK - settings.Iflag &^= syscall.ISTRIP - settings.Iflag &^= syscall.IGNBRK - settings.Iflag &^= syscall.BRKINT - settings.Iflag &^= syscall.INLCR - settings.Iflag &^= syscall.IGNCR - settings.Iflag &^= syscall.ICRNL + settings.Iflag &^= unix.IXON + settings.Iflag &^= unix.IXOFF + settings.Iflag &^= unix.IXANY + settings.Iflag &^= unix.INPCK + settings.Iflag &^= unix.IGNPAR + settings.Iflag &^= unix.PARMRK + settings.Iflag &^= unix.ISTRIP + settings.Iflag &^= unix.IGNBRK + settings.Iflag &^= unix.BRKINT + settings.Iflag &^= unix.INLCR + settings.Iflag &^= unix.IGNCR + settings.Iflag &^= unix.ICRNL settings.Iflag &^= tcIUCLC - settings.Oflag &^= syscall.OPOST + settings.Oflag &^= unix.OPOST // Block reads until at least one char is available (no timeout) - settings.Cc[syscall.VMIN] = 1 - settings.Cc[syscall.VTIME] = 0 + settings.Cc[unix.VMIN] = 1 + settings.Cc[unix.VTIME] = 0 } // native syscall wrapper functions -func (port *unixPort) getTermSettings() (*syscall.Termios, error) { - settings := &syscall.Termios{} +func (port *unixPort) getTermSettings() (*unix.Termios, error) { + settings := &unix.Termios{} err := ioctl(port.handle, ioctlTcgetattr, uintptr(unsafe.Pointer(settings))) return settings, err } -func (port *unixPort) setTermSettings(settings *syscall.Termios) error { +func (port *unixPort) setTermSettings(settings *unix.Termios) error { return ioctl(port.handle, ioctlTcsetattr, uintptr(unsafe.Pointer(settings))) } func (port *unixPort) getModemBitsStatus() (int, error) { var status int - err := ioctl(port.handle, syscall.TIOCMGET, uintptr(unsafe.Pointer(&status))) + err := ioctl(port.handle, unix.TIOCMGET, uintptr(unsafe.Pointer(&status))) return status, err } func (port *unixPort) setModemBitsStatus(status int) error { - return ioctl(port.handle, syscall.TIOCMSET, uintptr(unsafe.Pointer(&status))) + return ioctl(port.handle, unix.TIOCMSET, uintptr(unsafe.Pointer(&status))) } func (port *unixPort) acquireExclusiveAccess() error { - return ioctl(port.handle, syscall.TIOCEXCL, 0) + return ioctl(port.handle, unix.TIOCEXCL, 0) } func (port *unixPort) releaseExclusiveAccess() error { - return ioctl(port.handle, syscall.TIOCNXCL, 0) + return ioctl(port.handle, unix.TIOCNXCL, 0) } diff --git a/zsyscall_darwin.go b/zsyscall_darwin.go index 49cfac4..cef1732 100644 --- a/zsyscall_darwin.go +++ b/zsyscall_darwin.go @@ -10,10 +10,10 @@ package serial // import "go.bug.st/serial.v1" -import "syscall" +import "golang.org/x/sys/unix" func ioctl(fd int, req uint64, data uintptr) (err error) { - _, _, e1 := syscall.Syscall(syscall.SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(data)) + _, _, e1 := unix.Syscall(unix.SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(data)) if e1 != 0 { err = e1 } diff --git a/zsyscall_freebsd.go b/zsyscall_freebsd.go index 702fd99..9e6765d 100644 --- a/zsyscall_freebsd.go +++ b/zsyscall_freebsd.go @@ -10,10 +10,10 @@ package serial // import "go.bug.st/serial.v1" -import "syscall" +import "golang.org/x/sys/unix" func ioctl(fd int, req uint64, data uintptr) (err error) { - _, _, e1 := syscall.Syscall(syscall.SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(data)) + _, _, e1 := unix.Syscall(unix.SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(data)) if e1 != 0 { err = e1 } diff --git a/zsyscall_linux.go b/zsyscall_linux.go index 60c2d75..d93c1fb 100644 --- a/zsyscall_linux.go +++ b/zsyscall_linux.go @@ -10,10 +10,10 @@ package serial // import "go.bug.st/serial.v1" -import "syscall" +import "golang.org/x/sys/unix" func ioctl(fd int, req uint64, data uintptr) (err error) { - _, _, e1 := syscall.Syscall(syscall.SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(data)) + _, _, e1 := unix.Syscall(unix.SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(data)) if e1 != 0 { err = e1 }