Do not unlink pre-existing POSIX shared memory on error

`multiprocessing.shared_memory.SharedMemory` currently attempts to `unlink` a
POSIX shared memory object it has opened or created if a subsequent exception
is raised in its constructor.

This is necessary to avoid it leaking if the shared memory object was created
in the constructor, however it seems inappropriate if it is opening a
pre-existing shared memory object.

Fix this by only unlinking the shared memory object if it was created.

Author: duaneg

Lib/multiprocessing/shared_memory.py

@@ -116,7 +116,8 @@ def __init__(self, name=None, create=False, size=0, *, track=True):
                 size = stats.st_size
                 self._mmap = mmap.mmap(self._fd, size)
             except:
-                _posixshmem.shm_unlink(self._name)
+                if create:
+                    _posixshmem.shm_unlink(self._name)
                 raise
             if self._track:
                 resource_tracker.register(self._name, "shared_memory")

Lib/test/_test_multiprocessing.py

@@ -4851,6 +4851,26 @@ def test_shared_memory_tracking(self):
             resource_tracker.unregister(mem._name, "shared_memory")
             mem.close()
 
+    @unittest.skipIf(os.name != "posix", "windows automatically unlinks")
+    def test_creating_shm_unlinks_on_error(self):
+        name = self._new_shm_name("test_creating_shm_unlinks_on_error")
+        with unittest.mock.patch('mmap.mmap') as mock_mmap:
+            mock_mmap.side_effect = OSError("filesystems are evil")
+            with self.assertRaises(OSError):
+                shared_memory.SharedMemory(name, create=True, size=1)
+        with self.assertRaises(FileNotFoundError):
+            import _posixshmem
+            _posixshmem.shm_unlink(name)
+
+    def test_existing_shm_not_unlinked_on_error(self):
+        name = self._new_shm_name("test_existing_shm_not_unlinked_on_error")
+        mem = shared_memory.SharedMemory(name, create=True, size=1)
+        self.addCleanup(mem.unlink)
+        with unittest.mock.patch('mmap.mmap') as mock_mmap:
+            mock_mmap.side_effect = OSError("filesystems are evil")
+            with self.assertRaises(OSError):
+                shared_memory.SharedMemory(name, create=False)
+
     @unittest.skipIf(os.name != "posix", "posix-only test w/ empty file")
     def test_cleanup_zero_length_shared_memory(self):
         import _posixshmem
@@ -4864,9 +4884,8 @@ def test_cleanup_zero_length_shared_memory(self):
         with self.assertRaises(ValueError):
             shared_memory.SharedMemory(name, create=False)
 
-        # ...however it should delete the shared memory as part of its cleanup
-        with self.assertRaises(FileNotFoundError):
-            _posixshmem.shm_open(name, os.O_RDWR)
+        # ...but it should NOT delete the shared memory as part of its cleanup
+        _posixshmem.shm_unlink(name)
 
 #
 # Test to verify that `Finalize` works.