@yuuki824/kanshi 0.3.0

package/internal/storage/cache.go

@@ -0,0 +1,283 @@
+package storage
+
+import (
+	"bufio"
+	"encoding/gob"
+	"errors"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"slices"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/rene-roid/kanshi/internal/roots"
+)
+
+// Bumped whenever the file changes shape. This is a cache, so an old one is
+// dropped and rebuilt rather than migrated.
+const cacheVersion = 1
+
+// sized is what the cache knows about one folder.
+type sized struct {
+	size       int64
+	unreadable int
+	at         time.Time
+}
+
+// cache holds every folder a walk has sized, grouped by parent so a listing's
+// subfolders are one map lookup. Paths are roots.Key form: cleaned, and
+// lower-cased on Windows.
+//
+// It is small enough to keep in memory whole (one entry per folder, a few
+// thousand for all of / on the homeserver), and is written back to one file
+// after each walk rather than entry by entry.
+type cache struct {
+	path string // "" keeps it in memory only
+
+	mu    sync.Mutex
+	dirs  map[string]map[string]sized // parent key → name key → size
+	dirty bool
+}
+
+// cacheFile is the on-disk form. gob needs exported fields.
+type cacheFile struct {
+	Version int
+	Dirs    map[string]map[string]cacheEntry
+}
+
+type cacheEntry struct {
+	Size       int64
+	Unreadable int
+	SizedAt    int64 // unix seconds
+}
+
+// openCache loads the cache at path, or starts an in-memory one when path is
+// empty. A file that is missing, from another version or not a cache at all
+// starts it empty. It is then written straight away, so a path that cannot be
+// written to is reported now rather than after the first walk.
+func openCache(path string) (*cache, error) {
+	c := &cache{path: path, dirs: map[string]map[string]sized{}}
+	if path == "" {
+		return c, nil
+	}
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		return nil, err
+	}
+	f, err := os.Open(path)
+	if err == nil {
+		var file cacheFile
+		ok := gob.NewDecoder(bufio.NewReader(f)).Decode(&file) == nil && file.Version == cacheVersion
+		f.Close()
+		if ok {
+			for parent, children := range file.Dirs {
+				m := make(map[string]sized, len(children))
+				for name, e := range children {
+					m[name] = sized{size: e.Size, unreadable: e.Unreadable, at: time.Unix(e.SizedAt, 0)}
+				}
+				c.dirs[parent] = m
+			}
+			return c, nil
+		}
+	} else if !errors.Is(err, fs.ErrNotExist) {
+		return nil, err
+	}
+	c.dirty = true
+	if err := c.save(); err != nil {
+		return nil, err
+	}
+	return c, nil
+}
+
+// close writes out anything a listing changed since the last walk.
+func (c *cache) close() error { return c.save() }
+
+// save writes the cache if it has changed. It goes to a temporary file that
+// then replaces the old one, so a crash mid-write leaves the previous cache
+// rather than half of this one.
+func (c *cache) save() error {
+	c.mu.Lock()
+	if c.path == "" || !c.dirty {
+		c.mu.Unlock()
+		return nil
+	}
+	file := cacheFile{Version: cacheVersion, Dirs: make(map[string]map[string]cacheEntry, len(c.dirs))}
+	for parent, children := range c.dirs {
+		m := make(map[string]cacheEntry, len(children))
+		for name, s := range children {
+			m[name] = cacheEntry{Size: s.size, Unreadable: s.unreadable, SizedAt: s.at.Unix()}
+		}
+		file.Dirs[parent] = m
+	}
+	c.dirty = false
+	c.mu.Unlock()
+
+	tmp, err := os.CreateTemp(filepath.Dir(c.path), filepath.Base(c.path)+".*")
+	if err != nil {
+		c.markDirty()
+		return err
+	}
+	w := bufio.NewWriter(tmp)
+	err = gob.NewEncoder(w).Encode(&file)
+	if err == nil {
+		err = w.Flush()
+	}
+	if cerr := tmp.Close(); err == nil {
+		err = cerr
+	}
+	if err == nil {
+		err = os.Rename(tmp.Name(), c.path)
+	}
+	if err != nil {
+		os.Remove(tmp.Name())
+		c.markDirty()
+	}
+	return err
+}
+
+func (c *cache) markDirty() {
+	c.mu.Lock()
+	c.dirty = true
+	c.mu.Unlock()
+}
+
+// get returns what is cached for one folder.
+func (c *cache) get(key string) (sized, bool) {
+	parent, name := splitKey(key)
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	s, ok := c.dirs[parent][name]
+	return s, ok
+}
+
+// children returns every cached subfolder of dir, by name key. The map is a
+// copy, so the caller can hold on to it while walks carry on.
+func (c *cache) children(dir string) map[string]sized {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	out := make(map[string]sized, len(c.dirs[dir]))
+	for name, s := range c.dirs[dir] {
+		out[name] = s
+	}
+	return out
+}
+
+// put records one folder's size. It is saved with the next walk or on close:
+// a listing can always work it out again.
+func (c *cache) put(key string, s sized) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.set(key, s)
+}
+
+// set records one folder's size. The caller holds mu.
+func (c *cache) set(key string, s sized) {
+	parent, name := splitKey(key)
+	m := c.dirs[parent]
+	if m == nil {
+		m = map[string]sized{}
+		c.dirs[parent] = m
+	}
+	m[name] = s
+	c.dirty = true
+}
+
+// store replaces everything cached at and below key with one walk's result,
+// and saves the cache. Entries below the walk's depth are dropped rather than
+// kept: they predate it, and a folder with no entry is simply walked again
+// when it is opened. Other roots inside key are left alone, since the walk
+// may not have entered them: /mnt/data is its own root, on its own
+// filesystem, under /.
+func (c *cache) store(key string, t *tree, at time.Time, rootKeys []string) error {
+	c.mu.Lock()
+	c.deleteSubtree(key, rootKeys)
+	// Breadth-first order puts every parent before its children, so each
+	// node's key is known by the time its children need it.
+	keys := make([]string, len(t.nodes))
+	keys[0] = key
+	for i, n := range t.nodes {
+		for _, ch := range n.children {
+			keys[ch] = joinKey(keys[i], nameKey(t.nodes[ch].name))
+		}
+		c.set(keys[i], sized{size: n.size, unreadable: int(n.unreadable), at: at})
+	}
+	c.mu.Unlock()
+	return c.save()
+}
+
+// prune forgets the subfolders of dir that are no longer there, so a folder
+// recreated under an old name is sized afresh. Other roots are kept: a drive
+// mounted in dir is not one of its subfolders, but is still there.
+func (c *cache) prune(dir string, cached map[string]sized, present map[string]bool, rootKeys []string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	for name := range cached {
+		if key := joinKey(dir, name); !present[name] && !slices.Contains(rootKeys, key) {
+			c.deleteSubtree(key, rootKeys)
+		}
+	}
+}
+
+// deleteSubtree removes key and everything below it, except for the
+// subtrees of any other root in rootKeys. The caller holds mu.
+func (c *cache) deleteSubtree(key string, rootKeys []string) {
+	var keep []string
+	for _, r := range rootKeys {
+		if r != key && below(key, r) {
+			keep = append(keep, r)
+		}
+	}
+	parent, name := splitKey(key)
+	if m, ok := c.dirs[parent]; ok {
+		delete(m, name)
+		if len(m) == 0 {
+			delete(c.dirs, parent)
+		}
+	}
+	for p, m := range c.dirs {
+		if !below(key, p) || slices.ContainsFunc(keep, func(r string) bool { return below(r, p) }) {
+			continue
+		}
+		// A kept root's own entry sits under a parent inside key, which
+		// otherwise loses everything.
+		for name := range m {
+			if !slices.Contains(keep, joinKey(p, name)) {
+				delete(m, name)
+			}
+		}
+		if len(m) == 0 {
+			delete(c.dirs, p)
+		}
+	}
+	c.dirty = true
+}
+
+// below reports whether key is dir itself or somewhere inside it. Both are
+// already in key form.
+func below(dir, key string) bool {
+	if key == dir {
+		return true
+	}
+	if !strings.HasSuffix(dir, roots.Sep) {
+		dir += roots.Sep
+	}
+	return strings.HasPrefix(key, dir)
+}
+
+// splitKey divides a path key into its parent's key and its own name. A
+// volume root such as "/" or "c:\" has no parent and is its own name.
+func splitKey(key string) (parent, name string) {
+	parent = filepath.Dir(key)
+	if parent == key {
+		return "", key
+	}
+	return parent, filepath.Base(key)
+}
+
+func joinKey(dir, name string) string {
+	if strings.HasSuffix(dir, roots.Sep) {
+		return dir + name
+	}
+	return dir + roots.Sep + name
+}

