Record each file's size on disk and print it in trees (closes #147)

The files table gets a disk_size column: the file's allocated blocks,
st_blocks × 512, from the lstat the walk already does. scan writes it
with every record it writes. When a rescan finds a file with its size
and mtime unchanged but a different disk_size, it updates disk_size
alone, without reading the file. trees adds disk_size up per directory
and prints it as a column after size. On a compressed or sparse file it
is less than size, so two copies of one tree can differ; each row shows
the dupe copy's.

Judgement calls: a row's disk_size is the dupe copy's, not the first's.
A file whose record gets only a new disk_size counts as unchanged.

Model: opus-5-5

scan_test.go

@@ -42,6 +42,24 @@ func writeFile(t *testing.T, dir, name string, data []byte) string {
 	return p
 }
 
+// diskSizeOf returns the bytes the file at path takes on disk, from its
+// own lstat: st_blocks counts 512-byte units. ZFS counts a new file's
+// blocks only seconds after the write, and fsync does not hasten that.
+// A test therefore calls unix.Sync, which waits for it, before the scan
+// whose disk_size it compares with this.
+func diskSizeOf(t *testing.T, path string) int64 {
+	t.Helper()
+
+	var st syscall.Stat_t
+
+	err := syscall.Lstat(path, &st)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return st.Blocks * 512
+}
+
 // pattern returns n bytes of deterministic content seeded by tag.
 func pattern(tag byte, n int) []byte {
 	data := make([]byte, n)
@@ -1416,6 +1434,116 @@ func TestScanStoresRawHashes(t *testing.T) {
 	}
 }
 
+// TestScanStoresDiskSize scans a sparse file, which takes less space on
+// disk than its length, once through its directory and once as the
+// operand itself. Each scan stores the disk_size of the file's lstat.
+func TestScanStoresDiskSize(t *testing.T) {
+	t.Parallel()
+
+	const length = 1024 * 1024
+
+	p := sparseFile(t, t.TempDir(), "sparse", length)
+	pokeAt(t, p, 0, []byte("x"))
+
+	unix.Sync() // see diskSizeOf
+
+	want := diskSizeOf(t, p)
+	if want == 0 || want >= length {
+		t.Fatalf("the file takes %d bytes on disk, want more than none "+
+			"and fewer than its length %d", want, length)
+	}
+
+	for _, operand := range []string{filepath.Dir(p), p} {
+		db := openTestDB(t)
+		syncTree(t, db, operand)
+
+		got := recordByPath(t, dbRecords(t, db), p).diskSize
+		if got != want {
+			t.Errorf("scan of %s: disk_size = %d, want %d",
+				operand, got, want)
+		}
+	}
+}
+
+// TestSyncScanRewriteUpdatesDiskSize writes into the hole of a scanned
+// sparse file and moves its mtime on. The rescan hashes the file again
+// and rewrites its record with the new disk_size.
+func TestSyncScanRewriteUpdatesDiskSize(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	db := openTestDB(t)
+	p := sparseFile(t, dir, "sparse", 1024*1024)
+	pokeAt(t, p, 0, []byte("x"))
+
+	syncTree(t, db, dir)
+
+	before := recordByPath(t, dbRecords(t, db), p).diskSize
+
+	pokeAt(t, p, 512*1024, pattern(7, 64*1024))
+
+	// The write may leave the mtime the scan recorded; a later one makes
+	// the rescan read the file again.
+	later := time.Now().Add(time.Hour)
+
+	err := os.Chtimes(p, later, later)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	unix.Sync() // see diskSizeOf
+
+	want := diskSizeOf(t, p)
+	if want == before {
+		t.Fatalf("the file still takes %d bytes on disk after the write "+
+			"into its hole", want)
+	}
+
+	st := syncTree(t, db, dir)
+	if st != (scanStats{walked: 1, updated: 1}) {
+		t.Fatalf("rescan stats = %+v, want 1 updated", st)
+	}
+
+	got := recordByPath(t, dbRecords(t, db), p).diskSize
+	if got != want {
+		t.Errorf("disk_size = %d, want %d", got, want)
+	}
+}
+
+// TestSyncScanUnchangedUpdatesDiskSize gives a file's record a
+// disk_size the file does not have, as when ZFS had not yet counted the
+// file's blocks at the last scan. The rescan writes the file's own
+// disk_size into the record without reading the file again.
+func TestSyncScanUnchangedUpdatesDiskSize(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	db := openTestDB(t)
+	p := writeFile(t, dir, "a.bin", pattern(1, 500))
+
+	syncTree(t, db, dir)
+
+	// lstat counts 512-byte units, so no file takes 1 byte on disk.
+	_, err := db.ExecContext(t.Context(),
+		"UPDATE files SET disk_size = 1 WHERE path = ?", []byte(p))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	unix.Sync() // see diskSizeOf
+
+	// A file read again would count as updated.
+	st := syncTree(t, db, dir)
+	if st != (scanStats{walked: 1, unchanged: 1}) {
+		t.Fatalf("rescan stats = %+v, want 1 unchanged", st)
+	}
+
+	got := recordByPath(t, dbRecords(t, db), p).diskSize
+	if want := diskSizeOf(t, p); got != want {
+		t.Errorf("disk_size = %d, want %d", got, want)
+	}
+}
+
 // TestSyncScanSameSecondRewrite rewrites a file in place at the same
 // size with an mtime later in the same second as the recorded one: the
 // next scan must notice the change and re-hash the file. The operand is