fs: use signed types for stat data

This allows to support timestamps before 1970-01-01.
On Windows, it's not supported due to Y2038 issue.
PR-URL: #43714Fixes: #43707
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>

Author: LiviaMedeiros

lib/internal/fs/utils.js

@@ -12,6 +12,7 @@ const {
  NumberIsFinite,
  NumberIsInteger,
  MathMin,
+ MathRound,
  ObjectIs,
  ObjectPrototypeHasOwnProperty,
  ObjectSetPrototypeOf,
@@ -39,9 +40,9 @@ const {
 }=require('internal/errors');
 const{
  isArrayBufferView,
-isUint8Array,
+isBigInt64Array,
  isDate,
-isBigUint64Array
+isUint8Array,
 }=require('internal/util/types');
 const{
  kEmptyObject,
@@ -454,14 +455,16 @@ function nsFromTimeSpecBigInt(sec, nsec) {
 returnsec*kNsPerSecBigInt+nsec;
 }
 
-// The Date constructor performs Math.floor() to the timestamp.
-// https://www.ecma-international.org/ecma-262/#sec-timeclip
+// The Date constructor performs Math.floor() on the absolute value
+// of the timestamp: https://tc39.es/ecma262/#sec-timeclip
 // Since there may be a precision loss when the timestamp is
 // converted to a floating point number, we manually round
 // the timestamp here before passing it to Date().
 // Refs: https://github.com/nodejs/node/pull/12607
+// Refs: https://github.com/nodejs/node/pull/43714
 functiondateFromMs(ms){
-returnnewDate(Number(ms)+0.5);
+// Coercing to number, ms can be bigint
+returnnewDate(MathRound(Number(ms)));
 }
 
 functionBigIntStats(dev,mode,nlink,uid,gid,rdev,blksize,
@@ -526,12 +529,12 @@ Stats.prototype._checkModeProperty = function(property) {
 };
 
 /**
- * @param {Float64Array | BigUint64Array} stats
+ * @param {Float64Array | BigInt64Array} stats
  * @param {number} offset
  * @returns {BigIntStats | Stats}
  */
 functiongetStatsFromBinding(stats,offset=0){
-if(isBigUint64Array(stats)){
+if(isBigInt64Array(stats)){
 returnnewBigIntStats(
 stats[0+offset],stats[1+offset],stats[2+offset],
 stats[3+offset],stats[4+offset],stats[5+offset],

src/aliased_buffer.h

@@ -307,7 +307,7 @@ typedef AliasedBufferBase<int32_t, v8::Int32Array> AliasedInt32Array;
 typedef AliasedBufferBase<uint8_t, v8::Uint8Array> AliasedUint8Array;
 typedef AliasedBufferBase<uint32_t, v8::Uint32Array> AliasedUint32Array;
 typedef AliasedBufferBase<double, v8::Float64Array> AliasedFloat64Array;
-typedef AliasedBufferBase<uint64_t, v8::BigUint64Array> AliasedBigUint64Array;
+typedef AliasedBufferBase<int64_t, v8::BigInt64Array> AliasedBigInt64Array;
 } // namespace node
 
 #endif// defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

src/node_file-inl.h

@@ -86,13 +86,22 @@ template <typename NativeT, typename V8T>
 voidFillStatsArray(AliasedBufferBase<NativeT, V8T>* fields,
 constuv_stat_t* s,
 constsize_t offset) {
-#defineSET_FIELD_WITH_STAT(stat_offset, stat) \
- fields->SetValue(offset + static_cast<size_t>(FsStatsOffset::stat_offset), \
+#defineSET_FIELD_WITH_STAT(stat_offset, stat) \
+ fields->SetValue(offset + static_cast<size_t>(FsStatsOffset::stat_offset), \
 static_cast<NativeT>(stat))
 
-#defineSET_FIELD_WITH_TIME_STAT(stat_offset, stat) \
-/* NOLINTNEXTLINE(runtime/int) */ \
+// On win32, time is stored in uint64_t and starts from 1601-01-01.
+// libuv calculates tv_sec and tv_nsec from it and converts to signed long,
+// which causes Y2038 overflow. On the other platforms it is safe to treat
+// negative values as pre-epoch time.
+#ifdef _WIN32
+#defineSET_FIELD_WITH_TIME_STAT(stat_offset, stat) \
+/* NOLINTNEXTLINE(runtime/int) */ \
 SET_FIELD_WITH_STAT(stat_offset, static_cast<unsignedlong>(stat))
+#else
+#defineSET_FIELD_WITH_TIME_STAT(stat_offset, stat) \
+SET_FIELD_WITH_STAT(stat_offset, static_cast<double>(stat))
+#endif// _WIN32
 
 SET_FIELD_WITH_STAT(kDev, s->st_dev);
 SET_FIELD_WITH_STAT(kMode, s->st_mode);
@@ -233,7 +242,7 @@ FSReqBase* GetReqWrap(const v8::FunctionCallbackInfo<v8::Value>& args,
  Environment* env = binding_data->env();
 if (value->StrictEquals(env->fs_use_promises_symbol())) {
 if (use_bigint) {
-return FSReqPromise<AliasedBigUint64Array>::New(binding_data, use_bigint);
+return FSReqPromise<AliasedBigInt64Array>::New(binding_data, use_bigint);
  } else {
 return FSReqPromise<AliasedFloat64Array>::New(binding_data, use_bigint);
  }

src/node_file.h

@@ -18,7 +18,7 @@ class BindingData : public SnapshotableObject {
 explicitBindingData(Environment* env, v8::Local<v8::Object> wrap);
 
  AliasedFloat64Array stats_field_array;
-AliasedBigUint64Array stats_field_bigint_array;
+AliasedBigInt64Array stats_field_bigint_array;
 
  std::vector<BaseObjectPtr<FileHandleReadWrap>>
  file_handle_read_wrap_freelist;

test/parallel/test-fs-stat-date.mjs

@@ -0,0 +1,79 @@
+import*ascommonfrom'../common/index.mjs';
+
+// Test timestamps returned by fsPromises.stat and fs.statSync
+
+importfsfrom'node:fs';
+importfsPromisesfrom'node:fs/promises';
+importpathfrom'node:path';
+importassertfrom'node:assert';
+importtmpdirfrom'../common/tmpdir.js';
+
+// On some platforms (for example, ppc64) boundaries are tighter
+// than usual. If we catch these errors, skip corresponding test.
+constignoredErrors=newSet(['EINVAL','EOVERFLOW']);
+
+tmpdir.refresh();
+constfilepath=path.resolve(tmpdir.path,'timestamp');
+
+await(awaitfsPromises.open(filepath,'w')).close();
+
+// Date might round down timestamp
+functioncloseEnough(actual,expected,margin){
+// On ppc64, value is rounded to seconds
+if(process.arch==='ppc64'){
+margin+=1000;
+}
+assert.ok(Math.abs(Number(actual-expected))<margin,
+`expected ${expected} ± ${margin}, got ${actual}`);
+}
+
+asyncfunctionrunTest(atime,mtime,margin=0){
+margin+=Number.EPSILON;
+try{
+awaitfsPromises.utimes(filepath,newDate(atime),newDate(mtime));
+}catch(e){
+if(ignoredErrors.has(e.code))return;
+throwe;
+}
+
+conststats=awaitfsPromises.stat(filepath);
+closeEnough(stats.atimeMs,atime,margin);
+closeEnough(stats.mtimeMs,mtime,margin);
+closeEnough(stats.atime.getTime(),newDate(atime).getTime(),margin);
+closeEnough(stats.mtime.getTime(),newDate(mtime).getTime(),margin);
+
+conststatsBigint=awaitfsPromises.stat(filepath,{bigint: true});
+closeEnough(statsBigint.atimeMs,BigInt(atime),margin);
+closeEnough(statsBigint.mtimeMs,BigInt(mtime),margin);
+closeEnough(statsBigint.atime.getTime(),newDate(atime).getTime(),margin);
+closeEnough(statsBigint.mtime.getTime(),newDate(mtime).getTime(),margin);
+
+conststatsSync=fs.statSync(filepath);
+closeEnough(statsSync.atimeMs,atime,margin);
+closeEnough(statsSync.mtimeMs,mtime,margin);
+closeEnough(statsSync.atime.getTime(),newDate(atime).getTime(),margin);
+closeEnough(statsSync.mtime.getTime(),newDate(mtime).getTime(),margin);
+
+conststatsSyncBigint=fs.statSync(filepath,{bigint: true});
+closeEnough(statsSyncBigint.atimeMs,BigInt(atime),margin);
+closeEnough(statsSyncBigint.mtimeMs,BigInt(mtime),margin);
+closeEnough(statsSyncBigint.atime.getTime(),newDate(atime).getTime(),margin);
+closeEnough(statsSyncBigint.mtime.getTime(),newDate(mtime).getTime(),margin);
+}
+
+// Too high/low numbers produce too different results on different platforms
+{
+// TODO(LiviaMedeiros): investigate outdated stat time on FreeBSD.
+// On Windows, filetime is stored and handled differently. Supporting dates
+// after Y2038 is preferred over supporting dates before 1970-01-01.
+if(!common.isFreeBSD&&!common.isWindows){
+awaitrunTest(-40691,-355,1);// Potential precision loss on 32bit
+awaitrunTest(-355,-40691,1);// Potential precision loss on 32bit
+awaitrunTest(-1,-1);
+}
+awaitrunTest(0,0);
+awaitrunTest(1,1);
+awaitrunTest(355,40691,1);// Precision loss on 32bit
+awaitrunTest(40691,355,1);// Precision loss on 32bit
+awaitrunTest(1713037251360,1713037251360,1);// Precision loss
+}