package/internal/storage/dir_linux.go

@@ -0,0 +1,177 @@
+package storage
+
+import (
+	"errors"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+const pathSep = '/'
+
+// normKey matches roots.Key for the clean paths the walk builds.
+func normKey(p []byte) string { return string(p) }
+
+func sameName(a, b string) bool { return a == b }
+
+// nameKey is how one name appears in a cache key.
+func nameKey(name string) string { return name }
+
+// systemRoot is where Windows keeps its hard links. Linux has no such place:
+// every multiply-linked file is spotted by its link count instead.
+var systemRoot = func() string { return "" }
+
+// rootDevice checks the root is a directory and returns the filesystem it is
+// on, which the walk will not leave.
+func rootDevice(path string) (uint64, error) {
+	var st syscall.Stat_t
+	if err := syscall.Stat(path, &st); err != nil {
+		return 0, err
+	}
+	if st.Mode&syscall.S_IFMT != syscall.S_IFDIR {
+		return 0, errors.New("not a directory")
+	}
+	return uint64(st.Dev), nil
+}
+
+// Linux dirent64: d_ino (8), d_off (8), d_reclen (2), d_type (1), d_name.
+const (
+	direntReclen = 16
+	direntType   = 18
+	direntName   = 19
+)
+
+const (
+	atSymlinkNofollow = 0x100
+	atNoAutomount     = 0x800
+)
+
+// A variable, not a constant: a negative constant cannot convert to uintptr.
+var atFDCWD = -100
+
+// dirReader lists directories with getdents64 and fstatat.
+//
+// The loop does no allocation per entry: records are parsed in place from one
+// reused buffer, and each is stat'ed relative to its directory's descriptor
+// with the NUL-terminated name straight out of that buffer, so the kernel
+// resolves one path component rather than the whole path from the root.
+type dirReader struct {
+	buf     []byte
+	names   []byte
+	entries []dirEntry
+	st      syscall.Stat_t
+}
+
+func newDirReader() *dirReader { return &dirReader{buf: make([]byte, 32*1024)} }
+
+// read lists one directory. path must be followed by a NUL in its backing
+// array. The result is only valid until the next call.
+func (r *dirReader) read(path []byte, _ bool) ([]dirEntry, int, error) {
+	fd, err := openDir(path)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer syscall.Close(fd)
+
+	r.entries, r.names = r.entries[:0], r.names[:0]
+	seen := 0
+	for {
+		n, err := syscall.Getdents(fd, r.buf)
+		if err != nil || n <= 0 {
+			break // end of directory, or a read error mid-directory
+		}
+		for off := 0; off < n; {
+			reclen := int(*(*uint16)(unsafe.Pointer(&r.buf[off+direntReclen])))
+			typ := r.buf[off+direntType]
+			name := r.buf[off+direntName : off+reclen]
+			off += reclen
+			if end := indexNUL(name); end >= 0 {
+				name = name[:end]
+			}
+			seen++
+			// d_type comes back with the directory entry, so symlinks,
+			// sockets and devices are rejected without a stat at all.
+			if typ != syscall.DT_DIR && typ != syscall.DT_REG && typ != syscall.DT_UNKNOWN {
+				continue
+			}
+			if len(name) == 0 || (name[0] == '.' && (len(name) == 1 || (len(name) == 2 && name[1] == '.'))) {
+				continue
+			}
+			if statAt(fd, path, name, &r.st) != nil {
+				continue
+			}
+			var e dirEntry
+			switch r.st.Mode & syscall.S_IFMT {
+			case syscall.S_IFDIR:
+				e.dir, e.dev = true, uint64(r.st.Dev)
+			case syscall.S_IFREG:
+				e.size = int64(r.st.Blocks) * 512
+				if r.st.Nlink > 1 {
+					e.key = uint64(r.st.Dev)<<48 | uint64(r.st.Ino)
+				}
+			default:
+				continue
+			}
+			// Copied out because the next getdents call reuses buf.
+			start := len(r.names)
+			r.names = append(r.names, name...)
+			e.name = r.names[start:len(r.names):len(r.names)]
+			r.entries = append(r.entries, e)
+		}
+	}
+	return r.entries, seen, nil
+}
+
+// openDir opens a directory by a path that is followed by a NUL in its
+// backing array, so the kernel reads it in place rather than from a copy.
+func openDir(path []byte) (int, error) {
+	fd, _, errno := syscall.Syscall6(syscall.SYS_OPENAT, uintptr(atFDCWD), uintptr(unsafe.Pointer(&path[0])),
+		syscall.O_RDONLY|syscall.O_DIRECTORY|syscall.O_CLOEXEC|syscall.O_NOFOLLOW, 0, 0, 0)
+	if errno != 0 {
+		return -1, errno
+	}
+	return int(fd), nil
+}
+
+func indexNUL(b []byte) int {
+	for i, c := range b {
+		if c == 0 {
+			return i
+		}
+	}
+	return -1
+}
+
+// join builds a full path without path/filepath's Clean pass: every path here
+// is an already-clean parent plus one getdents name.
+func join(dir, name string) string {
+	if dir == "/" {
+		return "/" + name
+	}
+	return dir + "/" + name
+}
+
+const (
+	ioprioWhoProcess = 1
+	ioprioClassBE    = 2
+	ioprioClassShift = 13
+)
+
+// deprioritise puts the calling thread at the back of the queue for both the
+// CPU (nice 19) and the disk (lowest best-effort I/O priority), so a rescan
+// never makes the at-a-glance numbers stutter. The idle I/O class would be
+// gentler still, but on a busy box it can starve the walk outright.
+func deprioritise() {
+	_ = syscall.Setpriority(syscall.PRIO_PROCESS, 0, 19)
+	syscall.RawSyscall(syscall.SYS_IOPRIO_SET, ioprioWhoProcess, 0, ioprioClassBE<<ioprioClassShift|7)
+}
+
+// threadCPU is the user+system time of the calling thread, which the walk has
+// to itself because it is locked to it.
+func threadCPU() time.Duration {
+	var ru syscall.Rusage
+	if syscall.Getrusage(syscall.RUSAGE_THREAD, &ru) != nil {
+		return 0
+	}
+	return time.Duration(ru.Utime.Nano() + ru.Stime.Nano())
+}

package/internal/storage/dir_windows.go

@@ -0,0 +1,244 @@
+package storage
+
+import (
+	"errors"
+	"os"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+	"unicode/utf16"
+	"unicode/utf8"
+	"unsafe"
+)
+
+const pathSep = '\\'
+
+// normKey matches roots.Key: NTFS names compare case-insensitively.
+func normKey(p []byte) string { return strings.ToLower(string(p)) }
+
+// sameName lets a pasted c:\users\... find C:\Users\... on disk.
+func sameName(a, b string) bool { return strings.EqualFold(a, b) }
+
+// nameKey is how one name appears in a cache key, lower-cased like roots.Key.
+func nameKey(name string) string { return strings.ToLower(name) }
+
+// systemRoot is C:\Windows. Its component store hard-links most of System32,
+// so files there are de-duplicated by file ID; anywhere else hard links are
+// rare enough that tracking every file ID would cost more memory than it saves.
+// A variable so tests can point it at a scratch directory.
+var systemRoot = func() string { return os.Getenv("SystemRoot") }
+
+func rootDevice(path string) (uint64, error) {
+	info, err := os.Stat(path)
+	if err != nil {
+		return 0, err
+	}
+	if !info.IsDir() {
+		return 0, errors.New("not a directory")
+	}
+	// Windows walks never cross into another volume anyway: mounted folders
+	// are reparse points, and those are skipped.
+	return 0, nil
+}
+
+var (
+	kernel32                         = syscall.NewLazyDLL("kernel32.dll")
+	procGetFileInformationByHandleEx = kernel32.NewProc("GetFileInformationByHandleEx")
+	procSetThreadPriority            = kernel32.NewProc("SetThreadPriority")
+	procGetThreadTimes               = kernel32.NewProc("GetThreadTimes")
+
+	advapi32                  = syscall.NewLazyDLL("advapi32.dll")
+	procLookupPrivilegeValueW = advapi32.NewProc("LookupPrivilegeValueW")
+	procAdjustTokenPrivileges = advapi32.NewProc("AdjustTokenPrivileges")
+)
+
+const (
+	fileListDirectory       = 0x0001
+	fileShareAll            = syscall.FILE_SHARE_READ | syscall.FILE_SHARE_WRITE | 0x4 // | FILE_SHARE_DELETE
+	fileFlagBackupSemantics = 0x02000000
+	fileIDBothDirectoryInfo = 10
+	errorNoMoreFiles        = 18
+
+	attrDirectory    = 0x10
+	attrReparsePoint = 0x400
+	// Junctions, symlinks and mounted folders all carry the name-surrogate
+	// bit: they point somewhere else, and following them would loop or count
+	// a directory twice. OneDrive placeholders do not, so they are walked.
+	reparseNameSurrogate = 0x20000000
+
+	// FILE_ID_BOTH_DIR_INFO field offsets.
+	offNext       = 0
+	offAllocation = 48
+	offAttributes = 56
+	offNameLength = 60
+	offEaSize     = 64 // holds the reparse tag when attrReparsePoint is set
+	offFileID     = 96
+	offName       = 104
+
+	currentThread             = ^uintptr(1) // GetCurrentThread's pseudo-handle, -2
+	threadModeBackgroundBegin = 0x00010000
+	sePrivilegeEnabled        = 0x2
+)
+
+// dirReader lists directories with GetFileInformationByHandleEx, which hands
+// back names, attributes and allocation sizes for a whole batch of entries in
+// one call — the same no-stat-per-file property the Linux reader gets from
+// fstatat, and the size on disk rather than the logical length.
+type dirReader struct {
+	buf     []byte // 8-byte aligned, as the records inside it require
+	path16  []uint16
+	names   []byte
+	entries []dirEntry
+}
+
+func newDirReader() *dirReader {
+	words := make([]uint64, 64*1024/8)
+	return &dirReader{buf: unsafe.Slice((*byte)(unsafe.Pointer(&words[0])), len(words)*8)}
+}
+
+func (r *dirReader) read(path []byte, dedupe bool) ([]dirEntry, int, error) {
+	h, err := syscall.CreateFile(r.longPath(path), fileListDirectory, fileShareAll, nil,
+		syscall.OPEN_EXISTING, fileFlagBackupSemantics, 0)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer syscall.CloseHandle(h)
+
+	r.entries, r.names = r.entries[:0], r.names[:0]
+	seen := 0
+	for first := true; ; first = false {
+		ok, _, e := procGetFileInformationByHandleEx.Call(uintptr(h), fileIDBothDirectoryInfo,
+			uintptr(unsafe.Pointer(&r.buf[0])), uintptr(len(r.buf)))
+		if ok == 0 {
+			if first && e != syscall.Errno(errorNoMoreFiles) {
+				return nil, 0, e // opened, but listing it was refused
+			}
+			break
+		}
+		for off := 0; ; {
+			rec := r.buf[off:]
+			next := u32(rec, offNext)
+			nameLen := int(u32(rec, offNameLength)) / 2
+			name := unsafe.Slice((*uint16)(unsafe.Pointer(&rec[offName])), nameLen)
+			r.add(name, rec, dedupe, &seen)
+			if next == 0 {
+				break
+			}
+			off += int(next)
+		}
+	}
+	return r.entries, seen, nil
+}
+
+func (r *dirReader) add(name []uint16, rec []byte, dedupe bool, seen *int) {
+	if len(name) == 1 && name[0] == '.' || len(name) == 2 && name[0] == '.' && name[1] == '.' {
+		return
+	}
+	*seen++
+	attrs := u32(rec, offAttributes)
+	if attrs&attrReparsePoint != 0 && u32(rec, offEaSize)&reparseNameSurrogate != 0 {
+		return
+	}
+	var e dirEntry
+	if attrs&attrDirectory != 0 {
+		e.dir = true
+	} else {
+		e.size = *(*int64)(unsafe.Pointer(&rec[offAllocation]))
+		if dedupe {
+			e.key = *(*uint64)(unsafe.Pointer(&rec[offFileID]))
+		}
+	}
+	start := len(r.names)
+	r.names = appendUTF8(r.names, name)
+	e.name = r.names[start:len(r.names):len(r.names)]
+	r.entries = append(r.entries, e)
+}
+
+// longPath converts to UTF-16 with the \\?\ prefix, which lifts the 260
+// character limit that a deep node_modules tree would otherwise hit.
+func (r *dirReader) longPath(path []byte) *uint16 {
+	p := r.path16[:0]
+	s := string(path)
+	if strings.HasPrefix(s, `\\`) {
+		p = append(p, []uint16(utf16.Encode([]rune(`\\?\UNC\`)))...)
+		s = s[2:]
+	} else {
+		p = append(p, '\\', '\\', '?', '\\')
+	}
+	for _, c := range s {
+		p = utf16.AppendRune(p, c)
+	}
+	p = append(p, 0)
+	r.path16 = p
+	return &p[0]
+}
+
+func appendUTF8(dst []byte, name []uint16) []byte {
+	for i := 0; i < len(name); i++ {
+		c := rune(name[i])
+		if c < utf8.RuneSelf {
+			dst = append(dst, byte(c))
+			continue
+		}
+		if utf16.IsSurrogate(c) && i+1 < len(name) {
+			if pair := utf16.DecodeRune(c, rune(name[i+1])); pair != utf8.RuneError {
+				c = pair
+				i++
+			}
+		}
+		dst = utf8.AppendRune(dst, c)
+	}
+	return dst
+}
+
+func u32(b []byte, off int) uint32 { return *(*uint32)(unsafe.Pointer(&b[off])) }
+
+var backupOnce sync.Once
+
+// deprioritise puts the calling thread in background mode, which lowers its
+// CPU, I/O and memory priority together — Windows' equivalent of nice 19 plus
+// the lowest I/O class.
+//
+// It also enables SeBackupPrivilege where the token holds it (an elevated
+// administrator), so folders whose ACLs shut out even administrators are
+// still counted. That privilege only grants reading; nothing is ever opened
+// for writing.
+func deprioritise() {
+	procSetThreadPriority.Call(currentThread, threadModeBackgroundBegin)
+	backupOnce.Do(enableBackupPrivilege)
+}
+
+func enableBackupPrivilege() {
+	var token syscall.Token
+	proc, _ := syscall.GetCurrentProcess()
+	if syscall.OpenProcessToken(proc, syscall.TOKEN_ADJUST_PRIVILEGES|syscall.TOKEN_QUERY, &token) != nil {
+		return
+	}
+	defer token.Close()
+	var privileges struct {
+		count uint32
+		luid  struct {
+			low  uint32
+			high int32
+		}
+		attributes uint32
+	}
+	name, _ := syscall.UTF16PtrFromString("SeBackupPrivilege")
+	if ok, _, _ := procLookupPrivilegeValueW.Call(0, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(&privileges.luid))); ok == 0 {
+		return
+	}
+	privileges.count, privileges.attributes = 1, sePrivilegeEnabled
+	procAdjustTokenPrivileges.Call(uintptr(token), 0, uintptr(unsafe.Pointer(&privileges)), 0, 0, 0)
+}
+
+// threadCPU is the kernel+user time of the calling thread.
+func threadCPU() time.Duration {
+	var created, exited, kernel, user syscall.Filetime
+	if ok, _, _ := procGetThreadTimes.Call(currentThread, uintptr(unsafe.Pointer(&created)),
+		uintptr(unsafe.Pointer(&exited)), uintptr(unsafe.Pointer(&kernel)), uintptr(unsafe.Pointer(&user))); ok == 0 {
+		return 0
+	}
+	ticks := func(f syscall.Filetime) int64 { return int64(f.HighDateTime)<<32 | int64(f.LowDateTime) }
+	return time.Duration(ticks(kernel)+ticks(user)) * 100
+}