116 lines
3.3 KiB
Go
116 lines
3.3 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"unsafe"
|
|
|
|
"golang.org/x/sys/unix"
|
|
)
|
|
|
|
const (
|
|
hwtstampTxOff = 0
|
|
hwtstampFilterAll = 1
|
|
)
|
|
|
|
type hwtstampConfig struct {
|
|
flags int32
|
|
txType int32
|
|
rxFilter int32
|
|
}
|
|
|
|
// Temporarily bypassed so BCM work can run on the X520, which cannot stamp;
|
|
// restore to fatal for the product NIC (docs/open-questions.md).
|
|
func checkTimestamping(fd int, ifname string) checkResult {
|
|
res := configureTimestamping(fd, ifname)
|
|
if res.err != nil {
|
|
res.state = "bypassed: " + res.detail()
|
|
res.err = nil
|
|
res.fixed = true
|
|
}
|
|
return res
|
|
}
|
|
|
|
// Receive stamping is filtered by protocol and ours is not PTP, so nothing
|
|
// narrower than "all" will see our frames.
|
|
func configureTimestamping(fd int, ifname string) checkResult {
|
|
res := checkResult{item: ifname + " hw timestamps"}
|
|
desc := func(c hwtstampConfig) string {
|
|
return fmt.Sprintf("tx_type=%d rx_filter=%d", c.txType, c.rxFilter)
|
|
}
|
|
|
|
hwtstampCall := func(req uintptr, cfg *hwtstampConfig) error {
|
|
var ifr dataIfreq
|
|
copy(ifr.name[:], ifname)
|
|
ifr.data = unsafe.Pointer(cfg)
|
|
if _, _, errno := unix.Syscall(unix.SYS_IOCTL, uintptr(fd), req,
|
|
uintptr(unsafe.Pointer(&ifr))); errno != 0 {
|
|
return errno
|
|
}
|
|
return nil
|
|
}
|
|
|
|
var have hwtstampConfig
|
|
if err := hwtstampCall(unix.SIOCGHWTSTAMP, &have); err != nil {
|
|
res.err = err
|
|
return res
|
|
}
|
|
if have.txType == hwtstampTxOff && have.rxFilter == hwtstampFilterAll {
|
|
res.state = desc(have)
|
|
return res
|
|
}
|
|
|
|
// The ioctl reports back what the driver actually applied, which can be
|
|
// narrower than what was asked for.
|
|
want := hwtstampConfig{txType: hwtstampTxOff, rxFilter: hwtstampFilterAll}
|
|
if err := hwtstampCall(unix.SIOCSHWTSTAMP, &want); err != nil {
|
|
res.err = err
|
|
res.state = "could not set"
|
|
return res
|
|
}
|
|
if want.txType != hwtstampTxOff || want.rxFilter != hwtstampFilterAll {
|
|
res.err = fmt.Errorf("driver applied %s instead", desc(want))
|
|
return res
|
|
}
|
|
res.fixed = true
|
|
res.state = fmt.Sprintf("was %s, now %s", desc(have), desc(want))
|
|
return res
|
|
}
|
|
|
|
func enableRxTimestamps(fd int) error {
|
|
return unix.SetsockoptInt(fd, unix.SOL_SOCKET, unix.SO_TIMESTAMPING,
|
|
unix.SOF_TIMESTAMPING_RX_HARDWARE|unix.SOF_TIMESTAMPING_RAW_HARDWARE)
|
|
}
|
|
|
|
// Three timespecs, of which the third is the raw hardware clock. A zero there
|
|
// means the mac did not produce a stamp.
|
|
const scmTimestampingLen = 3 * int(unsafe.Sizeof(unix.Timespec{}))
|
|
|
|
// A control message's payload starts at its header rounded up to a pointer, and
|
|
// the next starts at its length rounded up the same way.
|
|
const (
|
|
cmsgAlignMask = unix.SizeofPtr - 1
|
|
cmsgDataOff = (unix.SizeofCmsghdr + cmsgAlignMask) &^ cmsgAlignMask
|
|
)
|
|
|
|
// Walked by hand rather than through ParseSocketControlMessage, which allocates
|
|
// per call on a path that runs for every frame received.
|
|
func hwTimestamp(oob []byte) (int64, bool) {
|
|
for off := 0; off+unix.SizeofCmsghdr <= len(oob); {
|
|
h := (*unix.Cmsghdr)(unsafe.Pointer(&oob[off]))
|
|
n := int(h.Len)
|
|
if n < unix.SizeofCmsghdr || off+n > len(oob) {
|
|
return 0, false
|
|
}
|
|
if h.Level == unix.SOL_SOCKET && h.Type == unix.SCM_TIMESTAMPING {
|
|
if cmsgDataOff+scmTimestampingLen > n {
|
|
return 0, false
|
|
}
|
|
ts := (*[3]unix.Timespec)(unsafe.Pointer(&oob[off+cmsgDataOff]))
|
|
ns := ts[2].Nano()
|
|
return ns, ns != 0
|
|
}
|
|
off += (n + cmsgAlignMask) &^ cmsgAlignMask
|
|
}
|
|
return 0, false
|
|
}
|