Implement Process.Modules support on Linux

I'd previously left a comment in the implementation that we could potentially implement Process.Modules support by enumerating the contents of the procfs /procs/[pid]/maps file.  This commit does that.  It uses the heuristic that if the pathname isn't empty and the mapped region has both read and execute permissions, then the entry should be considered a module.  We can tweak this logic over time as needed.

Author: stephentoub

src/Common/src/Interop/Linux/procfs/Interop.ProcFsStat.cs

@@ -1,6 +1,10 @@
 // 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.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 
@@ -12,6 +16,7 @@ internal static partial class procfs
         internal const string SelfExeFilePath = RootPath + "self/exe";
         internal const string ProcUptimeFilePath = RootPath + "uptime";
         private const string StatFileName = "/stat";
+        private const string MapsFileName = "/maps";
         private const string TaskDirectoryName = "/task/";
 
         internal struct ParsedStat
@@ -67,16 +72,104 @@ internal struct ParsedStat
             //internal long cguest_time;
         }
 
+        internal struct ParsedMapsModule
+        {
+            internal string FileName;
+            internal KeyValuePair<long, long> AddressRange;
+        }
+
         internal static string GetStatFilePathForProcess(int pid)
         {
             return RootPath + pid.ToString(CultureInfo.InvariantCulture) + StatFileName;
         }
 
+        internal static string GetMapsFilePathForProcess(int pid)
+        {
+            return RootPath + pid.ToString(CultureInfo.InvariantCulture) + MapsFileName;
+        }
+
         internal static string GetTaskDirectoryPathForProcess(int pid)
         {
             return RootPath + pid.ToString(CultureInfo.InvariantCulture) + TaskDirectoryName;
         }
 
+        internal static IEnumerable<ParsedMapsModule> ParseMapsModules(int pid)
+        {
+            try
+            {
+                return ParseMapsModulesCore(File.ReadLines(GetMapsFilePathForProcess(pid)));
+            }
+            catch (FileNotFoundException) { }
+            catch (DirectoryNotFoundException) { }
+            catch (UnauthorizedAccessException) { }
+
+            return Array.Empty<ParsedMapsModule>();
+        }
+
+        private static IEnumerable<ParsedMapsModule> ParseMapsModulesCore(IEnumerable<string> lines)
+        {
+            Debug.Assert(lines != null);
+
+            // Parse each line from the maps file into a ParsedMapsModule result
+            foreach (string line in lines)
+            {
+                // Use a StringParser to avoid string.Split costs
+                var parser = new StringParser(line, separator: ' ', skipEmpty: true);
+
+                // Parse the address range 
+                KeyValuePair<long, long> addressRange =  
+                    parser.ParseRaw(delegate (string s, ref int start, ref int end)
+                    {
+                        long startingAddress = 0, endingAddress = 0;
+                        int pos = s.IndexOf('-', start, end - start);
+                        if (pos > 0)
+                        {
+                            string startingString = s.Substring(start, pos);
+                            if (long.TryParse(startingString, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out startingAddress))
+                            {
+                                string endingString = s.Substring(pos + 1, end - (pos + 1));
+                                long.TryParse(endingString, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out endingAddress);
+                            }
+                        }
+                        return new KeyValuePair<long, long>(startingAddress, endingAddress);
+                    });
+
+                // Parse the permissions (we only care about entries with 'r' and 'x' set)
+                if (!parser.ParseRaw(delegate (string s, ref int start, ref int end)
+                {
+                    bool sawRead = false, sawExec = false;
+                    for (int i = start; i < end; i++)
+                    {
+                        if (s[i] == 'r')
+                            sawRead = true;
+                        else if (s[i] == 'x')
+                            sawExec = true;
+                    }
+                    return sawRead & sawExec;
+                }))
+                {
+                    continue;
+                }
+
+                // Skip past the offset, dev, and inode fields
+                parser.MoveNext();
+                parser.MoveNext();
+                parser.MoveNext();
+
+                // Parse the pathname
+                if (!parser.MoveNext())
+                {
+                    continue;
+                }
+                string pathname = parser.ExtractCurrent();
+
+                // We only get here if a we have a non-empty pathname and
+                // the permissions included both readability and executability.
+                // Yield the result.
+                yield return new ParsedMapsModule { FileName = pathname, AddressRange = addressRange };
+            }
+        }
+
         private static string GetStatFilePathForThread(int pid, int tid)
         {
             // Perf note: Calling GetTaskDirectoryPathForProcess will allocate a string,

src/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs

@@ -85,7 +85,11 @@ public bool WaitForExitCore(int milliseconds)
         /// <summary>Gets the main module for the associated process.</summary>
         public ProcessModule MainModule
         {
-            get { throw new PlatformNotSupportedException(); }
+            get
+            {
+                ProcessModuleCollection pmc = Modules;
+                return pmc.Count > 0 ? pmc[0] : null;
+            }
         }
 
         /// <summary>Checks whether the process has exited and updates state accordingly.</summary>

src/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Linux.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Globalization;
 using System.IO;
 
@@ -28,6 +29,52 @@ public static int[] GetProcessIds()
             return pids.ToArray();
         }
 
