Fix inode time stamps. (#334)

* Cast values to those that are outlined in the kernel docs:
- Seconds as signed int32
- Extension as unsigned int32

* Decode the timestamp using the formula provided by the kernel doc.

* Add function to encode timestamps using the inverse of the kernel doc formula and write them to their targets.

* Expand `TestChtimes` to include all valid time ranges outlined in the kernel docs.

Author: StoneMonarch

filesystem/ext4/ext4_test.go

@@ -557,36 +557,65 @@ func TestChtimes(t *testing.T) {
 	if err != nil {
 		t.Fatalf("error opening file %s: %v", newfile, err)
 	}
-	fileImpl, ok := fileIntf.(*File)
-	if !ok {
-		t.Fatalf("could not cast to ext4.File")
-	}
-	ctime := fileImpl.createTime.Add(-30 * time.Minute)
-	atime := fileImpl.accessTime.Add(60 * time.Minute)
-	mtime := fileImpl.modifyTime.Add(120 * time.Minute)
+	fileIntf.Close()
 
-	if err := fs.Chtimes(newfile, ctime, atime, mtime); err != nil {
-		t.Fatalf("error changing times on file %s: %v", newfile, err)
-	}
-	// now check that it was updated
-	// get existing times
-	fileIntf, err = fs.OpenFile(newfile, os.O_RDONLY)
-	if err != nil {
-		t.Fatalf("error opening file %s: %v", newfile, err)
-	}
-	// ext4 only supports second-level time resolution
+	// ext4 supports 34-bit seconds and 30-bit nanoseconds
+	// We use 91 nanoseconds because it has the lowest 2 bits set (binary 1011011),
+	// which tests the bit-packing logic.
+	nano := 91
 
-	fileImpl, ok = fileIntf.(*File)
-	if !ok {
-		t.Fatalf("could not cast to ext4.File")
-	}
-	if fileImpl.createTime.Unix() != ctime.Unix() {
-		t.Errorf("mismatched create time, actual %v expected %v", fileImpl.createTime, ctime)
-	}
-	if fileImpl.accessTime.Unix() != atime.Unix() {
-		t.Errorf("mismatched access time, actual %v expected %v", fileImpl.accessTime, atime)
-	}
-	if fileImpl.modifyTime.Unix() != mtime.Unix() {
-		t.Errorf("mismatched modify time, actual %v expected %v", fileImpl.modifyTime, mtime)
+	tests := []struct {
+		name string
+		t    time.Time
+	}{
+		{"1901-1969", time.Date(1930, 1, 1, 0, 0, 0, nano, time.UTC)},
+		{"1970-2038", time.Date(2026, 1, 1, 0, 0, 0, nano, time.UTC)},
+		{"2038-2106", time.Date(2050, 1, 1, 0, 0, 0, nano, time.UTC)},
+		{"2106-2174", time.Date(2120, 1, 1, 0, 0, 0, nano, time.UTC)},
+		{"2174-2242", time.Date(2200, 1, 1, 0, 0, 0, nano, time.UTC)},
+		{"2242-2310", time.Date(2280, 1, 1, 0, 0, 0, nano, time.UTC)},
+		{"2310-2378", time.Date(2350, 1, 1, 0, 0, 0, nano, time.UTC)},
+		{"2378-2446", time.Date(2440, 1, 1, 0, 0, 0, nano, time.UTC)},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := fs.Chtimes(newfile, tt.t, tt.t, tt.t); err != nil {
+				t.Fatalf("error changing times on file %s: %v", newfile, err)
+			}
+
+			// now check that it was updated
+			fileIntf, err = fs.OpenFile(newfile, os.O_RDONLY)
+			if err != nil {
+				t.Fatalf("error opening file %s: %v", newfile, err)
+			}
+			defer fileIntf.Close()
+
+			fileImpl, ok := fileIntf.(*File)
+			if !ok {
+				t.Fatalf("could not cast to ext4.File")
+			}
+
+			if fileImpl.createTime.Unix() != tt.t.Unix() {
+				t.Errorf("mismatched create time seconds, actual %d (%v) expected %d (%v)", fileImpl.createTime.Unix(), fileImpl.createTime, tt.t.Unix(), tt.t)
+			}
+			if fileImpl.createTime.Nanosecond() != tt.t.Nanosecond() {
+				t.Errorf("mismatched create time nanoseconds, actual %d expected %d", fileImpl.createTime.Nanosecond(), tt.t.Nanosecond())
+			}
+
+			if fileImpl.accessTime.Unix() != tt.t.Unix() {
+				t.Errorf("mismatched access time seconds, actual %d (%v) expected %d (%v)", fileImpl.accessTime.Unix(), fileImpl.accessTime, tt.t.Unix(), tt.t)
+			}
+			if fileImpl.accessTime.Nanosecond() != tt.t.Nanosecond() {
+				t.Errorf("mismatched access time nanoseconds, actual %d expected %d", fileImpl.accessTime.Nanosecond(), tt.t.Nanosecond())
+			}
+
+			if fileImpl.modifyTime.Unix() != tt.t.Unix() {
+				t.Errorf("mismatched modify time seconds, actual %d (%v) expected %d (%v)", fileImpl.modifyTime.Unix(), fileImpl.modifyTime, tt.t.Unix(), tt.t)
+			}
+			if fileImpl.modifyTime.Nanosecond() != tt.t.Nanosecond() {
+				t.Errorf("mismatched modify time nanoseconds, actual %d expected %d", fileImpl.modifyTime.Nanosecond(), tt.t.Nanosecond())
+			}
+		})
 	}
 }

