Use Stat from System.Native shim throughout

nguerrera · nguerrera · commit 2de10733ebca · 2015-08-16T21:42:02.000-07:00
Replace all usage of GetFileInformation from libcoreclr with newer
Stat from System.Native shim.
diff --git a/src/Common/src/Interop/Unix/System.Native/Interop.Stat.cs b/src/Common/src/Interop/Unix/System.Native/Interop.Stat.cs
@@ -41,7 +41,7 @@ internal static class FileTypes
         internal enum FileStatusFlags
         {
             None = 0,
-            HasCreationTime = 1,
+            HasBirthTime = 1,
         }
 
         [DllImport(Libraries.SystemNative, SetLastError = true)]
diff --git a/src/Common/src/Interop/Unix/libcoreclr/Interop.GetFileInformation.cs b/src/Common/src/Interop/Unix/libcoreclr/Interop.GetFileInformation.cs
diff --git a/src/Common/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs b/src/Common/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs
@@ -51,13 +51,13 @@ internal static SafeFileHandle Open(string path, Interop.libc.OpenFlags flags, i
 
                 // Make sure it's not a directory; we do this after opening it once we have a file descriptor 
                 // to avoid race conditions.
-                Interop.libcoreclr.fileinfo buf;
-                if (Interop.libcoreclr.GetFileInformationFromFd(fd, out buf) != 0)
+                Interop.Sys.FileStatus status;
+                if (Interop.Sys.FStat(fd, out status) != 0)
                 {
                     handle.Dispose();
                     throw Interop.GetExceptionForIoErrno(Interop.Sys.GetLastErrorInfo(), path);
                 }
-                if ((buf.mode & Interop.libcoreclr.FileTypes.S_IFMT) == Interop.libcoreclr.FileTypes.S_IFDIR)
+                if ((status.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFDIR)
                 {
                     handle.Dispose();
                     throw Interop.GetExceptionForIoErrno(Interop.Error.EACCES.Info(), path, isDirectory: true);
diff --git a/src/System.Console/src/System.Console.csproj b/src/System.Console/src/System.Console.csproj
@@ -132,9 +132,6 @@
     <Compile Include="$(CommonPath)\Interop\Unix\libc\Interop.snprintf.cs">
       <Link>Common\Interop\Unix\Interop.snprintf.cs</Link>
     </Compile>
-    <Compile Include="$(CommonPath)\Interop\Unix\libcoreclr\Interop.GetFileInformation.cs">
-      <Link>Common\Interop\Unix\Interop.GetFileInformation.cs"</Link>
-    </Compile>
     <Compile Include="$(CommonPath)\Interop\Unix\System.Native\Interop.Stat.cs">
       <Link>Common\Interop\Unix\Interop.Stat.cs</Link>
     </Compile>
diff --git a/src/System.Diagnostics.Debug/src/System.Diagnostics.Debug.csproj b/src/System.Diagnostics.Debug/src/System.Diagnostics.Debug.csproj
@@ -74,8 +74,8 @@
     <Compile Include="$(CommonPath)\Interop\Unix\libc\Interop.write.cs">
       <Link>Common\Interop\Unix\libc\Interop.write.cs</Link>
     </Compile>
-    <Compile Include="$(CommonPath)\Interop\Unix\libcoreclr\Interop.GetFileInformation.cs">
-      <Link>Common\Interop\Unix\Interop.GetFileInformation.cs"</Link>
+    <Compile Include="$(CommonPath)\Interop\Unix\System.Native\Interop.Stat.cs">
+      <Link>Common\Interop\Unix\Interop.Stat.cs</Link>
     </Compile>
     <Compile Include="$(CommonPath)\Microsoft\Win32\SafeHandles\SafeFileHandle.Unix.cs">
       <Link>Common\Microsoft\Win32\SafeHandles\SafeFileHandle.Unix.cs</Link>
diff --git a/src/System.IO.FileSystem/src/System.IO.FileSystem.csproj b/src/System.IO.FileSystem/src/System.IO.FileSystem.csproj
@@ -334,8 +334,8 @@
     <Compile Include="$(CommonPath)\Interop\Unix\libc\Interop.unlink.cs">
       <Link>Common\Interop\Unix\Interop.unlink.cs</Link>
     </Compile>
-    <Compile Include="$(CommonPath)\Interop\Unix\libcoreclr\Interop.GetFileInformation.cs">
-      <Link>Common\Interop\Unix\Interop.GetInformation.cs</Link>
+    <Compile Include="$(CommonPath)\Interop\Unix\System.Native\Interop.Stat.cs">
+      <Link>Common\Interop\Unix\Interop.Stat.cs</Link>
     </Compile>
     <Compile Include="$(CommonPath)\System\IO\PathInternal.Unix.cs">
       <Link>Common\System\IO\PathInternal.Unix.cs</Link>
diff --git a/src/System.IO.FileSystem/src/System/IO/FileSystemInfo.Unix.cs b/src/System.IO.FileSystem/src/System/IO/FileSystemInfo.Unix.cs
@@ -8,15 +8,15 @@ namespace System.IO
     partial class FileSystemInfo : IFileSystemObject
     {
         /// <summary>The last cached stat information about the file.</summary>
-        private Interop.libcoreclr.fileinfo _fileinfo;
+        private Interop.Sys.FileStatus _fileStatus;
 
         /// <summary>
         /// Whether we've successfully cached a stat structure.
-        /// -1 if we need to refresh _fileinfo, 0 if we've successfully cached one,
+        /// -1 if we need to refresh _fileStatus, 0 if we've successfully cached one,
         /// or any other value that serves as an errno error code from the
-        /// last time we tried and failed to refresh _fileinfo.
+        /// last time we tried and failed to refresh _fileStatus.
         /// </summary>
-        private int _fileinfoInitialized = -1;
+        private int _fileStatusInitialized = -1;
 
         internal IFileSystemObject FileSystemObject
         {
@@ -25,7 +25,7 @@ internal IFileSystemObject FileSystemObject
 
         internal void Invalidate()
         {
-            _fileinfoInitialized = -1;
+            _fileStatusInitialized = -1;
         }
 
         FileAttributes IFileSystemObject.Attributes
@@ -77,7 +77,7 @@ FileAttributes IFileSystemObject.Attributes
                 // just changing its permissions accordingly.
                 EnsureStatInitialized();
                 IsReadOnlyAssumesInitialized = (value & FileAttributes.ReadOnly) != 0;
-                _fileinfoInitialized = -1;
+                _fileStatusInitialized = -1;
             }
         }
 
@@ -86,15 +86,15 @@ private bool IsDirectoryAssumesInitialized
         {
             get
             {
-                return (_fileinfo.mode & Interop.libcoreclr.FileTypes.S_IFMT) == Interop.libcoreclr.FileTypes.S_IFDIR;
+                return (_fileStatus.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFDIR;
             }
         }
 
         private bool IsLink
         {
             get
             {
-                return (_fileinfo.mode & Interop.libcoreclr.FileTypes.S_IFMT) == Interop.libcoreclr.FileTypes.S_IFLNK;
+                return (_fileStatus.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFLNK;
             }
         }
 
@@ -107,12 +107,12 @@ private bool IsReadOnlyAssumesInitialized
             get
             {
                 Interop.libc.Permissions readBit, writeBit;
-                if (_fileinfo.uid == Interop.libc.geteuid())      // does the user effectively own the file?
+                if (_fileStatus.Uid == Interop.libc.geteuid())      // does the user effectively own the file?
                 {
                     readBit  = Interop.libc.Permissions.S_IRUSR;
                     writeBit = Interop.libc.Permissions.S_IWUSR;
                 }
-                else if (_fileinfo.gid == Interop.libc.getegid()) // does the user belong to a group that effectively owns the file?
+                else if (_fileStatus.Gid == Interop.libc.getegid()) // does the user belong to a group that effectively owns the file?
                 {
                     readBit  = Interop.libc.Permissions.S_IRGRP;
                     writeBit = Interop.libc.Permissions.S_IWGRP;
@@ -124,12 +124,12 @@ private bool IsReadOnlyAssumesInitialized
                 }
 
                 return
-                    (_fileinfo.mode & (int)readBit) != 0 && // has read permission
-                    (_fileinfo.mode & (int)writeBit) == 0;  // but not write permission
+                    (_fileStatus.Mode & (int)readBit) != 0 && // has read permission
+                    (_fileStatus.Mode & (int)writeBit) == 0;  // but not write permission
             }
             set
             {
-                int newMode = _fileinfo.mode;
+                int newMode = _fileStatus.Mode;
                 if (value) // true if going from writable to readable, false if going from readable to writable
                 {
                     // Take away all write permissions from user/group/everyone
@@ -142,7 +142,7 @@ private bool IsReadOnlyAssumesInitialized
                 }
 
                 // Change the permissions on the file
-                if (newMode != _fileinfo.mode)
+                if (newMode != _fileStatus.Mode)
                 {
                     bool isDirectory = this is DirectoryInfo;
                     while (Interop.CheckIo(Interop.libc.chmod(FullPath, newMode), FullPath, isDirectory)) ;
@@ -154,12 +154,12 @@ bool IFileSystemObject.Exists
         {
             get
             {
-                if (_fileinfoInitialized == -1)
+                if (_fileStatusInitialized == -1)
                 {
                     Refresh();
                 }
                 return
-                    _fileinfoInitialized == 0 && // avoid throwing if Refresh failed; instead just return false
+                    _fileStatusInitialized == 0 && // avoid throwing if Refresh failed; instead just return false
                     (this is DirectoryInfo) == IsDirectoryAssumesInitialized;
             }
         }
@@ -169,8 +169,8 @@ DateTimeOffset IFileSystemObject.CreationTime
             get
             {
                 EnsureStatInitialized();
-                return (_fileinfo.flags & (uint)Interop.libcoreclr.FileInformationFlags.HasBTime) != 0 ?
-                    DateTimeOffset.FromUnixTimeSeconds(_fileinfo.btime) :
+                return (_fileStatus.Flags & Interop.Sys.FileStatusFlags.HasBirthTime) != 0 ?
+                    DateTimeOffset.FromUnixTimeSeconds(_fileStatus.BirthTime) :
                     default(DateTimeOffset);
             }
             set
@@ -188,7 +188,7 @@ DateTimeOffset IFileSystemObject.LastAccessTime
             get
             {
                 EnsureStatInitialized();
-                return DateTimeOffset.FromUnixTimeSeconds(_fileinfo.atime).ToLocalTime();
+                return DateTimeOffset.FromUnixTimeSeconds(_fileStatus.ATime).ToLocalTime();
             }
             set { SetAccessWriteTimes((IntPtr)value.ToUnixTimeSeconds(), null); }
         }
@@ -198,29 +198,29 @@ DateTimeOffset IFileSystemObject.LastWriteTime
             get
             {
                 EnsureStatInitialized();
-                return DateTimeOffset.FromUnixTimeSeconds(_fileinfo.mtime).ToLocalTime();
+                return DateTimeOffset.FromUnixTimeSeconds(_fileStatus.MTime).ToLocalTime();
             }
             set { SetAccessWriteTimes(null, (IntPtr)value.ToUnixTimeSeconds()); }
         }
 
         private void SetAccessWriteTimes(IntPtr? accessTime, IntPtr? writeTime)
         {
-            _fileinfoInitialized = -1; // force a refresh so that we have an up-to-date times for values not being overwritten
+            _fileStatusInitialized = -1; // force a refresh so that we have an up-to-date times for values not being overwritten
             EnsureStatInitialized();
             Interop.libc.utimbuf buf;
-            buf.actime = accessTime ?? new IntPtr(_fileinfo.atime);
-            buf.modtime = writeTime ?? new IntPtr(_fileinfo.mtime);
+            buf.actime = accessTime ?? new IntPtr(_fileStatus.ATime);
+            buf.modtime = writeTime ?? new IntPtr(_fileStatus.MTime);
             bool isDirectory = this is DirectoryInfo;
             while (Interop.CheckIo(Interop.libc.utime(FullPath, ref buf), FullPath, isDirectory)) ;
-            _fileinfoInitialized = -1;
+            _fileStatusInitialized = -1;
         }
 
         long IFileSystemObject.Length
         {
             get
             {
                 EnsureStatInitialized();
-                return _fileinfo.size;
+                return _fileStatus.Size;
             }
         }
 
@@ -231,10 +231,10 @@ void IFileSystemObject.Refresh()
             int result;
             while (true)
             {
-                result = Interop.libcoreclr.GetFileInformationFromPath(FullPath, out _fileinfo);
+                result = Interop.Sys.Stat(FullPath, out _fileStatus);
                 if (result >= 0)
                 {
-                    _fileinfoInitialized = 0;
+                    _fileStatusInitialized = 0;
                 }
                 else
                 {
@@ -243,23 +243,23 @@ void IFileSystemObject.Refresh()
                     {
                         continue;
                     }
-                    _fileinfoInitialized = errorInfo.RawErrno;
+                    _fileStatusInitialized = errorInfo.RawErrno;
                 }
                 break;
             }
         }
 
         private void EnsureStatInitialized()
         {
-            if (_fileinfoInitialized == -1)
+            if (_fileStatusInitialized == -1)
             {
                 Refresh();
             }
 
-            if (_fileinfoInitialized != 0)
+            if (_fileStatusInitialized != 0)
             {
-                int errno = _fileinfoInitialized;
-                _fileinfoInitialized = -1;
+                int errno = _fileStatusInitialized;
+                _fileStatusInitialized = -1;
                 var errorInfo =  new Interop.ErrorInfo(errno);
 
                 // Windows distinguishes between whether the directory or the file isn't found,
diff --git a/src/System.IO.FileSystem/src/System/IO/UnixFileStream.cs b/src/System.IO.FileSystem/src/System/IO/UnixFileStream.cs
@@ -281,9 +281,9 @@ public override long Length
                 // Get the length of the file as reported by the OS
                 long length = SysCall<int, int>((fd, _, __) =>
                 {
-                    Interop.libcoreclr.fileinfo fileinfo;
-                    int result = Interop.libcoreclr.GetFileInformationFromFd(fd, out fileinfo);
-                    return result >= 0 ? fileinfo.size : result;
+                    Interop.Sys.FileStatus status;
+                    int result = Interop.Sys.FStat(fd, out status);
+                    return result >= 0 ? status.Size : result;
                 });
 
                 // But we may have buffered some data to be written that puts our length
diff --git a/src/System.IO.FileSystem/src/System/IO/UnixFileSystem.cs b/src/System.IO.FileSystem/src/System/IO/UnixFileSystem.cs
@@ -43,9 +43,9 @@ public override void CopyFile(string sourceFullPath, string destFullPath, bool o
             }
 
             // Now copy over relevant read/write/execute permissions from the source to the destination
-            Interop.libcoreclr.fileinfo fileinfo;
-            while (Interop.CheckIo(Interop.libcoreclr.GetFileInformationFromPath(sourceFullPath, out fileinfo), sourceFullPath)) ;
-            int newMode = fileinfo.mode & (int)Interop.libc.Permissions.Mask;
+            Interop.Sys.FileStatus status;
+            while (Interop.CheckIo(Interop.Sys.Stat(sourceFullPath, out status), sourceFullPath)) ;
+            int newMode = status.Mode & (int)Interop.libc.Permissions.Mask;
             while (Interop.CheckIo(Interop.libc.chmod(destFullPath, newMode), destFullPath)) ;
         }
 
@@ -315,22 +315,22 @@ public override bool DirectoryExists(string fullPath)
 
         private static bool DirectoryExists(string fullPath, out Interop.ErrorInfo errorInfo)
         {
-            return FileExists(fullPath, Interop.libcoreclr.FileTypes.S_IFDIR, out errorInfo);
+            return FileExists(fullPath, Interop.Sys.FileTypes.S_IFDIR, out errorInfo);
         }
 
         public override bool FileExists(string fullPath)
         {
             Interop.ErrorInfo ignored;
-            return FileExists(fullPath, Interop.libcoreclr.FileTypes.S_IFREG, out ignored);
+            return FileExists(fullPath, Interop.Sys.FileTypes.S_IFREG, out ignored);
         }
 
         private static bool FileExists(string fullPath, int fileType, out Interop.ErrorInfo errorInfo)
         {
-            Interop.libcoreclr.fileinfo fileinfo;
+            Interop.Sys.FileStatus fileinfo;
             while (true)
             {
                 errorInfo = default(Interop.ErrorInfo);
-                int result = Interop.libcoreclr.GetFileInformationFromPath(fullPath, out fileinfo);
+                int result = Interop.Sys.Stat(fullPath, out fileinfo);
                 if (result < 0)
                 {
                     errorInfo = Interop.Sys.GetLastErrorInfo();
@@ -340,7 +340,7 @@ private static bool FileExists(string fullPath, int fileType, out Interop.ErrorI
                     }
                     return false;
                 }
-                return (fileinfo.mode & Interop.libcoreclr.FileTypes.S_IFMT) == fileType;
+                return (fileinfo.Mode & Interop.Sys.FileTypes.S_IFMT) == fileType;
             }
         }
 
diff --git a/src/System.IO.Pipes/src/System.IO.Pipes.csproj b/src/System.IO.Pipes/src/System.IO.Pipes.csproj
@@ -196,8 +196,8 @@
     <Compile Include="$(CommonPath)\Interop\Unix\libc\Interop.write.cs">
       <Link>Common\Interop\Unix\Interop.write.cs</Link>
     </Compile>
-    <Compile Include="$(CommonPath)\Interop\Unix\libcoreclr\Interop.GetFileInformation.cs">
-      <Link>Common\Interop\Unix\Interop.GetInformation.cs</Link>
+    <Compile Include="$(CommonPath)\Interop\Unix\System.Native\Interop.Stat.cs">
+      <Link>Common\Interop\Unix\Interop.Stat.cs</Link>
     </Compile>
   </ItemGroup>
   <!-- Linux -->
diff --git a/src/System.IO.Pipes/src/System/IO/Pipes/PipeStream.Unix.cs b/src/System.IO.Pipes/src/System/IO/Pipes/PipeStream.Unix.cs
diff --git a/src/System.Private.Uri/src/System.Private.Uri.CoreCLR.csproj b/src/System.Private.Uri/src/System.Private.Uri.CoreCLR.csproj

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ internal static class FileTypes`
`41`	`41`	`internal enum FileStatusFlags`
`42`	`42`	`{`
`43`	`43`	`None = 0,`
`44`		`- HasCreationTime = 1,`
	`44`	`+ HasBirthTime = 1,`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`[DllImport(Libraries.SystemNative, SetLastError = true)]`
Original file line number	Diff line number	Diff line change
`@@ -51,13 +51,13 @@ internal static SafeFileHandle Open(string path, Interop.libc.OpenFlags flags, i`
`51`	`51`
`52`	`52`	`// Make sure it's not a directory; we do this after opening it once we have a file descriptor`
`53`	`53`	`// to avoid race conditions.`
`54`		`- Interop.libcoreclr.fileinfo buf;`
`55`		`- if (Interop.libcoreclr.GetFileInformationFromFd(fd, out buf) != 0)`
	`54`	`+ Interop.Sys.FileStatus status;`
	`55`	`+ if (Interop.Sys.FStat(fd, out status) != 0)`
`56`	`56`	`{`
`57`	`57`	`handle.Dispose();`
`58`	`58`	`throw Interop.GetExceptionForIoErrno(Interop.Sys.GetLastErrorInfo(), path);`
`59`	`59`	`}`
`60`		`- if ((buf.mode & Interop.libcoreclr.FileTypes.S_IFMT) == Interop.libcoreclr.FileTypes.S_IFDIR)`
	`60`	`+ if ((status.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFDIR)`
`61`	`61`	`{`
`62`	`62`	`handle.Dispose();`
`63`	`63`	`throw Interop.GetExceptionForIoErrno(Interop.Error.EACCES.Info(), path, isDirectory: true);`
Original file line number	Diff line number	Diff line change
`@@ -8,15 +8,15 @@ namespace System.IO`
`8`	`8`	`partial class FileSystemInfo : IFileSystemObject`
`9`	`9`	`{`
`10`	`10`	`/// <summary>The last cached stat information about the file.</summary>`
`11`		`- private Interop.libcoreclr.fileinfo _fileinfo;`
	`11`	`+ private Interop.Sys.FileStatus _fileStatus;`
`12`	`12`
`13`	`13`	`/// <summary>`
`14`	`14`	`/// Whether we've successfully cached a stat structure.`
`15`		`- /// -1 if we need to refresh _fileinfo, 0 if we've successfully cached one,`
	`15`	`+ /// -1 if we need to refresh _fileStatus, 0 if we've successfully cached one,`
`16`	`16`	`/// or any other value that serves as an errno error code from the`
`17`		`- /// last time we tried and failed to refresh _fileinfo.`
	`17`	`+ /// last time we tried and failed to refresh _fileStatus.`
`18`	`18`	`/// </summary>`
`19`		`- private int _fileinfoInitialized = -1;`
	`19`	`+ private int _fileStatusInitialized = -1;`
`20`	`20`
`21`	`21`	`internal IFileSystemObject FileSystemObject`
`22`	`22`	`{`
`@@ -25,7 +25,7 @@ internal IFileSystemObject FileSystemObject`
`25`	`25`
`26`	`26`	`internal void Invalidate()`
`27`	`27`	`{`
`28`		`- _fileinfoInitialized = -1;`
	`28`	`+ _fileStatusInitialized = -1;`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`FileAttributes IFileSystemObject.Attributes`
`@@ -77,7 +77,7 @@ FileAttributes IFileSystemObject.Attributes`
`77`	`77`	`// just changing its permissions accordingly.`
`78`	`78`	`EnsureStatInitialized();`
`79`	`79`	`IsReadOnlyAssumesInitialized = (value & FileAttributes.ReadOnly) != 0;`
`80`		`- _fileinfoInitialized = -1;`
	`80`	`+ _fileStatusInitialized = -1;`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`
`@@ -86,15 +86,15 @@ private bool IsDirectoryAssumesInitialized`
`86`	`86`	`{`
`87`	`87`	`get`
`88`	`88`	`{`
`89`		`- return (_fileinfo.mode & Interop.libcoreclr.FileTypes.S_IFMT) == Interop.libcoreclr.FileTypes.S_IFDIR;`
	`89`	`+ return (_fileStatus.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFDIR;`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`private bool IsLink`
`94`	`94`	`{`
`95`	`95`	`get`
`96`	`96`	`{`
`97`		`- return (_fileinfo.mode & Interop.libcoreclr.FileTypes.S_IFMT) == Interop.libcoreclr.FileTypes.S_IFLNK;`
	`97`	`+ return (_fileStatus.Mode & Interop.Sys.FileTypes.S_IFMT) == Interop.Sys.FileTypes.S_IFLNK;`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`
`@@ -107,12 +107,12 @@ private bool IsReadOnlyAssumesInitialized`
`107`	`107`	`get`
`108`	`108`	`{`
`109`	`109`	`Interop.libc.Permissions readBit, writeBit;`
`110`		`- if (_fileinfo.uid == Interop.libc.geteuid()) // does the user effectively own the file?`
	`110`	`+ if (_fileStatus.Uid == Interop.libc.geteuid()) // does the user effectively own the file?`
`111`	`111`	`{`
`112`	`112`	`readBit = Interop.libc.Permissions.S_IRUSR;`
`113`	`113`	`writeBit = Interop.libc.Permissions.S_IWUSR;`
`114`	`114`	`}`
`115`		`- else if (_fileinfo.gid == Interop.libc.getegid()) // does the user belong to a group that effectively owns the file?`
	`115`	`+ else if (_fileStatus.Gid == Interop.libc.getegid()) // does the user belong to a group that effectively owns the file?`
`116`	`116`	`{`
`117`	`117`	`readBit = Interop.libc.Permissions.S_IRGRP;`
`118`	`118`	`writeBit = Interop.libc.Permissions.S_IWGRP;`
`@@ -124,12 +124,12 @@ private bool IsReadOnlyAssumesInitialized`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`return`
`127`		`- (_fileinfo.mode & (int)readBit) != 0 && // has read permission`
`128`		`- (_fileinfo.mode & (int)writeBit) == 0; // but not write permission`
	`127`	`+ (_fileStatus.Mode & (int)readBit) != 0 && // has read permission`
	`128`	`+ (_fileStatus.Mode & (int)writeBit) == 0; // but not write permission`
`129`	`129`	`}`
`130`	`130`	`set`
`131`	`131`	`{`
`132`		`- int newMode = _fileinfo.mode;`
	`132`	`+ int newMode = _fileStatus.Mode;`
`133`	`133`	`if (value) // true if going from writable to readable, false if going from readable to writable`
`134`	`134`	`{`
`135`	`135`	`// Take away all write permissions from user/group/everyone`
`@@ -142,7 +142,7 @@ private bool IsReadOnlyAssumesInitialized`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`// Change the permissions on the file`
`145`		`- if (newMode != _fileinfo.mode)`
	`145`	`+ if (newMode != _fileStatus.Mode)`
`146`	`146`	`{`
`147`	`147`	`bool isDirectory = this is DirectoryInfo;`
`148`	`148`	`while (Interop.CheckIo(Interop.libc.chmod(FullPath, newMode), FullPath, isDirectory)) ;`
`@@ -154,12 +154,12 @@ bool IFileSystemObject.Exists`
`154`	`154`	`{`
`155`	`155`	`get`
`156`	`156`	`{`
`157`		`- if (_fileinfoInitialized == -1)`
	`157`	`+ if (_fileStatusInitialized == -1)`
`158`	`158`	`{`
`159`	`159`	`Refresh();`
`160`	`160`	`}`
`161`	`161`	`return`
`162`		`- _fileinfoInitialized == 0 && // avoid throwing if Refresh failed; instead just return false`
	`162`	`+ _fileStatusInitialized == 0 && // avoid throwing if Refresh failed; instead just return false`
`163`	`163`	`(this is DirectoryInfo) == IsDirectoryAssumesInitialized;`
`164`	`164`	`}`
`165`	`165`	`}`
`@@ -169,8 +169,8 @@ DateTimeOffset IFileSystemObject.CreationTime`
`169`	`169`	`get`
`170`	`170`	`{`
`171`	`171`	`EnsureStatInitialized();`
`172`		`- return (_fileinfo.flags & (uint)Interop.libcoreclr.FileInformationFlags.HasBTime) != 0 ?`
`173`		`- DateTimeOffset.FromUnixTimeSeconds(_fileinfo.btime) :`
	`172`	`+ return (_fileStatus.Flags & Interop.Sys.FileStatusFlags.HasBirthTime) != 0 ?`
	`173`	`+ DateTimeOffset.FromUnixTimeSeconds(_fileStatus.BirthTime) :`
`174`	`174`	`default(DateTimeOffset);`
`175`	`175`	`}`
`176`	`176`	`set`
`@@ -188,7 +188,7 @@ DateTimeOffset IFileSystemObject.LastAccessTime`
`188`	`188`	`get`
`189`	`189`	`{`
`190`	`190`	`EnsureStatInitialized();`
`191`		`- return DateTimeOffset.FromUnixTimeSeconds(_fileinfo.atime).ToLocalTime();`
	`191`	`+ return DateTimeOffset.FromUnixTimeSeconds(_fileStatus.ATime).ToLocalTime();`
`192`	`192`	`}`
`193`	`193`	`set { SetAccessWriteTimes((IntPtr)value.ToUnixTimeSeconds(), null); }`
`194`	`194`	`}`
`@@ -198,29 +198,29 @@ DateTimeOffset IFileSystemObject.LastWriteTime`
`198`	`198`	`get`
`199`	`199`	`{`
`200`	`200`	`EnsureStatInitialized();`
`201`		`- return DateTimeOffset.FromUnixTimeSeconds(_fileinfo.mtime).ToLocalTime();`
	`201`	`+ return DateTimeOffset.FromUnixTimeSeconds(_fileStatus.MTime).ToLocalTime();`
`202`	`202`	`}`
`203`	`203`	`set { SetAccessWriteTimes(null, (IntPtr)value.ToUnixTimeSeconds()); }`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`private void SetAccessWriteTimes(IntPtr? accessTime, IntPtr? writeTime)`
`207`	`207`	`{`
`208`		`- _fileinfoInitialized = -1; // force a refresh so that we have an up-to-date times for values not being overwritten`
	`208`	`+ _fileStatusInitialized = -1; // force a refresh so that we have an up-to-date times for values not being overwritten`
`209`	`209`	`EnsureStatInitialized();`
`210`	`210`	`Interop.libc.utimbuf buf;`
`211`		`- buf.actime = accessTime ?? new IntPtr(_fileinfo.atime);`
`212`		`- buf.modtime = writeTime ?? new IntPtr(_fileinfo.mtime);`
	`211`	`+ buf.actime = accessTime ?? new IntPtr(_fileStatus.ATime);`
	`212`	`+ buf.modtime = writeTime ?? new IntPtr(_fileStatus.MTime);`
`213`	`213`	`bool isDirectory = this is DirectoryInfo;`
`214`	`214`	`while (Interop.CheckIo(Interop.libc.utime(FullPath, ref buf), FullPath, isDirectory)) ;`
`215`		`- _fileinfoInitialized = -1;`
	`215`	`+ _fileStatusInitialized = -1;`
`216`	`216`	`}`
`217`	`217`
`218`	`218`	`long IFileSystemObject.Length`
`219`	`219`	`{`
`220`	`220`	`get`
`221`	`221`	`{`
`222`	`222`	`EnsureStatInitialized();`
`223`		`- return _fileinfo.size;`
	`223`	`+ return _fileStatus.Size;`
`224`	`224`	`}`
`225`	`225`	`}`
`226`	`226`
`@@ -231,10 +231,10 @@ void IFileSystemObject.Refresh()`
`231`	`231`	`int result;`
`232`	`232`	`while (true)`
`233`	`233`	`{`
`234`		`- result = Interop.libcoreclr.GetFileInformationFromPath(FullPath, out _fileinfo);`
	`234`	`+ result = Interop.Sys.Stat(FullPath, out _fileStatus);`
`235`	`235`	`if (result >= 0)`
`236`	`236`	`{`
`237`		`- _fileinfoInitialized = 0;`
	`237`	`+ _fileStatusInitialized = 0;`
`238`	`238`	`}`
`239`	`239`	`else`
`240`	`240`	`{`
`@@ -243,23 +243,23 @@ void IFileSystemObject.Refresh()`
`243`	`243`	`{`
`244`	`244`	`continue;`
`245`	`245`	`}`
`246`		`- _fileinfoInitialized = errorInfo.RawErrno;`
	`246`	`+ _fileStatusInitialized = errorInfo.RawErrno;`
`247`	`247`	`}`
`248`	`248`	`break;`
`249`	`249`	`}`
`250`	`250`	`}`
`251`	`251`
`252`	`252`	`private void EnsureStatInitialized()`
`253`	`253`	`{`
`254`		`- if (_fileinfoInitialized == -1)`
	`254`	`+ if (_fileStatusInitialized == -1)`
`255`	`255`	`{`
`256`	`256`	`Refresh();`
`257`	`257`	`}`
`258`	`258`
`259`		`- if (_fileinfoInitialized != 0)`
	`259`	`+ if (_fileStatusInitialized != 0)`
`260`	`260`	`{`
`261`		`- int errno = _fileinfoInitialized;`
`262`		`- _fileinfoInitialized = -1;`
	`261`	`+ int errno = _fileStatusInitialized;`
	`262`	`+ _fileStatusInitialized = -1;`
`263`	`263`	`var errorInfo = new Interop.ErrorInfo(errno);`
`264`	`264`
`265`	`265`	`// Windows distinguishes between whether the directory or the file isn't found,`
Original file line number	Diff line number	Diff line change
`@@ -43,9 +43,9 @@ public override void CopyFile(string sourceFullPath, string destFullPath, bool o`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`// Now copy over relevant read/write/execute permissions from the source to the destination`
`46`		`- Interop.libcoreclr.fileinfo fileinfo;`
`47`		`- while (Interop.CheckIo(Interop.libcoreclr.GetFileInformationFromPath(sourceFullPath, out fileinfo), sourceFullPath)) ;`
`48`		`- int newMode = fileinfo.mode & (int)Interop.libc.Permissions.Mask;`
	`46`	`+ Interop.Sys.FileStatus status;`
	`47`	`+ while (Interop.CheckIo(Interop.Sys.Stat(sourceFullPath, out status), sourceFullPath)) ;`
	`48`	`+ int newMode = status.Mode & (int)Interop.libc.Permissions.Mask;`
`49`	`49`	`while (Interop.CheckIo(Interop.libc.chmod(destFullPath, newMode), destFullPath)) ;`
`50`	`50`	`}`
`51`	`51`
`@@ -315,22 +315,22 @@ public override bool DirectoryExists(string fullPath)`
`315`	`315`
`316`	`316`	`private static bool DirectoryExists(string fullPath, out Interop.ErrorInfo errorInfo)`
`317`	`317`	`{`
`318`		`- return FileExists(fullPath, Interop.libcoreclr.FileTypes.S_IFDIR, out errorInfo);`
	`318`	`+ return FileExists(fullPath, Interop.Sys.FileTypes.S_IFDIR, out errorInfo);`
`319`	`319`	`}`
`320`	`320`
`321`	`321`	`public override bool FileExists(string fullPath)`
`322`	`322`	`{`
`323`	`323`	`Interop.ErrorInfo ignored;`
`324`		`- return FileExists(fullPath, Interop.libcoreclr.FileTypes.S_IFREG, out ignored);`
	`324`	`+ return FileExists(fullPath, Interop.Sys.FileTypes.S_IFREG, out ignored);`
`325`	`325`	`}`
`326`	`326`
`327`	`327`	`private static bool FileExists(string fullPath, int fileType, out Interop.ErrorInfo errorInfo)`
`328`	`328`	`{`
`329`		`- Interop.libcoreclr.fileinfo fileinfo;`
	`329`	`+ Interop.Sys.FileStatus fileinfo;`
`330`	`330`	`while (true)`
`331`	`331`	`{`
`332`	`332`	`errorInfo = default(Interop.ErrorInfo);`
`333`		`- int result = Interop.libcoreclr.GetFileInformationFromPath(fullPath, out fileinfo);`
	`333`	`+ int result = Interop.Sys.Stat(fullPath, out fileinfo);`
`334`	`334`	`if (result < 0)`
`335`	`335`	`{`
`336`	`336`	`errorInfo = Interop.Sys.GetLastErrorInfo();`
`@@ -340,7 +340,7 @@ private static bool FileExists(string fullPath, int fileType, out Interop.ErrorI`
`340`	`340`	`}`
`341`	`341`	`return false;`
`342`	`342`	`}`
`343`		`- return (fileinfo.mode & Interop.libcoreclr.FileTypes.S_IFMT) == fileType;`
	`343`	`+ return (fileinfo.Mode & Interop.Sys.FileTypes.S_IFMT) == fileType;`
`344`	`344`	`}`
`345`	`345`	`}`
`346`	`346`