Use Instant instead of milliseconds for filesystem timestamp handling

This enables higher file timestamp resolution on filesystems like ext4,
Mac APFS (1ns) or NTFS (100ns) providing high timestamp resolution on
filesystem level.

Note:
- on some OSes Java 8,9 truncate milliseconds, see
https://bugs.openjdk.java.net/browse/JDK-8177809, fixed in Java 10
- UnixFileAttributes truncates timestamp resolution to microseconds when
converting the internal representation to FileTime exposed in the API,
see https://bugs.openjdk.java.net/browse/JDK-8181493
- WindowsFileAttributes also provides only microsecond resolution

Change-Id: I25ffff31a3c6f725fc345d4ddc2f26da3b88f6f2
Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>

23 files changed, 438 insertions, 123 deletions

diff --git a/org.eclipse.jgit/.settings/.api_filters b/org.eclipse.jgit/.settings/.api_filters
index 5f58e7e457..951a5e30f8 100644
--- a/org.eclipse.jgit/.settings/.api_filters
+++ b/org.eclipse.jgit/.settings/.api_filters
@@ -8,6 +8,20 @@
             </message_arguments>
         </filter>
     </resource>
+    <resource path="src/org/eclipse/jgit/dircache/DirCacheEntry.java" type="org.eclipse.jgit.dircache.DirCacheEntry">
+        <filter id="1142947843">
+            <message_arguments>
+                <message_argument value="5.1.9"/>
+                <message_argument value="getLastModifiedInstant()"/>
+            </message_arguments>
+        </filter>
+        <filter id="1142947843">
+            <message_arguments>
+                <message_argument value="5.1.9"/>
+                <message_argument value="setLastModified(Instant)"/>
+            </message_arguments>
+        </filter>
+    </resource>
     <resource path="src/org/eclipse/jgit/errors/PackInvalidException.java" type="org.eclipse.jgit.errors.PackInvalidException">
         <filter id="1142947843">
             <message_arguments>
@@ -130,6 +144,28 @@
             </message_arguments>
         </filter>
     </resource>
+    <resource path="src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java" type="org.eclipse.jgit.treewalk.WorkingTreeIterator">
+        <filter id="1142947843">
+            <message_arguments>
+                <message_argument value="5.1.9"/>
+                <message_argument value="getEntryLastModifiedInstant()"/>
+            </message_arguments>
+        </filter>
+    </resource>
+    <resource path="src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java" type="org.eclipse.jgit.treewalk.WorkingTreeIterator$Entry">
+        <filter id="336695337">
+            <message_arguments>
+                <message_argument value="org.eclipse.jgit.treewalk.WorkingTreeIterator.Entry"/>
+                <message_argument value="getLastModifiedInstant()"/>
+            </message_arguments>
+        </filter>
+        <filter id="1142947843">
+            <message_arguments>
+                <message_argument value="5.1.9"/>
+                <message_argument value="getLastModifiedInstant()"/>
+            </message_arguments>
+        </filter>
+    </resource>
     <resource path="src/org/eclipse/jgit/util/FS.java" type="org.eclipse.jgit.util.FS">
         <filter id="1142947843">
             <message_arguments>
@@ -140,16 +176,42 @@
         <filter id="1142947843">
             <message_arguments>
                 <message_argument value="5.1.9"/>
+                <message_argument value="lastModifiedInstant(File)"/>
+            </message_arguments>
+        </filter>
+        <filter id="1142947843">
+            <message_arguments>
+                <message_argument value="5.1.9"/>
+                <message_argument value="lastModifiedInstant(Path)"/>
+            </message_arguments>
+        </filter>
+        <filter id="1142947843">
+            <message_arguments>
+                <message_argument value="5.1.9"/>
                 <message_argument value="setAsyncfileStoreAttrCache(boolean)"/>
             </message_arguments>
         </filter>
         <filter id="1142947843">
             <message_arguments>
+                <message_argument value="5.1.9"/>
+                <message_argument value="setLastModified(Path, Instant)"/>
+            </message_arguments>
+        </filter>
+        <filter id="1142947843">
+            <message_arguments>
                 <message_argument value="5.2.3"/>
                 <message_argument value="getFsTimerResolution(Path)"/>
             </message_arguments>
         </filter>
     </resource>
+    <resource path="src/org/eclipse/jgit/util/FS.java" type="org.eclipse.jgit.util.FS$Attributes">
+        <filter id="1142947843">
+            <message_arguments>
+                <message_argument value="5.1.9"/>
+                <message_argument value="getLastModifiedInstant()"/>
+            </message_arguments>
+        </filter>
+    </resource>
     <resource path="src/org/eclipse/jgit/util/FileUtils.java" type="org.eclipse.jgit.util.FileUtils">
         <filter id="1142947843">
             <message_arguments>
diff --git a/org.eclipse.jgit/resources/org/eclipse/jgit/internal/JGitText.properties b/org.eclipse.jgit/resources/org/eclipse/jgit/internal/JGitText.properties
index 9af6cce59d..6ac6955f06 100644
--- a/org.eclipse.jgit/resources/org/eclipse/jgit/internal/JGitText.properties
+++ b/org.eclipse.jgit/resources/org/eclipse/jgit/internal/JGitText.properties
@@ -561,6 +561,7 @@ rawLogMessageDoesNotParseAsLogEntry=Raw log message does not parse as log entry
 readConfigFailed=Reading config file ''{0}'' failed
 readerIsRequired=Reader is required
 readingObjectsFromLocalRepositoryFailed=reading objects from local repository failed: {0}
+readLastModifiedFailed=Reading lastModified of {0} failed
 readTimedOut=Read timed out after {0} ms
 receivePackObjectTooLarge1=Object too large, rejecting the pack. Max object size limit is {0} bytes.
 receivePackObjectTooLarge2=Object too large ({0} bytes), rejecting the pack. Max object size limit is {1} bytes.
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/api/AddCommand.java b/org.eclipse.jgit/src/org/eclipse/jgit/api/AddCommand.java
index f0408ab3d4..a2cd4aeb2a 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/api/AddCommand.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/api/AddCommand.java
@@ -50,6 +50,7 @@ import static org.eclipse.jgit.lib.FileMode.TYPE_TREE;
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.time.Instant;
 import java.util.Collection;
 import java.util.LinkedList;
 
