Initial OSX DriveInfo changes

Author: Jonathan Miller

src/Common/src/Interop/OSX/Interop.Libraries.cs

@@ -5,8 +5,10 @@ internal static partial class Interop
 {
     private static partial class Libraries
     {
+        internal const string INODE64SUFFIX = "$INODE64";
         internal const string CoreFoundationLibrary = "/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation";
         internal const string CoreServicesLibrary   = "/System/Library/Frameworks/CoreServices.framework/CoreServices";
+        internal const string libc = "libc";
         internal const string libproc = "libproc";
         internal const string LibSystemKernel = "/usr/lib/system/libsystem_kernel";
     }

src/Common/src/Interop/OSX/libc/Interop.statfs.cs

@@ -0,0 +1,90 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Runtime.InteropServices;
+
+using uid_t = System.UInt32;
+
+internal static partial class Interop
+{
+    internal static partial class libc
+    {
+        internal const int MAXPATHLEN = 1024;
+        internal const int MFSTYPENAMELEN = 16;
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal unsafe struct fsid_t
+        {
+            internal fixed int val[2];
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal unsafe struct statfs
+        {
+            internal uint       f_bsize;                        /* fundamental file system block size */
+            internal int        f_iosize;                       /* optimal transfer block size */
+            internal ulong      f_blocks;                       /* total data blocks in file system */
+            internal ulong      f_bfree;                        /* free blocks in fs */
+            internal ulong      f_bavail;                       /* free blocks avail to non-superuser */
+            internal ulong      f_files;                        /* total file nodes in file system */
+            internal ulong      f_ffree;                        /* free file nodes in fs */
+            internal fsid_t     f_fsid;                         /* file system id */
+            internal uid_t      f_owner;                        /* user that mounted the filesystem */
+            internal uint       f_type;                         /* type of filesystem */
+            internal uint       f_flags;                        /* copy of mount exported flags */
+            internal uint       f_fssubtype;                    /* fs sub-type (flavor) */
+            internal fixed byte f_fstypename[MFSTYPENAMELEN];   /* fs type name */
+            internal fixed byte f_mntonname[MAXPATHLEN];        /* directory on which mounted */
+            internal fixed byte f_mntfromname[MAXPATHLEN];      /* mounted filesystem */
+            internal fixed uint f_reserved[8];                  /* For future use */
+        }
+
+        /// <summary>
+        /// Gets all the current mount points on the system
+        /// </summary>
+        /// <param name="ppBuffer">A pointer to an array of mount points</param>
+        /// <param name="flags">Flags that are passed to the getfsstat call for each statfs struct</param>
+        /// <returns>Returns the number of retrieved statfs structs</returns>
+        /// <remarks
+        /// Do NOT free this memory...this memory is allocated by the OS, which is responsible for it.
+        /// This call could also block for a bit to wait for slow network drives.
+        /// </remarks>
+        [DllImport(Interop.Libraries.libc, EntryPoint = "getmntinfo" + Interop.Libraries.INODE64SUFFIX)]
+        internal static unsafe extern int getmntinfo(statfs** ppBuffer, int flags);
+
+        /// <summary>
+        /// Gets a statfs struct for the given path that describes that mount point
+        /// </summary>
+        /// <param name="path">The path to retrieve the statfs for</param>
+        /// <param name="buffer">The output statfs struct describing the mount point</param>
+        /// <returns>Returns 0 on success, -1 on failure</returns>
+        [DllImport(Interop.Libraries.libc, EntryPoint = "statfs" + Interop.Libraries.INODE64SUFFIX)]
+        private static unsafe extern int get_statfs(string path, statfs* buffer);
+
+        /// <summary>
+        /// Gets a statfs struct for a given mount point
+        /// </summary>
+        /// <param name="name">The drive name to retrieve the statfs data for</param>
+        /// <returns>Returns </returns>
+        internal static unsafe statfs GetStatFsForDriveName(string name)
+        {
+            statfs data = default(statfs);
+            int result = get_statfs(name, &data);
+            if (result < 0)
+                throw Interop.GetExceptionForIoErrno(Marshal.GetLastWin32Error());
+            else
+                return data;
+        }
+
+        internal static unsafe String GetMountPointName(statfs data)
+        {
+            return Marshal.PtrToStringAnsi((IntPtr)data.f_mntonname);
+        }
+
+        internal static unsafe String GetMountPointFsType(statfs data)
+        {
+            return Marshal.PtrToStringAnsi((IntPtr)data.f_fstypename);
+        }
+    }
+}

src/System.IO.FileSystem.DriveInfo/src/System.IO.FileSystem.DriveInfo.csproj

@@ -116,16 +116,18 @@
   </ItemGroup>
   <ItemGroup Condition=" '$(TargetsOSX)' == 'true' ">
     <Compile Include="System\IO\DriveInfo.OSX.cs" />
-    <Compile Include="$(CommonPath)\System\NotImplemented.cs">
-      <!-- TODO: Remove once implemented -->
-      <Link>Common\System\NotImplemented.cs</Link>
-    </Compile>
     <Compile Include="$(CommonPath)\Interop\OSX\Interop.Errors.cs">
       <Link>Common\Interop\OSX\Interop.Errors.cs</Link>
     </Compile>
     <Compile Include="$(CommonPath)\System\IO\PathInternal.CaseInsensitive.cs">
       <Link>Common\System\IO\PathInternal.CaseInsensitive.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)\Interop\OSX\Interop.Libraries.cs">
+      <Link>Common\Interop\OSX\Interop.Libraries.cs</Link>
+    </Compile>
+    <Compile Include="$(CommonPath)\Interop\OSX\libc\Interop.Mount.cs">
+      <Link>Common\Interop\OSX\Interop.Mount.cs</Link>
+    </Compile>
   </ItemGroup>
   <ItemGroup>
     <None Include="project.json" />

src/System.IO.FileSystem.DriveInfo/src/System/IO/DriveInfo.Linux.cs

@@ -171,151 +171,5 @@ private static unsafe string DecodeString(byte* str)
         {
             return str != null ? Marshal.PtrToStringAnsi((IntPtr)str) : null;
         }
-
-        /// <summary>Categorizes a file system name into a drive type.</summary>
-        /// <param name="fileSystemName">The name to categorize.</param>
-        /// <returns>The recognized drive type.</returns>
-        private static DriveType GetDriveType(string fileSystemName)
-        {
-            // This list is based primarily on "man fs", "man mount", "mntent.h", "/proc/filesystems",
-            // and "wiki.debian.org/FileSystem". It can be extended over time as we 
-            // find additional file systems that should be recognized as a particular drive type.
-            switch (fileSystemName)
-            {
-                case "iso":
-                case "isofs":
-                case "iso9660":
-                case "fuseiso":
-                case "fuseiso9660":
-                case "umview-mod-umfuseiso9660":
-                    return DriveType.CDRom;
-
-                case "adfs":
-                case "affs":
-                case "befs":
-                case "bfs":
-                case "btrfs":
-                case "ecryptfs":
-                case "efs":
-                case "ext":
-                case "ext2":
-                case "ext3":
-                case "ext4":
-                case "ext4dev":
-                case "fat":
-                case "fuseblk":
-                case "fuseext2":
-                case "fusefat":
-                case "hfs":
-                case "hfsplus":
-                case "hpfs":
-                case "jbd":
-                case "jbd2":
-                case "jfs":
-                case "jffs":
-                case "jffs2":
-                case "minix":
-                case "msdos":
-                case "ocfs2":
-                case "omfs":
-                case "ntfs":
-                case "qnx4":
-                case "reiserfs":
-                case "squashfs":
-                case "swap":
-                case "sysv":
-                case "ubifs":
-                case "udf":
-                case "ufs":
-                case "umsdos":
-                case "umview-mod-umfuseext2":
-                case "xenix":
-                case "xfs":
-                case "xiafs":
-                case "xmount":
-                case "zfs-fuse":
-                    return DriveType.Fixed;
-
-                case "9p":
-                case "autofs":
-                case "autofs4":
-                case "beaglefs":
-                case "cifs":
-                case "coda":
-                case "coherent":
-                case "curlftpfs":
-                case "davfs2":
-                case "dlm":
-                case "flickrfs":
-                case "fusedav":
-                case "fusesmb":
-                case "gfs2":
-                case "glusterfs-client":
-                case "gmailfs":
-                case "kafs":
-                case "ltspfs":
-                case "ncpfs":
-                case "nfs":
-                case "nfs4":
-                case "obexfs":
-                case "s3ql":
-                case "smb":
-                case "smbfs":
-                case "sshfs":
-                case "sysfs":
-                case "wikipediafs":
-                    return DriveType.Network;
-
-                case "anon_inodefs":
-                case "aptfs":
-                case "avfs":
-                case "bdev":
-                case "binfmt_misc":
-                case "cgroup":
-                case "configfs":
-                case "cramfs":
-                case "cryptkeeper":
-                case "cpuset":
-                case "debugfs":
-                case "devpts":
-                case "devtmpfs":
-                case "encfs":
-                case "fuse":
-                case "fuse.gvfsd-fuse":
-                case "fusectl":
-                case "hugetlbfs":
-                case "libpam-encfs":
-                case "ibpam-mount":
-                case "mtpfs":
-                case "mythtvfs":
-                case "mqueue":
-                case "pipefs":
-                case "plptools":
-                case "proc":
-                case "pstore":
-                case "pytagsfs":
-                case "ramfs":
-                case "rofs":
-                case "romfs":
-                case "rootfs":
-                case "securityfs":
-                case "sockfs":
-                case "tmpfs":
-                    return DriveType.Ram;
-
-                case "gphotofs":
-                case "usbfs":
-                case "vfat":
-                    return DriveType.Removable;
-
-                case "aufs": // marking all unions as unknown
-                case "funionfs":
-                case "unionfs-fuse":
-                case "mhddfs":
-                default:
-                    return DriveType.Unknown;
-            }
-        }
-
     }
 }