func getRawMonoTime() (int64, int64) {
var timeSpec syscall.Timespec
syscall.Syscall(syscall.SYS_CLOCK_GETTIME, CLOCK_MONOTONIC_RAW, uintptr(unsafe.Pointer(&timeSpec)), 0)
sec, nsec := timeSpec.Unix()
return sec, nsec
}
func (conf *FindConf) ParseCMTime() {
now := time.Now().Unix()
var ct, mt, at syscall.Timespec
ct.Sec = now - int64(conf.Cmin*60) - int64(conf.Ctime*24*3600)
mt.Sec = now - int64(conf.Mmin*60) - int64(conf.Mtime*24*3600)
at.Sec = now - int64(conf.Amin*60) - int64(conf.Atime*24*3600)
conf.Stat.Ctim = ct
conf.Stat.Mtim = mt
conf.Stat.Atim = at
}
func compareRegularInodes(left, right *RegularInode, logWriter io.Writer) bool {
if left.Mode != right.Mode {
if logWriter != nil {
fmt.Fprintf(logWriter, "Mode: left vs. right: %x vs. %x\n",
left.Mode, right.Mode)
}
return false
}
if left.Uid != right.Uid {
if logWriter != nil {
fmt.Fprintf(logWriter, "Uid: left vs. right: %d vs. %d\n",
left.Uid, right.Uid)
}
return false
}
if left.Gid != right.Gid {
if logWriter != nil {
fmt.Fprintf(logWriter, "Gid: left vs. right: %d vs. %d\n",
left.Gid, right.Gid)
}
return false
}
if left.Size != right.Size {
if logWriter != nil {
fmt.Fprintf(logWriter, "Size: left vs. right: %d vs. %d\n",
left.Size, right.Size)
}
return false
}
var leftMtime, rightMtime syscall.Timespec
leftMtime.Sec = left.MtimeSeconds
leftMtime.Nsec = int64(left.MtimeNanoSeconds)
rightMtime.Sec = right.MtimeSeconds
rightMtime.Nsec = int64(right.MtimeNanoSeconds)
if leftMtime != rightMtime {
if logWriter != nil {
fmt.Fprintf(logWriter, "Mtime: left vs. right: %v vs. %v\n",
leftMtime, rightMtime)
}
return false
}
if bytes.Compare(left.Hash[:], right.Hash[:]) != 0 {
if logWriter != nil {
fmt.Fprintf(logWriter, "hash: left vs. right: %x vs. %x\n",
left.Hash, right.Hash)
}
return false
}
return true
}
func compareInodes(left, right *Inode, logWriter io.Writer) bool {
if left.Mode != right.Mode {
if logWriter != nil {
fmt.Fprintf(logWriter, "Mode: left vs. right: %o vs. %o\n",
left.Mode, right.Mode)
}
return false
}
if left.Uid != right.Uid {
if logWriter != nil {
fmt.Fprintf(logWriter, "Uid: left vs. right: %d vs. %d\n",
left.Uid, right.Uid)
}
return false
}
if left.Gid != right.Gid {
if logWriter != nil {
fmt.Fprintf(logWriter, "Gid: left vs. right: %d vs. %d\n",
left.Gid, right.Gid)
}
return false
}
var leftMtime, rightMtime syscall.Timespec
leftMtime.Sec = left.MtimeSeconds
leftMtime.Nsec = int64(left.MtimeNanoSeconds)
rightMtime.Sec = right.MtimeSeconds
rightMtime.Nsec = int64(right.MtimeNanoSeconds)
if leftMtime != rightMtime {
if logWriter != nil {
fmt.Fprintf(logWriter, "Mtime: left vs. right: %v vs. %v\n",
leftMtime, rightMtime)
}
return false
}
if left.Mode&syscall.S_IFMT == syscall.S_IFBLK ||
left.Mode&syscall.S_IFMT == syscall.S_IFCHR {
if left.Rdev != right.Rdev {
if logWriter != nil {
fmt.Fprintf(logWriter, "Rdev: left vs. right: %#x vs. %#x\n",
left.Rdev, right.Rdev)
}
return false
}
}
return true
}
func compareSpecialInodesMetadata(left, right *SpecialInode,
logWriter io.Writer) bool {
if left == right {
return true
}
if left.Mode != right.Mode {
if logWriter != nil {
fmt.Fprintf(logWriter, "Mode: left vs. right: %o vs. %o\n",
left.Mode, right.Mode)
}
return false
}
if left.Uid != right.Uid {
if logWriter != nil {
fmt.Fprintf(logWriter, "Uid: left vs. right: %d vs. %d\n",
left.Uid, right.Uid)
}
return false
}
if left.Gid != right.Gid {
if logWriter != nil {
fmt.Fprintf(logWriter, "Gid: left vs. right: %d vs. %d\n",
left.Gid, right.Gid)
}
return false
}
var leftMtime, rightMtime syscall.Timespec
leftMtime.Sec = left.MtimeSeconds
leftMtime.Nsec = int64(left.MtimeNanoSeconds)
rightMtime.Sec = right.MtimeSeconds
rightMtime.Nsec = int64(right.MtimeNanoSeconds)
if leftMtime != rightMtime {
if logWriter != nil {
fmt.Fprintf(logWriter, "Mtime: left vs. right: %v vs. %v\n",
leftMtime, rightMtime)
}
return false
}
return true
}
func timeFromTimespec(ts syscall.Timespec) time.Time {
sec, nsec := ts.Unix()
return time.Unix(sec, nsec)
}
// TODO(sgotti) for the moment just use a syscall so it'll work on all linux
// architectures. It's slower than using a vdso but we don't have such performance
// needs. Let's wait for a stdlib native monotonic clock.
func Now() int64 {
var ts syscall.Timespec
syscall.Syscall(syscall.SYS_CLOCK_GETTIME, CLOCK_MONOTONIC, uintptr(unsafe.Pointer(&ts)), 0)
nsec := ts.Nano()
return nsec
}
func toTime(src syscall.Timespec) time.Time {
sec, nsec := src.Unix()
return time.Unix(sec, nsec)
}