+        /// <summary>Gets an array of module infos for the specified process.</summary>
+        /// <param name="processId">The ID of the process whose modules should be enumerated.</param>
+        /// <returns>The array of modules.</returns>
+        internal static ModuleInfo[] GetModuleInfos(int processId)
+        {
+            var modules = new List<ModuleInfo>();
+
+            // Process from the parsed maps file each entry representing a module
+            foreach (Interop.procfs.ParsedMapsModule entry in Interop.procfs.ParseMapsModules(processId))
+            {
+                int sizeOfImage = (int)(entry.AddressRange.Value - entry.AddressRange.Key);
+
+                // A single module may be split across multiple map entries; consolidate based on
+                // the name and address ranges of sequential entries.
+                if (modules.Count > 0)
+                {
+                    ModuleInfo mi = modules[modules.Count - 1];
+                    if (mi._fileName == entry.FileName && 
+                        ((long)mi._baseOfDll + mi._sizeOfImage == entry.AddressRange.Key))
+                    {
+                        // Merge this entry with the previous one
+                        modules[modules.Count - 1]._sizeOfImage += sizeOfImage;
+                        continue;
+                    }
+                }
+
+                // It's not a continuation of a previous entry but a new one: add it.
+                modules.Add(new ModuleInfo()
+                {
+                    _fileName = entry.FileName,
+                    _baseName = Path.GetFileName(entry.FileName),
+                    _baseOfDll = new IntPtr(entry.AddressRange.Key),
+                    _sizeOfImage = sizeOfImage,
+                    _entryPoint = IntPtr.Zero // unknown
+                });
+            }
+
+            // Return the set of modules found
+            if (modules.Count == 0)
+            {
+                // Match Windows behavior when failing to enumerate modules
+                throw new Win32Exception(SR.EnumProcessModuleFailed);
+            }
+            return modules.ToArray();
+        }
+
         // -----------------------------
         // ---- PAL layer ends here ----
         // -----------------------------

src/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.OSX.cs

@@ -70,6 +70,15 @@ private unsafe static ProcessInfo CreateProcessInfo(int pid)
             return procInfo;
         }
 
+        /// <summary>Gets an array of module infos for the specified process.</summary>
+        /// <param name="processId">The ID of the process whose modules should be enumerated.</param>
+        /// <returns>The array of modules.</returns>
+        internal static ModuleInfo[] GetModuleInfos(int processId)
+        {
+            // We currently don't provide support for modules on OS X.
+            return Array.Empty<ModuleInfo>();
+        }
+
         // ----------------------------------
         // ---- Unix PAL layer ends here ----
         // ----------------------------------

src/System.Diagnostics.Process/src/System/Diagnostics/ProcessManager.Unix.cs

@@ -77,17 +77,6 @@ public static int GetProcessIdFromHandle(SafeProcessHandle processHandle)
             return (int)processHandle.DangerousGetHandle(); // not actually dangerous; just wraps a process ID
         }
 
-        /// <summary>Gets an array of module infos for the specified process.</summary>
-        /// <param name="processId">The ID of the process whose modules should be enumerated.</param>
-        /// <returns>The array of modules.</returns>
-        public static ModuleInfo[] GetModuleInfos(int processId)
-        {
-            // Not currently supported, but we can simply return an empty array rather than throwing.
-            // Could potentially be done via /proc/pid/maps and some heuristics to determine
-            // which entries correspond to modules.
-            return Array.Empty<ModuleInfo>();
-        }
-
         /// <summary>Gets whether the named machine is remote or local.</summary>
         /// <param name="machineName">The machine name.</param>
         /// <returns>true if the machine is remote; false if it's local.</returns>

src/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests/ProcessTest.cs

@@ -229,14 +229,11 @@ public void Process_MachineName()
         public void Process_MainModule()
         {
             // Get MainModule property from a Process object
-            ProcessModule mainModule = null;
-            if (global::Interop.IsWindows)
-            {
-                mainModule = _process.MainModule;
-            }
-            else
+            ProcessModule mainModule = _process.MainModule;
+
+            if (!global::Interop.IsOSX) // OS X doesn't currently implement modules support
             {
-                Assert.Throws<PlatformNotSupportedException>(() => _process.MainModule);
+                Assert.NotNull(mainModule);
             }
 
             if (mainModule != null)
@@ -320,11 +317,13 @@ public void Process_Modules()
             {
                 // Validated that we can get a value for each of the following.
                 Assert.NotNull(pModule);
-                Assert.NotNull(pModule.BaseAddress);
-                Assert.NotNull(pModule.EntryPointAddress);
+                Assert.NotEqual(IntPtr.Zero, pModule.BaseAddress);
                 Assert.NotNull(pModule.FileName);
-                int memSize = pModule.ModuleMemorySize;
                 Assert.NotNull(pModule.ModuleName);
+
+                // Just make sure these don't throw
+                IntPtr addr = pModule.EntryPointAddress;
+                int memSize = pModule.ModuleMemorySize;
             }
         }