filesystem/ext4/inode.go

@@ -195,31 +195,29 @@ func inodeFromBytes(b []byte, sb *superblock, number uint32) (*inode, error) {
 	// Thus, the full 64-bit timestamp value is constructed as follows:
 	//  original 32 bits (0:4) are seconds. Add (to the left) 2 more bits from the 32
 	//  the remaining 30 bites are nanoseconds
-	accessTimeSeconds := uint64(binary.LittleEndian.Uint32(b[0x8:0xc]))
-	changeTimeSeconds := uint64(binary.LittleEndian.Uint32(b[0xc:0x10]))
-	modifyTimeSeconds := uint64(binary.LittleEndian.Uint32(b[0x10:0x14]))
-	createTimeSeconds := uint64(binary.LittleEndian.Uint32(b[0x90:0x94]))
-
-	accessTimeExtra := uint64(binary.LittleEndian.Uint32(b[0x8c:0x90]))
-	changeTimeExtra := uint64(binary.LittleEndian.Uint32(b[0x84:0x88]))
-	modifyTimeExtra := uint64(binary.LittleEndian.Uint32(b[0x88:0x8c]))
-	createTimeExtra := uint64(binary.LittleEndian.Uint32(b[0x94:0x98]))
-
-	accessTimeHigh := accessTimeExtra & 0x3
-	changeTimeHigh := changeTimeExtra & 0x3
-	modifyTimeHigh := modifyTimeExtra & 0x3
-	createTimeHigh := createTimeExtra & 0x3
-
-	accessTimeSeconds = (accessTimeHigh << 32) | accessTimeSeconds
-	changeTimeSeconds = (changeTimeHigh << 32) | changeTimeSeconds
-	modifyTimeSeconds = (modifyTimeHigh << 32) | modifyTimeSeconds
-	createTimeSeconds = (createTimeHigh << 32) | createTimeSeconds
-
-	// now get the nanoseconds by using the upper 30 bites
-	accessTimeNanoseconds := accessTimeExtra >> 2
-	changeTimeNanoseconds := changeTimeExtra >> 2
-	modifyTimeNanoseconds := modifyTimeExtra >> 2
-	createTimeNanoseconds := createTimeExtra >> 2
+	accessTimeSeconds := int32(binary.LittleEndian.Uint32(b[0x8:0xc]))
+	changeTimeSeconds := int32(binary.LittleEndian.Uint32(b[0xc:0x10]))
+	modifyTimeSeconds := int32(binary.LittleEndian.Uint32(b[0x10:0x14]))
+	createTimeSeconds := int32(binary.LittleEndian.Uint32(b[0x90:0x94]))
+
+	accessTimeExtra := binary.LittleEndian.Uint32(b[0x8c:0x90])
+	changeTimeExtra := binary.LittleEndian.Uint32(b[0x84:0x88])
+	modifyTimeExtra := binary.LittleEndian.Uint32(b[0x88:0x8c])
+	createTimeExtra := binary.LittleEndian.Uint32(b[0x94:0x98])
+
+	decodeTimestamp := func(seconds int32, extra uint32) (int64, int64) {
+		// The formula derived from the kernel documentation table is:
+		// Decoded = int64(int32(lower)) + (int64(extra_bits) << 32)
+		sec := int64(seconds) + (int64(extra&0x3) << 32)
+		// Nanoseconds are in the upper 30 bits
+		nano := int64(extra >> 2)
+		return sec, nano
+	}
+
+	atimeSec, atimeNano := decodeTimestamp(accessTimeSeconds, accessTimeExtra)
+	ctimeSec, ctimeNano := decodeTimestamp(changeTimeSeconds, changeTimeExtra)
+	mtimeSec, mtimeNano := decodeTimestamp(modifyTimeSeconds, modifyTimeExtra)
+	crtimeSec, crtimeNano := decodeTimestamp(createTimeSeconds, createTimeExtra)
 
 	flagsNum := binary.LittleEndian.Uint32(b[0x20:0x24])
 
@@ -287,10 +285,10 @@ func inodeFromBytes(b []byte, sb *superblock, number uint32) (*inode, error) {
 		version:                binary.LittleEndian.Uint64(version),
 		inodeSize:              binary.LittleEndian.Uint16(b[0x80:0x82]) + minInodeSize,
 		deletionTime:           binary.LittleEndian.Uint32(b[0x14:0x18]),
-		accessTime:             time.Unix(int64(accessTimeSeconds), int64(accessTimeNanoseconds)),
-		changeTime:             time.Unix(int64(changeTimeSeconds), int64(changeTimeNanoseconds)),
-		modifyTime:             time.Unix(int64(modifyTimeSeconds), int64(modifyTimeNanoseconds)),
-		createTime:             time.Unix(int64(createTimeSeconds), int64(createTimeNanoseconds)),
+		accessTime:             time.Unix(atimeSec, atimeNano),
+		changeTime:             time.Unix(ctimeSec, ctimeNano),
+		modifyTime:             time.Unix(mtimeSec, mtimeNano),
+		createTime:             time.Unix(crtimeSec, crtimeNano),
 		extendedAttributeBlock: binary.LittleEndian.Uint64(extendedAttributeBlock),
 		project:                binary.LittleEndian.Uint32(b[0x9c:0x100]),
 		extents:                allExtents,
@@ -332,17 +330,23 @@ func (i *inode) toBytes(sb *superblock) []byte {
 	binary.LittleEndian.PutUint64(version, i.version)
 	binary.LittleEndian.PutUint64(extendedAttributeBlock, i.extendedAttributeBlock)
 
-	// there is some odd stuff that ext4 does with nanoseconds. We might need this in the future.
+	// ext4 timestamps are 32 bits of seconds, plus an extra 32-bit field
+	// containing 30 bits of nanoseconds and 2 bits of extended seconds.
 	// See https://ext4.wiki.kernel.org/index.php/Ext4_Disk_Layout#Inode_Timestamps
-	// binary.LittleEndian.PutUint32(accessTime[4:8], (i.accessTimeNanoseconds<<2)&accessTime[4])
-	binary.LittleEndian.PutUint64(accessTime, uint64(i.accessTime.Unix()))
-	binary.LittleEndian.PutUint32(accessTime[4:8], uint32(i.accessTime.Nanosecond()))
-	binary.LittleEndian.PutUint64(createTime, uint64(i.createTime.Unix()))
-	binary.LittleEndian.PutUint32(createTime[4:8], uint32(i.createTime.Nanosecond()))
-	binary.LittleEndian.PutUint64(changeTime, uint64(i.changeTime.Unix()))
-	binary.LittleEndian.PutUint32(changeTime[4:8], uint32(i.changeTime.Nanosecond()))
-	binary.LittleEndian.PutUint64(modifyTime, uint64(i.modifyTime.Unix()))
-	binary.LittleEndian.PutUint32(modifyTime[4:8], uint32(i.modifyTime.Nanosecond()))
+	encodeAndWriteTimestamp := func(t time.Time, target []byte) {
+		seconds := t.Unix()
+		nanos := uint32(t.Nanosecond())
+		high := uint32((seconds-int64(int32(seconds)))>>32) & 0x3
+		extra := (nanos << 2) | high
+
+		binary.LittleEndian.PutUint32(target[0:4], uint32(seconds))
+		binary.LittleEndian.PutUint32(target[4:8], extra)
+	}
+
+	encodeAndWriteTimestamp(i.accessTime, accessTime)
+	encodeAndWriteTimestamp(i.createTime, createTime)
+	encodeAndWriteTimestamp(i.changeTime, changeTime)
+	encodeAndWriteTimestamp(i.modifyTime, modifyTime)
 
 	blocks := make([]byte, 8)
 	binary.LittleEndian.PutUint64(blocks, i.blocks)