@@ -228,7 +229,7 @@ public class AddCommand extends GitCommand<DirCache> {
 
 				if (GITLINK != mode) {
 					entry.setLength(f.getEntryLength());
-					entry.setLastModified(f.getEntryLastModified());
+					entry.setLastModified(f.getEntryLastModifiedInstant());
 					long len = f.getEntryContentLength();
 					// We read and filter the content multiple times.
 					// f.getEntryContentLength() reads and filters the input and
@@ -241,7 +242,7 @@ public class AddCommand extends GitCommand<DirCache> {
 					}
 				} else {
 					entry.setLength(0);
-					entry.setLastModified(0);
+					entry.setLastModified(Instant.ofEpochSecond(0));
 					entry.setObjectId(f.getEntryObjectId());
 				}
 				builder.add(entry);
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java b/org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java
index d07532c092..cea28fac18 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/api/CommitCommand.java
@@ -392,7 +392,7 @@ public class CommitCommand extends GitCommand<RevCommit> {
 						final DirCacheEntry dcEntry = new DirCacheEntry(path);
 						long entryLength = fTree.getEntryLength();
 						dcEntry.setLength(entryLength);
-						dcEntry.setLastModified(fTree.getEntryLastModified());
+						dcEntry.setLastModified(fTree.getEntryLastModifiedInstant());
 						dcEntry.setFileMode(fTree.getIndexFileMode(dcTree));
 
 						boolean objectExists = (dcTree != null
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/api/ResetCommand.java b/org.eclipse.jgit/src/org/eclipse/jgit/api/ResetCommand.java
index 13ce4e7690..d7c9ad5e04 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/api/ResetCommand.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/api/ResetCommand.java
@@ -422,7 +422,7 @@ public class ResetCommand extends GitCommand<Ref> {
 						DirCacheIterator.class);
 				if (dcIter != null && dcIter.idEqual(cIter)) {
 					DirCacheEntry indexEntry = dcIter.getDirCacheEntry();
-					entry.setLastModified(indexEntry.getLastModified());
+					entry.setLastModified(indexEntry.getLastModifiedInstant());
 					entry.setLength(indexEntry.getLength());
 				}
 
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/api/StashApplyCommand.java b/org.eclipse.jgit/src/org/eclipse/jgit/api/StashApplyCommand.java
index 01d070cbd9..ff7c4c64bc 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/api/StashApplyCommand.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/api/StashApplyCommand.java
@@ -332,7 +332,7 @@ public class StashApplyCommand extends GitCommand<ObjectId> {
 						DirCacheIterator.class);
 				if (dcIter != null && dcIter.idEqual(cIter)) {
 					DirCacheEntry indexEntry = dcIter.getDirCacheEntry();
-					entry.setLastModified(indexEntry.getLastModified());
+					entry.setLastModified(indexEntry.getLastModifiedInstant());
 					entry.setLength(indexEntry.getLength());
 				}
 
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/api/StashCreateCommand.java b/org.eclipse.jgit/src/org/eclipse/jgit/api/StashCreateCommand.java
index c32890d8a4..0d010adb26 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/api/StashCreateCommand.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/api/StashCreateCommand.java
@@ -300,7 +300,8 @@ public class StashCreateCommand extends GitCommand<RevCommit> {
 						final DirCacheEntry entry = new DirCacheEntry(
 								treeWalk.getRawPath());
 						entry.setLength(wtIter.getEntryLength());
-						entry.setLastModified(wtIter.getEntryLastModified());
+						entry.setLastModified(
+								wtIter.getEntryLastModifiedInstant());
 						entry.setFileMode(wtIter.getEntryFileMode());
 						long contentLength = wtIter.getEntryContentLength();
 						try (InputStream in = wtIter.openEntryStream()) {
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCache.java b/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCache.java
index 14653fe17f..340214b068 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCache.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCache.java
@@ -497,8 +497,9 @@ public class DirCache {
 			throw new CorruptObjectException(JGitText.get().DIRCHasTooManyEntries);
 
 		snapshot = FileSnapshot.save(liveFile);
-		int smudge_s = (int) (snapshot.lastModified() / 1000);
-		int smudge_ns = ((int) (snapshot.lastModified() % 1000)) * 1000000;
+		// TODO (ms) combine smudge_s and smudge_ns into Duration
+		int smudge_s = (int) (snapshot.lastModifiedInstant().getEpochSecond());
+		int smudge_ns = snapshot.lastModifiedInstant().getNano();
 
 		// Load the individual file entries.
 		//
@@ -679,8 +680,8 @@ public class DirCache {
 			// so we use the current timestamp as a approximation.
 			myLock.createCommitSnapshot();
 			snapshot = myLock.getCommitSnapshot();
-			smudge_s = (int) (snapshot.lastModified() / 1000);
-			smudge_ns = ((int) (snapshot.lastModified() % 1000)) * 1000000;
+			smudge_s = (int) (snapshot.lastModifiedInstant().getEpochSecond());
+			smudge_ns = snapshot.lastModifiedInstant().getNano();
 		} else {
 			// Used in unit tests only
 			smudge_ns = 0;
@@ -1025,7 +1026,7 @@ public class DirCache {
 				DirCacheEntry entry = iIter.getDirCacheEntry();
 				if (entry.isSmudged() && iIter.idEqual(fIter)) {
 					entry.setLength(fIter.getEntryLength());
-					entry.setLastModified(fIter.getEntryLastModified());
+					entry.setLastModified(fIter.getEntryLastModifiedInstant());
 				}
 			}
 		}
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheCheckout.java b/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheCheckout.java
index ca1e3ab275..5110d77dc9 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheCheckout.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheCheckout.java
@@ -50,6 +50,7 @@ import java.io.IOException;
 import java.io.OutputStream;
 import java.nio.file.StandardCopyOption;
 import java.text.MessageFormat;
+import java.time.Instant;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -425,8 +426,10 @@ public class DirCacheCheckout {
 					// update the timestamp of the index with the one from the
 					// file if not set, as we are sure to be in sync here.
 					DirCacheEntry entry = i.getDirCacheEntry();
-					if (entry.getLastModified() == 0)
-						entry.setLastModified(f.getEntryLastModified());
+					Instant mtime = entry.getLastModifiedInstant();
+					if (mtime == null || mtime.equals(Instant.EPOCH)) {
+						entry.setLastModified(f.getEntryLastModifiedInstant());
+					}
 					keep(entry);
 				}
 			} else
@@ -611,7 +614,7 @@ public class DirCacheCheckout {
 		File gitlinkDir = new File(repo.getWorkTree(), path);
 		FileUtils.mkdirs(gitlinkDir, true);
 		FS fs = repo.getFS();
-		entry.setLastModified(fs.lastModified(gitlinkDir));
+		entry.setLastModified(fs.lastModifiedInstant(gitlinkDir));
 	}
 
 	private static ArrayList<String> filterOut(ArrayList<String> strings,
@@ -1433,7 +1436,7 @@ public class DirCacheCheckout {
 			}
 			fs.createSymLink(f, target);
 			entry.setLength(bytes.length);
-			entry.setLastModified(fs.lastModified(f));
+			entry.setLastModified(fs.lastModifiedInstant(f));
 			return;
 		}
 
@@ -1502,7 +1505,7 @@ public class DirCacheCheckout {
 				FileUtils.delete(tmpFile);
 			}
 		}
-		entry.setLastModified(fs.lastModified(f));
+		entry.setLastModified(fs.lastModifiedInstant(f));
 	}
 
 	// Run an external filter command
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheEntry.java b/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheEntry.java
index 6b1d4f4d8a..4b36f6b96b 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheEntry.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheEntry.java
@@ -56,6 +56,7 @@ import java.io.OutputStream;
 import java.nio.ByteBuffer;
 import java.security.MessageDigest;
 import java.text.MessageFormat;
+import java.time.Instant;
 import java.util.Arrays;
 
 import org.eclipse.jgit.errors.CorruptObjectException;
@@ -144,6 +145,7 @@ public class DirCacheEntry {
 	/** Flags which are never stored to disk. */
 	private byte inCoreFlags;
 
+	// TODO (ms): use Instant to combine smudge_s and smudge_ns
 	DirCacheEntry(final byte[] sharedInfo, final MutableInteger infoAt,
 			final InputStream in, final MessageDigest md, final int smudge_s,
 			final int smudge_ns) throws IOException {
@@ -563,22 +565,51 @@ public class DirCacheEntry {
 	 *
 	 * @return last modification time of this file, in milliseconds since the
 	 *         Java epoch (midnight Jan 1, 1970 UTC).
+	 * @deprecated use {@link #getLastModifiedInstant()} instead
 	 */
+	@Deprecated
 	public long getLastModified() {
 		return decodeTS(P_MTIME);
 	}
 
 	/**
+	 * Get the cached last modification date of this file.
+	 * <p>
+	 * One of the indicators that the file has been modified by an application
+	 * changing the working tree is if the last modification time for the file
+	 * differs from the time stored in this entry.
+	 *
+	 * @return last modification time of this file.
+	 * @since 5.1.9
+	 */
+	public Instant getLastModifiedInstant() {
+		return decodeTSInstant(P_MTIME);
+	}
+
+	/**
 	 * Set the cached last modification date of this file, using milliseconds.
 	 *
 	 * @param when
 	 *            new cached modification date of the file, in milliseconds.
+	 * @deprecated use {@link #setLastModified(Instant)} instead
 	 */
+	@Deprecated
 	public void setLastModified(long when) {
 		encodeTS(P_MTIME, when);
 	}
 
 	/**
+	 * Set the cached last modification date of this file.
+	 *
+	 * @param when
+	 *            new cached modification date of the file.
+	 * @since 5.1.9
+	 */
+	public void setLastModified(Instant when) {
+		encodeTS(P_MTIME, when);
+	}
+
+	/**
 	 * Get the cached size (mod 4 GB) (in bytes) of this file.
 	 * <p>
 	 * One of the indicators that the file has been modified by an application
@@ -692,7 +723,8 @@ public class DirCacheEntry {
 	@SuppressWarnings("nls")
 	@Override
 	public String toString() {
-		return getFileMode() + " " + getLength() + " " + getLastModified()
+		return getFileMode() + " " + getLength() + " "
+				+ getLastModifiedInstant()
 				+ " " + getObjectId() + " " + getStage() + " "
 				+ getPathString() + "\n";
 	}
@@ -750,12 +782,25 @@ public class DirCacheEntry {
 		return 1000L * sec + ms;
 	}
 
+	private Instant decodeTSInstant(int pIdx) {
+		final int base = infoOffset + pIdx;
+		final int sec = NB.decodeInt32(info, base);
+		final int nano = NB.decodeInt32(info, base + 4);
+		return Instant.ofEpochSecond(sec, nano);
+	}
+
 	private void encodeTS(int pIdx, long when) {
 		final int base = infoOffset + pIdx;
 		NB.encodeInt32(info, base, (int) (when / 1000));
 		NB.encodeInt32(info, base + 4, ((int) (when % 1000)) * 1000000);
 	}
 
+	private void encodeTS(int pIdx, Instant when) {
+		final int base = infoOffset + pIdx;
+		NB.encodeInt32(info, base, (int) when.getEpochSecond());
+		NB.encodeInt32(info, base + 4, when.getNano());
+	}
+
 	private int getExtendedFlags() {
 		if (isExtended())
 			return NB.decodeUInt16(info, infoOffset + P_FLAGS2) << 16;
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/JGitText.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/JGitText.java
index 79133d203c..38c063d071 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/JGitText.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/JGitText.java
@@ -622,6 +622,7 @@ public class JGitText extends TranslationBundle {
 	/***/ public String readConfigFailed;
 	/***/ public String readerIsRequired;
 	/***/ public String readingObjectsFromLocalRepositoryFailed;
+	/***/ public String readLastModifiedFailed;
 	/***/ public String readTimedOut;
 	/***/ public String receivePackObjectTooLarge1;
 	/***/ public String receivePackObjectTooLarge2;
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/FileSnapshot.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/FileSnapshot.java
index 1b13ccf765..fe3703719c 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/FileSnapshot.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/FileSnapshot.java
@@ -48,10 +48,10 @@ import static org.eclipse.jgit.lib.Constants.FALLBACK_TIMESTAMP_RESOLUTION;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.attribute.BasicFileAttributes;
-import java.text.DateFormat;
-import java.text.SimpleDateFormat;
 import java.time.Duration;
-import java.util.Date;
+import java.time.Instant;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
 import java.util.Locale;
 import java.util.Objects;
 import java.util.concurrent.TimeUnit;
@@ -87,8 +87,14 @@ public class FileSnapshot {
 	 */
 	public static final long UNKNOWN_SIZE = -1;
 
+	private static final Instant UNKNOWN_TIME = Instant.ofEpochMilli(-1);
+
 	private static final Object MISSING_FILEKEY = new Object();
 
+	private static final DateTimeFormatter dateFmt = DateTimeFormatter
+			.ofPattern("yyyy-MM-dd HH:mm:ss.nnnnnnnnn") //$NON-NLS-1$
+			.withLocale(Locale.getDefault()).withZone(ZoneId.systemDefault());
+
 	/**
 	 * A FileSnapshot that is considered to always be modified.
 	 * <p>
@@ -96,8 +102,8 @@ public class FileSnapshot {
 	 * file, but only after {@link #isModified(File)} gets invoked. The returned
 	 * snapshot contains only invalid status information.
 	 */
-	public static final FileSnapshot DIRTY = new FileSnapshot(-1, -1,
-			UNKNOWN_SIZE, Duration.ZERO, MISSING_FILEKEY);
+	public static final FileSnapshot DIRTY = new FileSnapshot(UNKNOWN_TIME,
+			UNKNOWN_TIME, UNKNOWN_SIZE, Duration.ZERO, MISSING_FILEKEY);
 
 	/**
 	 * A FileSnapshot that is clean if the file does not exist.
@@ -106,8 +112,8 @@ public class FileSnapshot {
 	 * file to be clean. {@link #isModified(File)} will return false if the file
 	 * path does not exist.
 	 */
-	public static final FileSnapshot MISSING_FILE = new FileSnapshot(0, 0, 0,
-			Duration.ZERO, MISSING_FILEKEY) {
+	public static final FileSnapshot MISSING_FILE = new FileSnapshot(
+			Instant.EPOCH, Instant.EPOCH, 0, Duration.ZERO, MISSING_FILEKEY) {
 		@Override
 		public boolean isModified(File path) {
 			return FS.DETECTED.exists(path);
@@ -163,18 +169,41 @@ public class FileSnapshot {
 	 * @param modified
 	 *            the last modification time of the file
 	 * @return the snapshot.
+	 * @deprecated use {@link #save(Instant)} instead.
 	 */
+	@Deprecated
 	public static FileSnapshot save(long modified) {
-		final long read = System.currentTimeMillis();
+		final Instant read = Instant.now();
+		return new FileSnapshot(read, Instant.ofEpochMilli(modified),
+				UNKNOWN_SIZE, Duration.ZERO, MISSING_FILEKEY);
+	}
+
+	/**
+	 * Record a snapshot for a file for which the last modification time is
+	 * already known.
+	 * <p>
+	 * This method should be invoked before the file is accessed.
+	 * <p>
+	 * Note that this method cannot rely on measuring file timestamp resolution
+	 * to avoid racy git issues caused by finite file timestamp resolution since
+	 * it's unknown in which filesystem the file is located. Hence the worst
+	 * case fallback for timestamp resolution is used.
+	 *
+	 * @param modified
+	 *            the last modification time of the file
+	 * @return the snapshot.
+	 */
+	public static FileSnapshot save(Instant modified) {
+		final Instant read = Instant.now();
 		return new FileSnapshot(read, modified, UNKNOWN_SIZE, Duration.ZERO,
 				MISSING_FILEKEY);
 	}
 
 	/** Last observed modification time of the path. */
-	private final long lastModified;
+	private final Instant lastModified;
 
 	/** Last wall-clock time the path was read. */
-	private volatile long lastRead;
+	private volatile Instant lastRead;
 
 	/** True once {@link #lastRead} is far later than {@link #lastModified}. */
 	private boolean cannotBeRacilyClean;
@@ -222,7 +251,7 @@ public class FileSnapshot {
 	 */
 	protected FileSnapshot(File file, boolean useConfig) {
 		this.file = file;
-		this.lastRead = System.currentTimeMillis();
+		this.lastRead = Instant.now();
 		this.fsTimestampResolution = useConfig
 				? FS.getFsTimerResolution(file.toPath().getParent())
 				: FALLBACK_TIMESTAMP_RESOLUTION;
@@ -230,18 +259,20 @@ public class FileSnapshot {
 		try {
 			fileAttributes = FS.DETECTED.fileAttributes(file);
 		} catch (IOException e) {
-			this.lastModified = file.lastModified();
+			this.lastModified = Instant.ofEpochMilli(file.lastModified());
 			this.size = file.length();
 			this.fileKey = MISSING_FILEKEY;
 			return;
 		}
-		this.lastModified = fileAttributes.lastModifiedTime().toMillis();
+		this.lastModified = fileAttributes.lastModifiedTime().toInstant();
 		this.size = fileAttributes.size();
 		this.fileKey = getFileKey(fileAttributes);
-		LOG.debug("file={}, create new FileSnapshot: lastRead={} ms" //$NON-NLS-1$
-				+ ", lastModified={} ms, size={}, fileKey={}", //$NON-NLS-1$
-				file, Long.valueOf(lastRead), Long.valueOf(lastModified),
-				Long.valueOf(size), fileKey);
+		if (LOG.isDebugEnabled()) {
+			LOG.debug("file={}, create new FileSnapshot: lastRead={}, lastModified={}, size={}, fileKey={}", //$NON-NLS-1$
+					file, dateFmt.format(lastRead),
+					dateFmt.format(lastModified), Long.valueOf(size),
+					fileKey.toString());
+		}
 	}
 
 	private boolean sizeChanged;
@@ -252,7 +283,7 @@ public class FileSnapshot {
 
 	private boolean wasRacyClean;
 
-	private FileSnapshot(long read, long modified, long size,
+	private FileSnapshot(Instant read, Instant modified, long size,
 			@NonNull Duration fsTimestampResolution, @NonNull Object fileKey) {
 		this.file = null;
 		this.lastRead = read;
@@ -266,8 +297,19 @@ public class FileSnapshot {
 	 * Get time of last snapshot update
 	 *
 	 * @return time of last snapshot update
+	 * @deprecated use {@link #lastModifiedInstant()} instead
 	 */
+	@Deprecated
 	public long lastModified() {
+		return lastModified.toEpochMilli();
+	}
+
+	/**
+	 * Get time of last snapshot update
+	 *
+	 * @return time of last snapshot update
+	 */
+	public Instant lastModifiedInstant() {
 		return lastModified;
 	}
 
@@ -286,16 +328,16 @@ public class FileSnapshot {
 	 * @return true if the path needs to be read again.
 	 */
 	public boolean isModified(File path) {
-		long currLastModified;
+		Instant currLastModified;
 		long currSize;
 		Object currFileKey;
 		try {
 			BasicFileAttributes fileAttributes = FS.DETECTED.fileAttributes(path);
-			currLastModified = fileAttributes.lastModifiedTime().toMillis();
+			currLastModified = fileAttributes.lastModifiedTime().toInstant();
 			currSize = fileAttributes.size();
 			currFileKey = getFileKey(fileAttributes);
 		} catch (IOException e) {
-			currLastModified = path.lastModified();
+			currLastModified = Instant.ofEpochMilli(path.lastModified());
 			currSize = path.length();
 			currFileKey = MISSING_FILEKEY;
 		}
@@ -337,7 +379,7 @@ public class FileSnapshot {
 	 *            the other snapshot.
 	 */
 	public void setClean(FileSnapshot other) {
-		final long now = other.lastRead;
+		final Instant now = other.lastRead;
 		if (!isRacyClean(now)) {
 			cannotBeRacilyClean = true;
 		}
@@ -351,7 +393,7 @@ public class FileSnapshot {
 	 *             if sleep was interrupted
 	 */
 	public void waitUntilNotRacy() throws InterruptedException {
-		while (isRacyClean(System.currentTimeMillis())) {
+		while (isRacyClean(Instant.now())) {
 			TimeUnit.NANOSECONDS
 					.sleep((fsTimestampResolution.toNanos() + 1) * 11 / 10);
 		}
@@ -366,7 +408,7 @@ public class FileSnapshot {
 	 */
 	public boolean equals(FileSnapshot other) {
 		boolean sizeEq = size == UNKNOWN_SIZE || other.size == UNKNOWN_SIZE || size == other.size;
-		return lastModified == other.lastModified && sizeEq
+		return lastModified.equals(other.lastModified) && sizeEq
 				&& Objects.equals(fileKey, other.fileKey);
 	}
 
@@ -389,8 +431,7 @@ public class FileSnapshot {
 	/** {@inheritDoc} */
 	@Override
 	public int hashCode() {
-		return Objects.hash(Long.valueOf(lastModified), Long.valueOf(size),
-				fileKey);
+		return Objects.hash(lastModified, Long.valueOf(size), fileKey);
 	}
 
 	/**
@@ -435,34 +476,37 @@ public class FileSnapshot {
 		if (this == MISSING_FILE) {
 			return "MISSING_FILE";
 		}
-		DateFormat f = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS",
-				Locale.US);
-		return "FileSnapshot[modified: " + f.format(new Date(lastModified))
-				+ ", read: " + f.format(new Date(lastRead)) + ", size:" + size
+		return "FileSnapshot[modified: " + dateFmt.format(lastModified)
+				+ ", read: " + dateFmt.format(lastRead) + ", size:" + size
 				+ ", fileKey: " + fileKey + "]";
 	}
 
-	private boolean isRacyClean(long read) {
+	private boolean isRacyClean(Instant read) {
 		// add a 10% safety margin
 		long racyNanos = (fsTimestampResolution.toNanos() + 1) * 11 / 10;
-		long delta = (read - lastModified) * 1_000_000;
+		long delta = Duration.between(lastModified, read).toNanos();
 		wasRacyClean = delta <= racyNanos;
-		LOG.debug("file={}, isRacyClean={}, read={} ms, lastModified={} ms," //$NON-NLS-1$
-				+ " delta={} ns, racy<={} ns", //$NON-NLS-1$
-				file, Boolean.valueOf(wasRacyClean), Long.valueOf(read),
-				Long.valueOf(lastModified), Long.valueOf(delta),
-				Long.valueOf(racyNanos));
+		if (LOG.isDebugEnabled()) {
+			LOG.debug(
+					"file={}, isRacyClean={}, read={}, lastModified={}, delta={} ns, racy<={} ns", //$NON-NLS-1$
+					file, Boolean.valueOf(wasRacyClean), dateFmt.format(read),
+					dateFmt.format(lastModified), Long.valueOf(delta),
+					Long.valueOf(racyNanos));
+		}
 		return wasRacyClean;
 	}
 
-	private boolean isModified(long currLastModified) {
+	private boolean isModified(Instant currLastModified) {
 		// Any difference indicates the path was modified.
 
-		lastModifiedChanged = lastModified != currLastModified;
+		lastModifiedChanged = !lastModified.equals(currLastModified);
 		if (lastModifiedChanged) {
-			LOG.debug("file={}, lastModified changed from {} to {}", //$NON-NLS-1$
-					file, Long.valueOf(lastModified),
-					Long.valueOf(currLastModified));
+			if (LOG.isDebugEnabled()) {
+				LOG.debug(
+						"file={}, lastModified changed from {} to {}", //$NON-NLS-1$
+						file, dateFmt.format(lastModified),
+						dateFmt.format(currLastModified));
+			}
 			return true;
 		}
 
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/GC.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/GC.java
index 3c830e88c1..791a108289 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/GC.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/GC.java
@@ -372,8 +372,9 @@ public class GC {
 					continue oldPackLoop;
 
 			if (!oldPack.shouldBeKept()
-					&& repo.getFS().lastModified(
-							oldPack.getPackFile()) < packExpireDate) {
+					&& repo.getFS()
+							.lastModifiedInstant(oldPack.getPackFile())
+							.toEpochMilli() < packExpireDate) {
 				oldPack.close();
 				if (shouldLoosen) {
 					loosen(inserter, reader, oldPack, ids);
@@ -561,8 +562,10 @@ public class GC {
 					String fName = f.getName();
 					if (fName.length() != Constants.OBJECT_ID_STRING_LENGTH - 2)
 						continue;
-					if (repo.getFS().lastModified(f) >= expireDate)
+					if (repo.getFS().lastModifiedInstant(f)
+							.toEpochMilli() >= expireDate) {
 						continue;
+					}
 					try {
 						ObjectId id = ObjectId.fromString(d + fName);
 						if (objectsToKeep.contains(id))
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/LockFile.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/LockFile.java
index b80c58ca9c..ccca0279aa 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/LockFile.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/LockFile.java
@@ -56,8 +56,11 @@ import java.io.OutputStream;
 import java.nio.ByteBuffer;
 import java.nio.channels.Channels;
 import java.nio.channels.FileChannel;
+import java.nio.file.Files;
 import java.nio.file.StandardCopyOption;
+import java.nio.file.attribute.FileTime;
 import java.text.MessageFormat;
+import java.time.Instant;
 
 import org.eclipse.jgit.internal.JGitText;
 import org.eclipse.jgit.lib.Constants;
@@ -424,7 +427,12 @@ public class LockFile {
 		FileSnapshot n = FileSnapshot.save(lck);
 		while (o.equals(n)) {
 			Thread.sleep(25 /* milliseconds */);
-			lck.setLastModified(System.currentTimeMillis());
+			try {
+				Files.setLastModifiedTime(lck.toPath(),
+						FileTime.from(Instant.now()));
+			} catch (IOException e) {
+				n.waitUntilNotRacy();
+			}
 			n = FileSnapshot.save(lck);
 		}
 	}
@@ -474,12 +482,23 @@ public class LockFile {
 	 * Get the modification time of the output file when it was committed.
 	 *
 	 * @return modification time of the lock file right before we committed it.
+	 * @deprecated use {@link #getCommitLastModifiedInstant()} instead
 	 */
+	@Deprecated
 	public long getCommitLastModified() {
 		return commitSnapshot.lastModified();
 	}
 
 	/**
+	 * Get the modification time of the output file when it was committed.
+	 *
+	 * @return modification time of the lock file right before we committed it.
+	 */
+	public Instant getCommitLastModifiedInstant() {
+		return commitSnapshot.lastModifiedInstant();
+	}
+
+	/**
 	 * Get the {@link FileSnapshot} just before commit.
 	 *
 	 * @return get the {@link FileSnapshot} just before commit.
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/PackFile.java b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/PackFile.java
index 73ad38c95a..88e05af414 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/PackFile.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/PackFile.java
@@ -60,6 +60,7 @@ import java.nio.channels.FileChannel.MapMode;
 import java.nio.file.AccessDeniedException;
 import java.nio.file.NoSuchFileException;
 import java.text.MessageFormat;
+import java.time.Instant;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
@@ -107,7 +108,7 @@ public class PackFile implements Iterable<PackIndex.MutableEntry> {
 	public static final Comparator<PackFile> SORT = new Comparator<PackFile>() {
 		@Override
 		public int compare(PackFile a, PackFile b) {
-			return b.packLastModified - a.packLastModified;
+			return b.packLastModified.compareTo(a.packLastModified);
 		}
 	};
 
@@ -132,7 +133,7 @@ public class PackFile implements Iterable<PackIndex.MutableEntry> {
 
 	private int activeCopyRawData;
 
-	int packLastModified;
+	Instant packLastModified;
 
 	private PackFileSnapshot fileSnapshot;
 
@@ -172,7 +173,7 @@ public class PackFile implements Iterable<PackIndex.MutableEntry> {
 	public PackFile(File packFile, int extensions) {
 		this.packFile = packFile;
 		this.fileSnapshot = PackFileSnapshot.save(packFile);
-		this.packLastModified = (int) (fileSnapshot.lastModified() >> 10);
+		this.packLastModified = fileSnapshot.lastModifiedInstant();
 		this.extensions = extensions;
 
 		// Multiply by 31 here so we can more directly combine with another
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/merge/ResolveMerger.java b/org.eclipse.jgit/src/org/eclipse/jgit/merge/ResolveMerger.java
index f60c95f647..d4282e0b85 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/merge/ResolveMerger.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/merge/ResolveMerger.java
@@ -46,6 +46,7 @@
  */
 package org.eclipse.jgit.merge;
 
+import static java.time.Instant.EPOCH;
 import static org.eclipse.jgit.diff.DiffAlgorithm.SupportedAlgorithm.HISTOGRAM;
 import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_DIFF_SECTION;
 import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_ALGORITHM;
@@ -59,6 +60,7 @@ import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.time.Instant;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -464,7 +466,7 @@ public class ResolveMerger extends ThreeWayMerger {
 	 * @return the entry which was added to the index
 	 */
 	private DirCacheEntry add(byte[] path, CanonicalTreeParser p, int stage,
-			long lastMod, long len) {
+			Instant lastMod, long len) {
 		if (p != null && !p.getEntryFileMode().equals(FileMode.TREE)) {
 			DirCacheEntry e = new DirCacheEntry(path, stage);
 			e.setFileMode(p.getEntryFileMode());
@@ -491,7 +493,7 @@ public class ResolveMerger extends ThreeWayMerger {
 				e.getStage());
 		newEntry.setFileMode(e.getFileMode());
 		newEntry.setObjectId(e.getObjectId());
-		newEntry.setLastModified(e.getLastModified());
+		newEntry.setLastModified(e.getLastModifiedInstant());
 		newEntry.setLength(e.getLength());
 		builder.add(newEntry);
 		return newEntry;
@@ -667,16 +669,17 @@ public class ResolveMerger extends ThreeWayMerger {
 						// we know about length and lastMod only after we have written the new content.
 						// This will happen later. Set these values to 0 for know.
 						DirCacheEntry e = add(tw.getRawPath(), theirs,
-								DirCacheEntry.STAGE_0, 0, 0);
+								DirCacheEntry.STAGE_0, EPOCH, 0);
 						addToCheckout(tw.getPathString(), e, attributes);
 					}
 					return true;
 				} else {
 					// FileModes are not mergeable. We found a conflict on modes.
 					// For conflicting entries we don't know lastModified and length.
-					add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, 0, 0);
-					add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, 0, 0);
-					add(tw.getRawPath(), theirs, DirCacheEntry.STAGE_3, 0, 0);
+					add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, EPOCH, 0);
+					add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, EPOCH, 0);
+					add(tw.getRawPath(), theirs, DirCacheEntry.STAGE_3, EPOCH,
+							0);
 					unmergedPaths.add(tw.getPathString());
 					mergeResults.put(
 							tw.getPathString(),
@@ -708,7 +711,7 @@ public class ResolveMerger extends ThreeWayMerger {
 				// the new content.
 				// This will happen later. Set these values to 0 for know.
 				DirCacheEntry e = add(tw.getRawPath(), theirs,
-						DirCacheEntry.STAGE_0, 0, 0);
+						DirCacheEntry.STAGE_0, EPOCH, 0);
 				if (e != null) {
 					addToCheckout(tw.getPathString(), e, attributes);
 				}
@@ -737,16 +740,16 @@ public class ResolveMerger extends ThreeWayMerger {
 			// detected later
 			if (nonTree(modeO) && !nonTree(modeT)) {
 				if (nonTree(modeB))
-					add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, 0, 0);
-				add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, 0, 0);
+					add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, EPOCH, 0);
+				add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, EPOCH, 0);
 				unmergedPaths.add(tw.getPathString());
 				enterSubtree = false;
 				return true;
 			}
 			if (nonTree(modeT) && !nonTree(modeO)) {
 				if (nonTree(modeB))
-					add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, 0, 0);
-				add(tw.getRawPath(), theirs, DirCacheEntry.STAGE_3, 0, 0);
+					add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, EPOCH, 0);
+				add(tw.getRawPath(), theirs, DirCacheEntry.STAGE_3, EPOCH, 0);
 				unmergedPaths.add(tw.getPathString());
 				enterSubtree = false;
 				return true;
@@ -773,9 +776,9 @@ public class ResolveMerger extends ThreeWayMerger {
 			boolean gitlinkConflict = isGitLink(modeO) || isGitLink(modeT);
 			// Don't attempt to resolve submodule link conflicts
 			if (gitlinkConflict || !attributes.canBeContentMerged()) {
-				add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, 0, 0);
-				add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, 0, 0);
-				add(tw.getRawPath(), theirs, DirCacheEntry.STAGE_3, 0, 0);
+				add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, EPOCH, 0);
+				add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, EPOCH, 0);
+				add(tw.getRawPath(), theirs, DirCacheEntry.STAGE_3, EPOCH, 0);
 
 				if (gitlinkConflict) {
 					MergeResult<SubmoduleConflict> result = new MergeResult<>(
@@ -822,10 +825,10 @@ public class ResolveMerger extends ThreeWayMerger {
 				MergeResult<RawText> result = contentMerge(base, ours, theirs,
 						attributes);
 
-				add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, 0, 0);
-				add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, 0, 0);
+				add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, EPOCH, 0);
+				add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, EPOCH, 0);
 				DirCacheEntry e = add(tw.getRawPath(), theirs,
-						DirCacheEntry.STAGE_3, 0, 0);
+						DirCacheEntry.STAGE_3, EPOCH, 0);
 
 				// OURS was deleted checkout THEIRS
 				if (modeO == 0) {
@@ -957,9 +960,9 @@ public class ResolveMerger extends ThreeWayMerger {
 				// A conflict occurred, the file will contain conflict markers
 				// the index will be populated with the three stages and the
 				// workdir (if used) contains the halfway merged content.
-				add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, 0, 0);
-				add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, 0, 0);
-				add(tw.getRawPath(), theirs, DirCacheEntry.STAGE_3, 0, 0);
+				add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, EPOCH, 0);
+				add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, EPOCH, 0);
+				add(tw.getRawPath(), theirs, DirCacheEntry.STAGE_3, EPOCH, 0);
 				mergeResults.put(tw.getPathString(), result);
 				return;
 			}
@@ -976,7 +979,7 @@ public class ResolveMerger extends ThreeWayMerger {
 					? FileMode.REGULAR_FILE : FileMode.fromBits(newMode));
 			if (mergedFile != null) {
 				dce.setLastModified(
-						nonNullRepo().getFS().lastModified(mergedFile));
+						nonNullRepo().getFS().lastModifiedInstant(mergedFile));
 				dce.setLength((int) mergedFile.length());
 			}
 			dce.setObjectId(insertMergeResult(rawMerged, attributes));
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/NetRC.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/NetRC.java
index e688f6340d..4f1eba66d3 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/NetRC.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/NetRC.java
@@ -46,6 +46,7 @@ import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
 import java.io.IOException;
+import java.time.Instant;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Locale;
@@ -123,7 +124,7 @@ public class NetRC {
 
 	private File netrc;
 
-	private long lastModified;
+	private Instant lastModified;
 
 	private Map<String, NetRCEntry> hosts = new HashMap<>();
 
@@ -187,8 +188,10 @@ public class NetRC {
 		if (netrc == null)
 			return null;
 
-		if (this.lastModified != this.netrc.lastModified())
+		if (!this.lastModified
+				.equals(FS.DETECTED.lastModifiedInstant(this.netrc))) {
 			parse();
+		}
 
 		NetRCEntry entry = this.hosts.get(host);
 
@@ -209,7 +212,7 @@ public class NetRC {
 
 	private void parse() {
 		this.hosts.clear();
-		this.lastModified = this.netrc.lastModified();
+		this.lastModified = FS.DETECTED.lastModifiedInstant(this.netrc);
 
 		try (BufferedReader r = new BufferedReader(new FileReader(netrc))) {
 			String line = null;
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/transport/OpenSshConfig.java b/org.eclipse.jgit/src/org/eclipse/jgit/transport/OpenSshConfig.java
index 480055c2e4..4dd5df9cd6 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/transport/OpenSshConfig.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/transport/OpenSshConfig.java
@@ -51,6 +51,7 @@ import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
+import java.time.Instant;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -166,7 +167,7 @@ public class OpenSshConfig implements ConfigRepository {
 	private final File configFile;
 
 	/** Modification time of {@link #configFile} when it was last loaded. */
-	private long lastModified;
+	private Instant lastModified;
 
 	/**
 	 * Encapsulates entries read out of the configuration file, and
@@ -224,8 +225,8 @@ public class OpenSshConfig implements ConfigRepository {
 	}
 
 	private synchronized State refresh() {
-		final long mtime = configFile.lastModified();
-		if (mtime != lastModified) {
+		final Instant mtime = FS.DETECTED.lastModifiedInstant(configFile);
+		if (!mtime.equals(lastModified)) {
 			State newState = new State();
 			try (FileInputStream in = new FileInputStream(configFile)) {
 				newState.entries = parse(in);
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/FileTreeIterator.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/FileTreeIterator.java
index 3d25c2314e..d432c94450 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/FileTreeIterator.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/FileTreeIterator.java
@@ -53,6 +53,7 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.time.Instant;
 
 import org.eclipse.jgit.dircache.DirCacheIterator;
 import org.eclipse.jgit.errors.IncorrectObjectTypeException;
@@ -406,8 +407,14 @@ public class FileTreeIterator extends WorkingTreeIterator {
 		}
 
 		@Override
+		@Deprecated
 		public long getLastModified() {
-			return attributes.getLastModifiedTime();
+			return attributes.getLastModifiedInstant().toEpochMilli();
+		}
+
+		@Override
+		public Instant getLastModifiedInstant() {
+			return attributes.getLastModifiedInstant();
 		}
 
 		@Override
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java
index 7c6bfb9d63..299f07fb09 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/treewalk/WorkingTreeIterator.java
@@ -59,6 +59,7 @@ import java.nio.CharBuffer;
 import java.nio.charset.CharacterCodingException;
 import java.nio.charset.CharsetEncoder;
 import java.text.MessageFormat;
+import java.time.Instant;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
@@ -645,12 +646,24 @@ public abstract class WorkingTreeIterator extends AbstractTreeIterator {
 	 *
 	 * @return last modified time of this file, in milliseconds since the epoch
 	 *         (Jan 1, 1970 UTC).
+	 * @deprecated use {@link #getEntryLastModifiedInstant()} instead
 	 */
+	@Deprecated
 	public long getEntryLastModified() {
 		return current().getLastModified();
 	}
 
 	/**
+	 * Get the last modified time of this entry.
+	 *
+	 * @return last modified time of this file
+	 * @since 5.1.9
+	 */
+	public Instant getEntryLastModifiedInstant() {
+		return current().getLastModifiedInstant();
+	}
+
+	/**
 	 * Obtain an input stream to read the file content.
 	 * <p>
 	 * Efficient implementations are not required. The caller will usually
@@ -924,30 +937,28 @@ public abstract class WorkingTreeIterator extends AbstractTreeIterator {
 
 		// Git under windows only stores seconds so we round the timestamp
 		// Java gives us if it looks like the timestamp in index is seconds
-		// only. Otherwise we compare the timestamp at millisecond precision,
+		// only. Otherwise we compare the timestamp at nanosecond precision,
 		// unless core.checkstat is set to "minimal", in which case we only
 		// compare the whole second part.
-		long cacheLastModified = entry.getLastModified();
-		long fileLastModified = getEntryLastModified();
-		long lastModifiedMillis = fileLastModified % 1000;
-		long cacheMillis = cacheLastModified % 1000;
-		if (getOptions().getCheckStat() == CheckStat.MINIMAL) {
-			fileLastModified = fileLastModified - lastModifiedMillis;
-			cacheLastModified = cacheLastModified - cacheMillis;
-		} else if (cacheMillis == 0)
-			fileLastModified = fileLastModified - lastModifiedMillis;
-		// Some Java version on Linux return whole seconds only even when
-		// the file systems supports more precision.
-		else if (lastModifiedMillis == 0)
-			cacheLastModified = cacheLastModified - cacheMillis;
-
-		if (fileLastModified != cacheLastModified)
+		Instant cacheLastModified = entry.getLastModifiedInstant();
+		Instant fileLastModified = getEntryLastModifiedInstant();
+		if ((getOptions().getCheckStat() == CheckStat.MINIMAL)
+				|| (cacheLastModified.getNano() == 0)
+				// Some Java version on Linux return whole seconds only even
+				// when the file systems supports more precision.
+				|| (fileLastModified.getNano() == 0)) {
+			if (fileLastModified.getEpochSecond() != cacheLastModified
+					.getEpochSecond()) {
+				return MetadataDiff.DIFFER_BY_TIMESTAMP;
+			}
+		}
+		if (!fileLastModified.equals(cacheLastModified)) {
 			return MetadataDiff.DIFFER_BY_TIMESTAMP;
-		else if (!entry.isSmudged())
-			// The file is clean when you look at timestamps.
-			return MetadataDiff.EQUAL;
-		else
+		} else if (entry.isSmudged()) {
 			return MetadataDiff.SMUDGED;
+		}
+		// The file is clean when when comparing timestamps
+		return MetadataDiff.EQUAL;
 	}
 
 	/**
@@ -1274,10 +1285,26 @@ public abstract class WorkingTreeIterator extends AbstractTreeIterator {
 		 * instance member instead.
 		 *
 		 * @return time since the epoch (in ms) of the last change.
+		 * @deprecated use {@link #getLastModifiedInstant()} instead
 		 */
+		@Deprecated
 		public abstract long getLastModified();
 
 		/**
+		 * Get the last modified time of this entry.
+		 * <p>
+		 * <b>Note: Efficient implementation required.</b>
+		 * <p>
+		 * The implementation of this method must be efficient. If a subclass
+		 * needs to compute the value they should cache the reference within an
+		 * instance member instead.
+		 *
+		 * @return time of the last change.
+		 * @since 5.1.9
+		 */
+		public abstract Instant getLastModifiedInstant();
+
+		/**
 		 * Get the name of this entry within its directory.
 		 * <p>
 		 * Efficient implementations are not required. The caller will obtain
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/util/FS.java b/org.eclipse.jgit/src/org/eclipse/jgit/util/FS.java
index 6e3e336e94..e8570d7417 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/util/FS.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/util/FS.java
@@ -44,6 +44,7 @@
 package org.eclipse.jgit.util;
 
 import static java.nio.charset.StandardCharsets.UTF_8;
+import static java.time.Instant.EPOCH;
 import static org.eclipse.jgit.lib.Constants.FALLBACK_TIMESTAMP_RESOLUTION;
 
 import java.io.BufferedReader;
@@ -66,6 +67,7 @@ import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.text.MessageFormat;
 import java.time.Duration;
+import java.time.Instant;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
@@ -625,12 +627,42 @@ public abstract class FS {
 	 * @return last modified time of f
 	 * @throws java.io.IOException
 	 * @since 3.0
+	 * @deprecated use {@link #lastModifiedInstant(Path)} instead
 	 */
+	@Deprecated
 	public long lastModified(File f) throws IOException {
 		return FileUtils.lastModified(f);
 	}
 
 	/**
+	 * Get the last modified time of a file system object. If the OS/JRE support
+	 * symbolic links, the modification time of the link is returned, rather
+	 * than that of the link target.
+	 *
+	 * @param p
+	 *            a {@link Path} object.
+	 * @return last modified time of p
+	 * @since 5.1.9
+	 */
+	public Instant lastModifiedInstant(Path p) {
+		return FileUtils.lastModifiedInstant(p);
+	}
+
+	/**
+	 * Get the last modified time of a file system object. If the OS/JRE support
+	 * symbolic links, the modification time of the link is returned, rather
+	 * than that of the link target.
+	 *
+	 * @param f
+	 *            a {@link File} object.
+	 * @return last modified time of p
+	 * @since 5.1.9
+	 */
+	public Instant lastModifiedInstant(File f) {
+		return FileUtils.lastModifiedInstant(f.toPath());
+	}
+
+	/**
 	 * Set the last modified time of a file system object. If the OS/JRE support
 	 * symbolic links, the link is modified, not the target,
 	 *
@@ -640,12 +672,29 @@ public abstract class FS {
 	 *            last modified time
 	 * @throws java.io.IOException
 	 * @since 3.0
+	 * @deprecated use {@link #setLastModified(Path, Instant)} instead
 	 */
+	@Deprecated
 	public void setLastModified(File f, long time) throws IOException {
 		FileUtils.setLastModified(f, time);
 	}
 
 	/**
+	 * Set the last modified time of a file system object. If the OS/JRE support
+	 * symbolic links, the link is modified, not the target,
+	 *
+	 * @param p
+	 *            a {@link Path} object.
+	 * @param time
+	 *            last modified time
+	 * @throws java.io.IOException
+	 * @since 5.1.9
+	 */
+	public void setLastModified(Path p, Instant time) throws IOException {
+		FileUtils.setLastModified(p, time);
+	}
+
+	/**
 	 * Get the length of a file or link, If the OS/JRE supports symbolic links
 	 * it's the length of the link, else the length of the target.
 	 *
@@ -1712,9 +1761,19 @@ public abstract class FS {
 		/**
 		 * @return the time (milliseconds since 1970-01-01) when this object was
 		 *         last modified
+		 * @deprecated use getLastModifiedInstant instead
 		 */
+		@Deprecated
 		public long getLastModifiedTime() {
-			return lastModifiedTime;
+			return lastModifiedInstant.toEpochMilli();
+		}
+
+		/**
+		 * @return the time when this object was last modified
+		 * @since 5.1.9
+		 */
+		public Instant getLastModifiedInstant() {
+			return lastModifiedInstant;
 		}
 
 		private final boolean isDirectory;
@@ -1725,7 +1784,7 @@ public abstract class FS {
 
 		private final long creationTime;
 
-		private final long lastModifiedTime;
+		private final Instant lastModifiedInstant;
 
 		private final boolean isExecutable;
 
@@ -1743,7 +1802,7 @@ public abstract class FS {
 		Attributes(FS fs, File file, boolean exists, boolean isDirectory,
 				boolean isExecutable, boolean isSymbolicLink,
 				boolean isRegularFile, long creationTime,
-				long lastModifiedTime, long length) {
+				Instant lastModifiedInstant, long length) {
 			this.fs = fs;
 			this.file = file;
 			this.exists = exists;
@@ -1752,7 +1811,7 @@ public abstract class FS {
 			this.isSymbolicLink = isSymbolicLink;
 			this.isRegularFile = isRegularFile;
 			this.creationTime = creationTime;
-			this.lastModifiedTime = lastModifiedTime;
+			this.lastModifiedInstant = lastModifiedInstant;
 			this.length = length;
 		}
 
@@ -1764,7 +1823,7 @@ public abstract class FS {
 		 * @param path
 		 */
 		public Attributes(File path, FS fs) {
-			this(fs, path, false, false, false, false, false, 0L, 0L, 0L);
+			this(fs, path, false, false, false, false, false, 0L, EPOCH, 0L);
 		}
 
 		/**
@@ -1810,7 +1869,7 @@ public abstract class FS {
 		boolean exists = isDirectory || isFile;
 		boolean canExecute = exists && !isDirectory && canExecute(path);
 		boolean isSymlink = false;
-		long lastModified = exists ? path.lastModified() : 0L;
+		Instant lastModified = exists ? lastModifiedInstant(path) : EPOCH;
 		long createTime = 0L;
 		return new Attributes(this, path, exists, isDirectory, canExecute,
 				isSymlink, isFile, createTime, lastModified, -1);
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/util/FS_Win32.java b/org.eclipse.jgit/src/org/eclipse/jgit/util/FS_Win32.java
index 98797dc64f..7c07270363 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/util/FS_Win32.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/util/FS_Win32.java
@@ -149,7 +149,7 @@ public class FS_Win32 extends FS {
 									attrs.isSymbolicLink(),
 									attrs.isRegularFile(),
 									attrs.creationTime().toMillis(),
-									attrs.lastModifiedTime().toMillis(),
+									attrs.lastModifiedTime().toInstant(),
 									attrs.size());
 							result.add(new FileEntry(f, fs, attributes,
 									fileModeStrategy));
diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/util/FileUtils.java b/org.eclipse.jgit/src/org/eclipse/jgit/util/FileUtils.java
index 9650602fea..80f188cb2c 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/util/FileUtils.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/util/FileUtils.java
@@ -76,11 +76,14 @@ import java.util.regex.Pattern;
 import org.eclipse.jgit.internal.JGitText;
 import org.eclipse.jgit.lib.Constants;
 import org.eclipse.jgit.util.FS.Attributes;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * File Utilities
  */
 public class FileUtils {
+	private static final Logger LOG = LoggerFactory.getLogger(FileUtils.class);
 
 	/**
 	 * Option to delete given {@code File}
@@ -656,13 +659,32 @@ public class FileUtils {
 	 * @return lastModified attribute for given file, not following symbolic
 	 *         links
 	 * @throws IOException
+	 * @deprecated use {@link #lastModifiedInstant(Path)} instead which returns
+	 *             FileTime
 	 */
+	@Deprecated
 	static long lastModified(File file) throws IOException {
 		return Files.getLastModifiedTime(toPath(file), LinkOption.NOFOLLOW_LINKS)
 				.toMillis();
 	}
 
 	/**
+	 * @param path
+	 * @return lastModified attribute for given file, not following symbolic
+	 *         links
+	 */
+	static Instant lastModifiedInstant(Path path) {
+		try {
+			return Files.getLastModifiedTime(path, LinkOption.NOFOLLOW_LINKS)
+					.toInstant();
+		} catch (IOException e) {
+			LOG.error(MessageFormat
+					.format(JGitText.get().readLastModifiedFailed, path));
+			return Instant.ofEpochMilli(path.toFile().lastModified());
+		}
+	}
+
+	/**
 	 * Return all the attributes of a file, without following symbolic links.
 	 *
 	 * @param file
@@ -680,11 +702,22 @@ public class FileUtils {
 	 * @param time
 	 * @throws IOException
 	 */
+	@Deprecated
 	static void setLastModified(File file, long time) throws IOException {
 		Files.setLastModifiedTime(toPath(file), FileTime.fromMillis(time));
 	}
 
 	/**
+	 * @param path
+	 * @param time
+	 * @throws IOException
+	 */
+	static void setLastModified(Path path, Instant time)
+			throws IOException {
+		Files.setLastModifiedTime(path, FileTime.from(time));
+	}
+
+	/**
 	 * @param file
 	 * @return {@code true} if the given file exists, not following symbolic
 	 *         links
@@ -788,7 +821,7 @@ public class FileUtils {
 					readAttributes.isSymbolicLink(),
 					readAttributes.isRegularFile(), //
 					readAttributes.creationTime().toMillis(), //
-					readAttributes.lastModifiedTime().toMillis(),
+					readAttributes.lastModifiedTime().toInstant(),
 					readAttributes.isSymbolicLink() ? Constants
 							.encode(readSymLink(file)).length
 							: readAttributes.size());
@@ -827,7 +860,7 @@ public class FileUtils {
 					readAttributes.isSymbolicLink(),
 					readAttributes.isRegularFile(), //
 					readAttributes.creationTime().toMillis(), //
-					readAttributes.lastModifiedTime().toMillis(),
+					readAttributes.lastModifiedTime().toInstant(),
 					readAttributes.size());
 			return attributes;
 		} catch (IOException e) {