Address PR feedback

- Added PersistedFiles.GetTempFeatureDirectory and used it from MemoryMappedFiles (can't be used well from Pipes due to assembly layering)
- Added directory existence check in Pipes before creating the directory structure
- Recreate the pipes path when needed if it's deleted during the execution of the app (maps is already doing this)

Author: stephentoub

src/Common/src/System/IO/PersistedFiles.Unix.cs

@@ -7,8 +7,26 @@ namespace System.IO
 {
     internal static partial class PersistedFiles
     {
+        private static string s_tempProductDirectory;
         private static string s_userProductDirectory;
 
+        /// <summary>
+        /// Get the location of where to store temporary files for a particular aspect of the framework,
+        /// such as "maps".
+        /// </summary>
+        /// <param name="featureName">The directory name for the feature</param>
+        /// <returns>A path within the temp directory for storing temporary files related to the feature.</returns>
+        internal static string GetTempFeatureDirectory(string featureName)
+        {
+            string path = s_tempProductDirectory;
+            if (path == null)
+            {
+                s_tempProductDirectory = path = Path.Combine(Path.GetTempPath(), TopLevelHiddenDirectory, SecondLevelDirectory);
+            }
+
+            return Path.Combine(path, featureName);
+        }
+
         /// <summary>
         /// Get the location of where to persist information for a particular aspect of the framework,
         /// such as "cryptography".

src/System.IO.MemoryMappedFiles/src/Resources/Strings.resx

@@ -216,4 +216,7 @@
   <data name="PlatformNotSupported_NamedMaps" xml:space="preserve">
     <value>Named maps are not supported.</value>
   </data>
+  <data name="PersistedFiles_NoHomeDirectory" xml:space="preserve">
+    <value>The home directory of the current user could not be determined.</value>
+  </data>
 </root>

src/System.IO.MemoryMappedFiles/src/System.IO.MemoryMappedFiles.csproj

@@ -201,6 +201,9 @@
     <Compile Include="$(CommonPath)\System\IO\PersistedFiles.Names.Unix.cs">
       <Link>Common\System\IO\PersistedFiles.Names.Unix.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)\System\IO\PersistedFiles.Unix.cs">
+      <Link>Common\System\IO\PersistedFiles.Unix.cs</Link>
+    </Compile>
   </ItemGroup>
   <!-- Resource files -->
   <ItemGroup>

src/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Unix.BackingObject_File.cs

@@ -38,10 +38,6 @@ private static FileStream CreateSharedBackingObject(Interop.libc.MemoryMappedPro
         // ---- PAL layer ends here ----
         // -----------------------------
 
-        private static readonly string s_tempMapsDirectory = Path.Combine(
-            Path.GetTempPath(),
-            PersistedFiles.TopLevelHiddenDirectory,
-            PersistedFiles.SecondLevelDirectory,
-            "maps");
+        private static readonly string s_tempMapsDirectory = PersistedFiles.GetTempFeatureDirectory("maps");
     }
 }

src/System.IO.Pipes/src/System/IO/Pipes/PipeStream.Unix.cs

@@ -37,7 +37,7 @@ internal static string GetPipePath(string serverName, string pipeName)
             }
 
             // Return the pipe path
-            return Path.Combine(GetPipeDirectoryPath(), pipeName);
+            return Path.Combine(EnsurePipeDirectoryPath(), pipeName);
         }
 
         /// <summary>Throws an exception if the supplied handle does not represent a valid pipe.</summary>
@@ -228,31 +228,57 @@ public virtual PipeTransmissionMode ReadMode
 
         private static string s_pipeDirectoryPath;
 
-        private static string GetPipeDirectoryPath()
+        private static string EnsurePipeDirectoryPath()
         {
-            string path = s_pipeDirectoryPath;
-            if (path == null)
+            const string PipesFeatureName = "pipes";
+
+            // Ideally this would simply use PersistedFiles.GetTempFeatureDirectory(PipesFeatureName) and then
+            // Directory.CreateDirectory to ensure it exists.  But this assembly doesn't reference System.IO.FileSystem.
+            // As such, we'd be calling GetTempFeatureDirectory, only to then need to parse it in order
+            // to create each of the individual directories as part of the path.  We instead access the named portions 
+            // of the path directly and do the building of the path and directory structure manually.
+
+            // First ensure we know what the full path should be, e.g. /tmp/.dotnet/corefx/pipes/
+            string fullPath = s_pipeDirectoryPath;
+            string tempPath = null;
+            if (fullPath == null)
             {
-                // Create the pipes temporary directory, e.g. "/tmp/.dotnet/corefx/pipes".
-                // We don't have access to Directory.CreateDirectory (which handles creating
-                // all levels of the directory full path specified), so we create each nested
-                // level individually (though we assume that the temp path already exists).
-
-                path = Path.GetTempPath();
+                tempPath = Path.GetTempPath();
+                fullPath = Path.Combine(tempPath, PersistedFiles.TopLevelHiddenDirectory, PersistedFiles.SecondLevelDirectory, PipesFeatureName);
+                s_pipeDirectoryPath = fullPath;
+            }
 
-                path = Path.Combine(path, PersistedFiles.TopLevelHiddenDirectory);
-                CreateDirectory(path);
+            // Then create the directory if it doesn't already exist.  If we get any error back from stat,
+            // just proceed to build up the directory, failing in the CreateDirectory calls if there's some
+            // problem.  Similarly, it's possible stat succeeds but the path is a file rather than directory; we'll
+            // call that success for now and let this fail later when the code tries to create a file in this "directory"
+            // (we don't want to overwrite/delete whatever that unknown file may be, and this is similar to other cases
+            // we can't control where the file system is manipulated concurrently with and separately from this code).
+            Interop.Sys.FileStatus ignored;
+            bool pathExists = Interop.Sys.Stat(fullPath, out ignored) == 0;
+            if (!pathExists)
+            {
+                // We need to build up the directory manually.  Ensure we have the temp directory in which
+                // we'll create the structure, e.g. /tmp/
+                if (tempPath == null)
+                {
+                    tempPath = Path.GetTempPath();
+                }
+                Debug.Assert(Interop.Sys.Stat(tempPath, out ignored) == 0, "Path.GetTempPath() directory could not be accessed");
 
-                path = Path.Combine(path, PersistedFiles.SecondLevelDirectory);
-                CreateDirectory(path);
+                // Create /tmp/.dotnet/ if it doesn't exist.
+                string partialPath = Path.Combine(tempPath, PersistedFiles.TopLevelHiddenDirectory);
+                CreateDirectory(partialPath);
 
-                const string PipesFeatureName = "pipes";
-                path = Path.Combine(path, PipesFeatureName);
-                CreateDirectory(path);
+                // Create /tmp/.dotnet/corefx/ if it doesn't exist
+                partialPath = Path.Combine(partialPath, PersistedFiles.SecondLevelDirectory);
+                CreateDirectory(partialPath);
 
-                s_pipeDirectoryPath = path;
+                // Create /tmp/.dotnet/corefx/pipes/ if it doesn't exist
+                CreateDirectory(fullPath);
             }
-            return path;
+
+            return fullPath;
         }
 
         private static void CreateDirectory(string directoryPath)